• day_08


    --暑假学习第八天--

    一.单例设计模式

    保证一个类在内存中只有一个对象。

    模式:模式就是解决 一类 问题的固定步骤 。

    模式的概念最早起源于建筑行业....
     
    建房子的步骤都是一样:
     
     打地基-------> 浇柱子-------->盖楼面--------->砌墙--------->封顶-------->装修--------->入住
     
    软件行业中的几种设计模式:
     单例设计模式
     模板设计模式
     装饰者设计模式
     观察者设计模式
     工厂设计模式
     
    二.单例设计模式的步骤: 

    饿汉单例设计模式
     1. 私有化构造函数。
     2. 声明本类的引用类型变量,并且使用该变量指向本类对象。
     3. 提供一个公共静态的方法获取本类的对象。
     
    懒汉单例设计模式:
     1. 私有化构造函数。
     2. 声明本类的引用类型变量,但是不要创建对象,
     3. 提供公共静态 的方法获取本类 的对象,获取之前先判断是否已经创建了本类 对象
     ,如果已经创建了,那么直接返回对象即可,如果还没有创建,那么先创建本类的对象,
     然后再返回。

    推荐使用: 饿汉单例设计模式。  因为懒汉单例设计模式会存在线程安全问题,目前还不能保证一类在内存中只有一个对象。
     
    eg:
    //饿汉单例设计模式 ----> 保证Single在在内存中只有一个对象。
    class Single{
    
    	//声明本类的引用类型变量,并且使用该变量指向本类对象
    	private static	Single s = new Single();
    
    	//私有化构造函数
    	private Single(){}
    
    	//提供一个公共静态的方法获取本类的对象
    	public	static  Single getInstance(){
    		return s;
    	}
    }
    
    class Test{
        public static Test t=new Test();
        private Test{}
        public static Test getInstance(){
        return t;
        }
    }
    
    class Test{
        public static Test t;
        private Test{}
        public static Test getInstance(){
        if(t==null){
           t=new Test();
        }
       return t;
      }
    }
    

      

    //懒汉单例设计模式 ----> 保证Single在在内存中只有一个对象。
    
    class Single2{
    	
    	//声明本类的引用类型变量,不创建本类的对象
    	private static Single2 s;
    
    	//私有化了构造函数
    	private Single2(){}
    
    	//
    	public static Single2 getInstance(){
    		if(s==null){
    			s = new Single2();
    		}
    		return s;
    	}
    }
    
    
    class Demo5
    {
    	public static void main(String[] args) 
    	{
    		Single2 s1 = Single2.getInstance();
    		Single2 s2 = Single2.getInstance();
    		System.out.println("是同一个对象吗?"+ (s1==s2));
    
    	}
    }
    

     

    三.继承

    继承:继承是通过关键字extends体现的。
     
    继承的格式:
     class 类名1 extends 类名2{
     
     }
     
    继承要注意的事项:
     1. 千万不要为了减少重复代码而去继承,只有真正存在着继承关系的时候才去继承。
     2. 父类私有的成员不能被继承。
     3. 父类的构造函数不能被继承。
     4. 创建子类对象时默认会先调用父类无参的构造函数。
     
    eg:
    //人类 
    class Person{
    	
    	String name;
    
    	private	int age;
    
    	public  Person(String name){
    		this.name = name;
    	}
    
    	public Person(){
    		System.out.println("Person类的构造方法被调用了....");
    	}
    
    	public void eat(){
    		System.out.println(name+"在吃饭...");
    	}
    }
    
    //学生类
    class Student extends Person {  // Student 就称作为Person类的子类, Person类就称作为Student的父类(超类、基类)
    
    	int num; //学号
    
    	public Student(){
    		System.out.println("Student类的构造方法被调用了....");
    	}
    
    	public void study(){
    		System.out.println(name+"good good study , day day up");
    	}	
    }
    
    
    class Demo
    {
    	public static void main(String[] args) 
    	{
    		Student s = new Student();
    		s.name = "狗娃";
    		System.out.println("名字:"+ s.name);
    		s.eat();
    		
    	}
    }
    

      

  • 相关阅读:
    从键盘输入10个数,计算出正数和负数的个数。
    浏览器允许的并发请求资源数 优化
    strict 严格模式
    AMD 和 CMD 的区别
    Canvas
    visual filters 滤镜 ie
    ie 如何判断正在执行的脚本
    async
    富文本编辑器
    检测CSS属性 是否支持
  • 原文地址:https://www.cnblogs.com/seduce-bug/p/9361365.html
Copyright © 2020-2023  润新知