静态 继承

一、静态

1.1 static修饰成员变量

        Java中的成员变量按照有无static修饰分为两种：类变量、实例变量。

        类变量：有static修饰，属于类，在计算机里只有一份，会被类的全部对象共享。

        实例变量（对象的变量）：无static修饰，属于每个对象的。

        由于静态变量是属于类的，只需要通过类名就可以调用：类名.静态变量

        实例变量是属于对象的，需要通过对象才能调用：对象.实例变量

        实例变量与静态变量的内存原理：    

1.2 static修饰成员方法

    

有static修饰的方法，是属于类的，称为类方法；调用时直接用类名调用即可。

无static修饰的方法，是属于对象的，称为实例方法；调用时，需要使用对象调用。

static修饰成员变量的内存原理：

1.3 工具类

        如果一个类中的方法全都是静态的，那么这个类中的方法就全都可以被类名直接调用，由于调用起来非常方便，就像一个工具一下，所以把这样的类就叫做工具类。

自定义一个生成验证码的工具类：

public class MyUtils{
    //构造私有化，防止使用者用对象调用
    private MyUtils(){}
        

    public static String createCode(int n){
        //1.定义一个字符串，用来记录产生的验证码
        String code = "";
        
        //2.验证码是由所有的大写字母、小写字母或者数字字符组成
        //这里先把所有的字符写成一个字符串，一会从字符串中随机找字符
        String data = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKMNOPQRSTUVWXYZ";
        
        //3.循环n次，产生n个索引,再通过索引获取字符
        Random r = new Random();
        for(int i=0; i<n; i++){
            int index = r.nextInt(data.length());
            char ch = data.charAt(index);
            //4.把获取到的字符，拼接到code验证码字符串上。
            code+=ch;
        }
        
        //最后返回code,code的值就是验证码
        return code;
    }
}

//比如这是一个登录界面
public class LoginDemo{
    public static void main(String[] args){
        System.out.println(MyUtils.createCode());
    }
}

1.4 static的注意事项

        类方法中可以直接访问类的成员，不可以直接访问实例成员。

        实例方法中既可以直接访问类成员，也可以直接访问实例成员。

        实例方法中可以出现this关键字，类方法中不可以出现this关键字。

public class Student {
    static String schoolName; // 类变量
    double score; // 实例变量

    // 1、类方法中可以直接访问类的成员，不可以直接访问实例成员。
    public static void printHelloWorld(){
        // 注意：同一个类中，访问类成员，可以省略类名不写。
        schoolName = "黑马";
        printHelloWorld2();

        System.out.println(score); // 报错的
        printPass(); // 报错的

        ystem.out.println(this); // 报错的
    }
    
	// 类方法
    public static void printHelloWorld2(){

    }
    
    // 实例方法
    public void printPass2(){

    }
    
    // 实例方法
    // 2、实例方法中既可以直接访问类成员，也可以直接访问实例成员。
    // 3、实例方法中可以出现this关键字，类方法中不可以出现this关键字的
    public void printPass(){
        schoolName = "黑马2"; //对的
        printHelloWorld2(); //对的

        System.out.println(score); //对的
        printPass2(); //对的

        System.out.println(this); //对的
    }
}

1.5 static应用（代码块）

        代码块根据有无static修饰分为两种：静态代码块、实例代码块

public class Student {
    static int number = 80;
    static String schoolName = "beida";
    // 静态代码块
    static {
        System.out.println("静态代码块执行了~~");
        schoolName = "beida";
    }
}

静态代码块不需要创建对象就能够执行

public class Test {
    public static void main(String[] args) {
        // 目标：认识两种代码块，了解他们的特点和基本作用。
        System.out.println(Student.number);
        System.out.println(Student.number);
        System.out.println(Student.number);

        System.out.println(Student.schoolName); // beida
    }
}

关于静态代码块重点注意：静态代码块，随着类的加载而执行，而且只执行一次。

实例代码块的作用和构造器的作用是一样的，用来给对象初始化值；而且每次创建对象之前都会先执行实例代码块。

public class Student{
    //实例变量
	int age;
    //实例代码块：实例代码块会执行在每一个构造方法之前
    {
        System.out.println("实例代码块执行了~~");
        age = 18;
        System.out.println("有人创建了对象：" + this);
    }

    public Student(){
        System.out.println("无参数构造器执行了~~");
    }

    public Student(String name){
        System.out.println("有参数构造器执行了~~");
    }
}

接下来在测试类中进行测试，观察创建对象时，实例代码块是否先执行了。

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student();
        Student s2 = new Student("张三");
        System.out.println(s1.age);
        System.out.println(s2.age);
    }
}

对于实例代码块重点注意：实例代码块每次创建对象之前都会执行一次

二、继承

2.1 继承

特点：子类继承父类所有非私有成员（变量、方法）

继承后对象的创建：子类的对象是由子类和父类共同完成的

继承的执行原理：

继承的好处：提高代码的复用性

2.2 权限修饰符

每一种权限修饰符能够被访问的范围如下：

2.3 单继承、Object

Java语言只支持单继承，不支持多继承，但是可以多层继承。就像家族里儿子、爸爸和爷爷的关系一样：一个儿子只能有一个爸爸，不能有多个爸爸，但是爸爸也是有爸爸的。

所有类都默认继承Object类，即Object类是所有类的父类。

2.4 方法重写

当子类觉得父类方法不好用，或者无法满足父类需求时，子类可以重写一个方法名称、参数列表一样的方法，去覆盖父类的这个方法，这就是方法重写。

注意：重写后，方法的访问遵循就近原则。

2.5 子类中访问成员的特点

原则：在子类中访问其他成员（成员变量、成员方法），是依据就近原则的

如果子类和父类出现同名变量或者方法，优先使用子类的；此时如果一定要在子类中使用父类的成员，可以加this或者super进行区分。

2.6 子类中访问构造器的特点

首先，子类全部构造器，都会先调用父类构造器，再执行自己。

如果不想使用默认的super()方式调用父类构造器，还可以手动使用super(参数)调用父类有参数构造器。

有时候我们也需要访问自己类的构造器。

最后再总结一下this和super的用法

访问本类成员：
	this.成员变量	//访问本类成员变量
	this.成员方法	//调用本类成员方法
	this()		   //调用本类空参数构造器
    this(参数)	  //调用本类有参数构造器
	
访问父类成员：
	super.成员变量	//访问父类成员变量
	super.成员方法	//调用父类成员方法
	super()		   //调用父类空参数构造器
    super(参数)	  //调用父类有参数构造器
    
注意：this和super访问构造方法，只能用到构造方法的第一句，否则会报错。