Java学习记录 Day7（继承、方法重写、final、多态）

Day 7

2019年4月13日。
这是我学习Java的第七天。
这一天，我学到了以下的知识。

代码块

在Java中，使用{}括起来的代码被称为代码块。

代码块根据定义的位置不同，分为：

1. 局部代码块：在方法中出现；限定变量生命周期，及早释放，提高内存利用率
2. 构造代码块：在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行
3. 静态代码块：在类中方法外出现，加了static修饰。
   在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且只执行一次。

其中，执行顺序为：静态代码块>构造代码块>局部代码块

面试题：看程序判断代码块的执行顺序

class Student {
		static {
			System.out.println("Student 静态代码块"); //3
		}
		
		{
			System.out.println("Student 构造代码块"); //4 6
		}
		
		public Student() {
			System.out.println("Student 构造方法"); //5 7
		}
	}

	class StudentDemo {
		static {
			System.out.println("StudentDemo的静态代码块");//1
		}
		
		public static void main(String[] args) {
			System.out.println("我是main方法");//2
			
			Student s1 = new Student();
			Student s2 = new Student();
		}
	}
	//执行顺序如代码所示

继承

继承是指子类可以继承父类的成员，并且可以使用。子类和父类之间通过关键字 extend 来产生继承关系。

特点：

1. 继承的思想：将所有子类的共性功能，向上抽取到父类当中

2. 继承的优点：提高了代码的复用性和维护性

3. 继承的弊端：增加了耦合性

4. 软件的设计原则：高内聚（一个类单独完成某个功能的能力），低耦合（一个类要完成某个功能，得去依赖某些类）

继承的注意事项：

1. Java中只支持单继承，但是支持多层继承。object是所有类的顶层父类，所有类都是直接或间接继承它
2. 父类私有的成员，子类不能继承
3. 构造方法不参与继承
4. 不要为了部分功能而去继承，会增加耦合性
5. 创建子类对象时，先去执行父类的空参构造（父类会比子类先初始化。因为子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化）
6. super是父类空间的一个标识，可以理解为父类的一个引用，可以用super去访问父类的数据（成员变量、成员方法、构造方法）
7. 在每个类的构造方法的第一行，都会默认有super()，调用父亲的空参构造，先完成父类数据的初始化

假如父类里面没有提供空参构造怎么办

public class MyTest {
    public static void main(String[] args) {
        //Zi zi = new Zi();
        //Zi zi = new Zi(1009);
        ////假如我父类里面没有提供空参构造怎么办？
        ////1.那子类可以去调父类有参构造
        ////2.先用this(参数)本类的有参构造，然后你调用的那个构造又去调用父类的有参构造
        //System.out.println(zi.num);
        Zi zi = new Zi();

    }
}

class Fu{
    int num=10;

    public Fu() {
        super();
        System.out.println("父类的空参构造执行了");
    }

    public Fu(int num) {
        super();
        this.num = num;
        System.out.println("父类的有参构造执行了");
    }
}

class Zi extends Fu{
    int num=100;
    public Zi() {
        super(10);
       // this(10000);
        System.out.println("子类的空参构造执行了");
    }

    public Zi(int num) {
        super(num);
        System.out.println("子类的有参构造执行了");
    }
}

方法重写

当子类出现了和父类一模一样的方法（方法名，参数列表，返回值类型一样）就会发生子类的方法覆盖父类的方法。

特点：

1. 作用：如果子类对父类的方法不满意，那么子类就可以覆盖它，或者说，子类想要对父类的方法实现功能拓展，也可以使用方法重写
2. @Override：注解。可以检测此方法是否是重写父类的方法
3. 静态成员方法不发生重写
4. 父类私有的方法，子类无法重写
5. 子类在重写父类方法时，权限修饰符不能比父类的低，要比父类的高或者一样（最好一样，修饰符大小比较：public > protected > 默认 > private）
6. 静态方法不算重写

final

最终的，可以修饰变量，类，成员方法。

final修饰特点：

• 修饰变量，此变量为自定义常量
• 修饰类，此类不能被继承
• 修饰方法，此方法不能被重写，子类可以原封不动的继承下去用
• 修饰基本数据类型，此值不能再改变
• 修饰引用数据类型，此地址值不能再改变

多态

多态，指的是某一个成员，在不同时刻表现出来的不同状态。

特点：

1. 继承是多态的前提
2. 多态的必要条件

• 要有继承

• 要有方法重写（可以没有，但是多态就没有意义）

• 父类引用要指向子类对象（父 f = new 子();）

3. 多态中成员变量的访问特点

• 成员变量：编译看左边，运行看左边

• 构造方法：创建子类对象的时候，会访问父类的构造方法，对父类的数据进行初始化

• 成员方法：编译看左边，运行看右边
• 静态方法：编译看左边，运行看左边（静态和类相关，算不上重写，所以，访问还是左边的）

4. 多态的优点：提高代码的复用性和扩展性
5. 多态的缺点：不能访问子类独有的功能。父类引用不能访问子类独有的方法，若想访问，可以向下转型
6. 以多态的形式来访问成员变量，使用的还是父类的变量
7. 以多态的形式来访问成员方法，编译看左边，运行看右边（以子类为准）

多态的经典算法（孔子装爹）

• 孔子装爹
  孔子爹，是西开的一个高级讲师，会讲授java。李四闻名而来，请孔子爹到他家里给他讲java。
  孔子爹就留孔子一个人在家，这时候张三也来让孔子爹来讲java。孔子爹这时候不在家，那孔子又不想失去这个学生，所以孔子，假扮成他爹，给张三讲论语。
  讲完之后，孔子好累，玩游戏休息下，那么这套装备，去玩游戏。

  代码如下

public class MyTest {
    public static void main(String[] args) {
        孔子爹 坑爹 = new 孔子();
        System.out.println(坑爹.age);
        坑爹.teache();
        //向下转型，做回他自己
        孔子 k = (孔子) 坑爹;
        System.out.println(k.age);
        k.playGame();

      //  老师 学生 都属于人类  睡觉和吃饭  学生睡觉打呼噜  老师睡觉要搂老婆  学生个性功能玩游戏，老师个性功能教书
    }
}

class 孔子爹 {
    int age = 60;

    public void teache() {
        System.out.println("讲授java");
    }

}

class 孔子 extends 孔子爹 {
    int age = 30;

    @Override
    public void teache() {
        System.out.println("讲授论语");
    }

    public void playGame() {
        System.out.println("玩王者荣耀");
    }
}