Java SE 19-24讲 Lesson2

1. 多态：父类型的引用可以指向子类型的对象。[color=red] 具体指向的是父类的对象还是子类的对象只有在运行的时候才确定，编译的时候不确定。[/color]

2. Parent p = new Child();当使用多态方式调用方法时，首先检查父类中是否有sing()方法，如果没有则编译错误；如果有，再去调用子类的sing()方法。 如果子类没有，则用继承下来的(动态绑定，又叫做晚绑定)。

[color=red]注意：早绑定不属于多态，方法的重载不是多态！[/color]

3. 一共有两种类型的强制类型转换：
a) 向上类型转换（upcast）：比如说将Cat类型转换为Animal类型，即将子类型转换为父类型。对于向上类型转换，不需要显式指定。
b) 向下类型转换（downcast）：比如将Animal类型转换为Cat类型。即将父类型转换为子类型。对于向下类型转换，必须要显式指定（必须要使用强制类型转换）。

[color=red]注：用子类特有的必须向下转型。如果转成其他子类则运行会报错，编译不会报错，换句话说：实例的哪个子类，就转成那个子类，不能转成其他子类。编译不会报错，运行会报错，属于晚绑定。[/color]

public class PolyTest2 {
	public static void main(String[] args) {
		/*
		 * Animal animal = new Cat(); 
		 * Animal animal2 = new Animal();
		 * animal2 = animal; 
		 * animal2.sing();
		 */

		/*
		 * Animal animal = new Cat(); 
		 * Animal animal2 = new Animal();
		 * animal = animal2; 
		 * animal.sing();
		 */

		/*
		 * Cat cat = new Cat(); 
		 * Animal animal = cat; 
		 * animal.sing();
		 */

		/*
		 * Animal animal = new Animal(); 
		 * Cat cat = (Cat)animal;//Animal指向的是Animal还是Cat只有在执行的时候才能确定， 此时会报转型错误
		 */

		// 向上类型转换
		Cat cat = new Cat();
		Animal animal = cat;
		animal.sing();

		// 向下类型转换
		Animal a = new Cat();
		Cat c = (Cat) a;//真正指向谁才能转成谁 c可以调用子类特有的
		c.sing();//c.sing(); a.sing(); 结果是一样的，但是a只能调用子类中方法在父类中有的


	}
}

class Animal {
	public void sing() {
		System.out.println("animal is singing");
	}
}

class Dog extends Animal {
	public void sing() {
		System.out.println("dog is singing");
	}
}

class Cat extends Animal {
	public void sing() {
		System.out.println("cat is singing");
	}
}

[color=blue]动态调用体现(只有在运行的时候才能确定是指向的哪个对象)：[/color]

public class PolyTest4 {

	public static void main(String[] args) {
		A a = null;

		if (args[0].equals("1")) {
			a = new B();
		} else if (args[0].equals("2")) {
			a = new C();
		} else if (args[0].equals("3")) {
			a = new D();
		}

		a.method();//a指向的是哪个对象只有在运行的时候，根据传的参数才能确定。Java虚拟机编译好后不知道a调用的是哪个对象的方法，在运行的时候才确定（晚绑定）
	}
}

class A {
	public void method() {
		System.out.println("A");
	}
}

class B extends A {
	public void method() {
		System.out.println("B");
	}
}

class C extends A {
	public void method() {
		System.out.println("C");
	}
}

class D extends A {
	public void method() {
		System.out.println("D");
	}
}

[color=blue]多态在开发中的应用：[/color]

package lesson2;

public class PolyTest5 {

//	public void run(BMW bmw) {
//		bmw.run();
//	}

//	public void run(QQ qq) {
//		qq.run();
//	}

	public void run(Car car) {
		car.run();
	}

	public static void main(String[] args) {
//		PolyTest5 test = new PolyTest5();
//		BMW bmw = new BMW();
//		test.run(bmw);
//		QQ qq = new QQ();
//		test.run(qq);

		PolyTest5 test = new PolyTest5();
		Car car = new BMW();
		test.run(car);
		car = new QQ();
		test.run(car);
	}
}

class Car {
	public void run() {
		System.out.println("car is running");
	}
}

class BMW extends Car {
	public void run() {
		System.out.println("BMW is running");
	}
}

class QQ extends Car {
	public void run() {
		System.out.println("QQ is running");
	}
}

4. 抽象类（abstract class）：使用了[color=blue]abstract[/color]关键字所修饰的类叫做抽象类。抽象类无法实例化，也就是说，[color=blue]不能new出来一个抽象类的对象[/color]（实例）。

5. 抽象方法（abstract method）：使用[color=blue]abstract[/color]关键字所修饰的方法叫做抽象方法。[color=blue]抽象方法需要定义在抽象类中。[/color]相对于抽象方法，之前所定义的方法叫做具体方法（有声明，有实现）。

6. 如果一个类包含了抽象方法，那么这个类一定是抽象类。

7. 如果某个类是抽象类，那么该类可以包含具体方法（有声明、有实现）。

8. 如果一个类中包含了抽象方法，那么这个类一定要声明成abstract class，也就是说，该类一定是抽象类；反之，如果某个类是抽象类，那么该类既可以包含抽象方法，也可以包含具体方法。 也可以什么都没有，也可以全部是具体方法。但是不能实例化。

9. 无论何种情况，只要一个类是抽象类，那么这个类就无法实例化。

10. 在子类继承父类（父类是个抽象类）的情况下，那么该子类必须要实现父类中所定义的所有抽象方法；否则，该子类需要声明成一个abstract class。

11. 接口（interface）：接口的地位等同于class，接口中的所有方法都是抽象方法。[color=blue]在声明接口中的方法时，可以使用abstract关键字，也可以不使用。通常情况下，都会省略掉abstract关键字。 [/color]

12. [color=blue]可以将接口看作是特殊的抽象类（抽象类中可以有具体方法，也可以有抽象方法，而接口中只能有抽象方法，不能有具体方法）。 [/color]

3. 类可以实现接口。实现使用关键字implements表示，代表了某个类实现了某个接口。

14. [color=blue]一个类实现了某个接口，那么该类必须要实现接口中声明的所有方法。如果该类是个抽象类，那么就无需实现接口中的方法了。 [/color]

15. [color=blue]Java是单继承的，也就是说某个类只能有唯一一个父类；一个类可以实现多个接口，多个接口之间使用逗号分隔。[/color]

16. [color=blue]多态：所谓多态，就是父类型的引用可以指向子类型的对象，或者接口类型的引用可以指向实现该接口的类的实例。[/color][color=red]关于接口与实现接口的类之间的强制类型转换方式与父类和子类之间的强制类型转换方式完全一样。 [/color]

17. [color=blue]static关键字：可以用于修饰属性，也可以用于修饰方法，还可以用于修饰类（后面的课程讲） [/color]

18. static修饰属性：无论一个类生成了多少个对象，所有这些对象共同使用唯一一份静态的成员变量；一个对象对该静态成员变量进行了修改，其他对象的该静态成员变量的值也会随之发生变化。如果一个成员变量是static的，那么我们可以通过类名.成员变量名的方式来使用它（推荐使用这种方式）。

19. static修饰方法：static修饰的方法叫做静态方法。对于静态方法来说，可以使用类名.方法名的方式来访问。

20.[color=red] 静态方法只能继承，不能重写（Override）。 [/color]

21. final关键字：final可以修饰属性、方法、类。

22. final修饰类：当一个类被final所修饰时，表示该类是一个终态类，即不能被继承。

23. final修饰方法：当一个方法被final所修饰时，表示该方法是一个终态方法，即不能被重写（Override）。

24. final修饰属性：当一个属性被final所修饰时，表示该属性不能被改写。

25. [color=blue]当final修饰一个原生数据类型时，表示该原生数据类型的值不能发生变化（比如说不能从10变为20）；如果final修饰一个引用类型时，表示该引用类型不能再指向其他对象了，但该引用所指向的对象的内容是可以发生变化的。 [/color]

26. 对于final类型成员变量，一般来说有两种赋初值方式：
a) 在声明final类型的成员变量时就赋上初值
b) 在声明final类型的成员变量时不赋初值，但在类的所有构造方法中[color=red]都[/color]为其赋上初值。

package lesson2;

public class FinalTest4 {
	final int a;//对于final类型必须显示赋(两种方法)。 如果非final则这样写可以(final属性则要么声明时赋值要么构造方法中赋值)，默认为0

	/**
	 * final：赋值的两种方法： 1、声明时赋值 ；  2、构造方法中赋值。
	 * 两种方法不能同时用：new一个对象时声明时有赋值，构造方法中又去赋值，说明去改变值，与final违背
	 */
	public FinalTest4() {
		a = 0;
	}

	/**
	 * 声明final时不赋值，则要在所有构造方法都要赋值。
	 * @param a
	 */
	public FinalTest4(int a) {
		this.a = a;
	}

	public static void main(String[] args) {
		System.out.println(new FinalTest4().a);
	}
}

27. static代码块：静态代码块。静态代码块的作用也是完成一些初始化工作。首先执行静态代码块，然后执行构造方法。静态代码块在类被加载的时候执行，而构造方法是在生成对象的时候执行；要想调用某个类来生成对象，首先需要将类加载到Java虚拟机上（JVM），然后由JVM加载这个类来生成对象。

package lesson2;

/**
 * 静态代码块：放在类里面与方法、属性同一层次
 * @author jie.guo
 *
 */
public class StaticTest4 {
	//Java->class->加载到Java虚拟机(一个声明周期只加载一次)(执行静态块)->生成对象(执行构造方法)
	public static void main(String[] args) {
		new S();
		new S();
	}
}

class P {
	static {
		System.out.println("P static block");
	}

	public P() {
		System.out.println("P constructor");
	}
}

class Q extends P {
	static {
		System.out.println("Q static block");
	}

	public Q() {
		System.out.println("Q constructor");
	}
}

class S extends Q {
	static {
		System.out.println("S static block");
	}

	public S() {
		System.out.println("S constructor");
	}
}

28.[color=red] 类的静态代码块只会执行一次，是在类被加载的时候执行的，因为每个类只会被加载一次，所以静态代码块也只会被执行一次；而构造方法则不然，每次生成一个对象的时候都会调用类的构造方法，所以new一次就会调用构造方法一次。[/color]

29. [color=blue]如果继承体系中既有构造方法，又有静态代码块，那么首先执行最顶层的类的静态代码块，一直执行到最底层类的静态代码块，然后再去执行最顶层类的构造方法，一直执行到最底层类的构造方法。注意：静态代码块只会执行一次。 [/color]

30. 不能在静态方法中访问非静态成员变量；可以在静态方法中访问静态的成员变量。可以在非静态方法中访问静态的成员变量。

31.[color=blue] 总结：静态的只能访问静态的；非静态的可以访问一切。 [/color]

32. [color=blue]不能在静态方法中使用this关键字。this:表示当前对象。[/color]