Java基础 类的继承/重写+static+饿汉懒汉设计模式

static 静态成员

用来修饰静态成员对象

使用 static 修饰的成员对象会和类一起被加载 所以在 static 修饰的成员对象中无法使用实例对象（实例对象尚未加载）如下

public class staticCs {
    String name = "张三";
    static public void  getName(){
        System.out.println(name); //提示无法从 static 上下文引用非 static 字段 'name'
    }
}

而在实例对象中则可以调用static所修饰的成员对象如下

    static String name = "张三";
    public void  getName(){
        System.out.println(name);//输出张三
    }

静态/构造代码块 

静态代码块

    //主要用来初始化实例对象随着类的加载而加载
    //static String name;先执行变量定义 再执行代码块
    static {
        name = "张三";
    }
    static String name;  //顺序不会影响执行效果

构造代码块

/*每一次初始化实例对象new都会触发 用于初始化实例对象 了解即可，因为变量对象的值很少有固定的，
通常都在初始化实例对象new时传实参赋值*/
  public class staticCs {
     String name;
     {
        name = "张三";
    }
    //staticCs newStaticCs = new staticCs("张三") 
    public staticCs(String name){
         this.name = name;
    }
  }

饿汉/懒汉模式（均为单例模式）

//单例模式  保证一个类仅有一个实例，并提供一个访问它的全局访问点

//饿汉
public class staticCs {
    //通过类名 staticCs.newStaticCs  调用使用的是同一个实例
    static staticCs newStaticCs = new staticCs(); 
     
     private staticCs(){
        
    }
}
//饥汉模式
public class staticCs {
    static staticCs newStaticCs;
    private staticCs(){

    }
    //通过方法来返回 实例
    static staticCs getNewStaticCs(){
        if(newStaticCs == null){
            newStaticCs = new staticCs();
        }
        return newStaticCs;
    }
}

类的继承/重写

继承的特点：

1、只支持单继承，即一个子类只允许有一个父类。

2、子类可以拥有父类的属性和方法。

3、子类可以重写覆盖父类的方法。

4、子类可以重写覆盖父类的方法。

5、可继承父类私有化变量只是无法直接访问

重写的注意事项

1、重写时方法的名称、形参列表必须与被重写方法的名称和参数列表一致。

2、私有方法不能被重写。

3、子类重写父类方法时，访问权限必须大于或者等于父类（缺省<protected<public）

4、子类不能重写父类静态方法。重写会报错

//父类

public class OldPhone {
    String name = "张三";
    public void CallUp(){
        System.out.println("打电话");
    }
    public void sendMessage(){
        System.out.println("发信息");
    }
}

//子类
//public class 类名(当前类） extends 类名(要从哪个类那继承对象属性）
// NewPhone  继承了 OldPhone 的对象属性
public class NewPhone extends OldPhone {
    
    //当出现同名变量时 会采用就近原则 不管类型是否相同
    int name = 123;
    // 假设传来的name 参数为 李四
    public void getName(String name){
        //this指向当前原型对象  super指向父类的原型对象 name则是当前方法中的变量名
        //输出张三打视频给123,李四接听了
        System.out.println(super.name + "打视频给" + this.name+"，"+name+"接听了");
    }
    
   @Override  //重写注释 可检测是不是重写父/祖的方法（不是会报错） 提高代码可读性
    public void CallUp(){
        super.CallUp();//通过super调用父类对象中的方法≈在原有方法基础上进行增强
        System.out.println("打视频");//调用 子类中的CallUp 将输出打电话 \n 打视频
    }

   @Override
   public void sendMessage(){
       super.sendMessage();
       System.out.println("语音");
   }
}

private私有变量的继承

// 在继承父类时 也会继承私有化变量只是无法直接访问 可通过继承父类的方法进行 读/改  
//父类
public class People {
    //私有变量name
    private String name;
    
    //获取name值
    public String getName() {
        return name;
    }
    //设置name值
    public void setName(String name) {
        this.name = name;
    }
    // 无参构造器
    public People(){
        
    }
    //有参构造器
    public People(String name){
        this.name = name
    }

    
}
//子类

public class Student extends People {

    public void getName2() {
        
        System.out.println(this.getName());
    }
    //
    public Student (){
        //  会默认生成super()来调用父类的无参构造器 
    }
    public Student (String name){
        super(name)  //调用父类的有参构造器
    }
}