零基础学java——面向对象（三）

多态

多态是同一个行为具有多个不同表现形式或形态的能力。
多态性是对象多种表现形式的体现。
多态存在的必要条件:
	继承 重写 父类引用指向子类对象
	Person p=new student();

多态的应用

/**
不同国家的人在同一家饭店吃饭
	中国人 用筷子吃 中餐
	英国人 用刀叉	  西餐	
*/
public class Test02 {
	public static void main(String[] args) {
		Chinese ch = new Chinese();
		eatRoom(ch);
		En en = new En();
		eatRoom(en);
	} 

/** 
public static void eatRoom(Chinese ch) { 
	ch.eat(); 
	}
public static void eatRoom(En en) { 
	en.eat(); 
	}
*/
public static void eatRoom(Person person) {
	// Person person = ch; Person person = en;
	person.eat();
	}
} 
	class Person{
		public Person() {
		}
		public void eat() {
		}
	}
	class Chinese extends Person{
		private String name;
		private int age;
		public Chinese() {
		}
		public void setName(String name) {
			this.name = name;
		}
		public String getName() {
			return this.name;
		}
		public void setAge(int age) {
			this.age = age;
		} 
		public int getAge() {
			return this.age;
		}	
		public void eat() {
			System.out.println("用筷子吃饭");
		}
	} 
class En extends Person{
	private String name;
	private int age;
	public En() {
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getName() {
		return this.name;
	}
	public void setAge(int age) {
		this.age = age;
	} 
	public int getAge() {
		return this.age;
	} 
	public void eat() {
		System.out.println("用刀叉吃饭");
	}
}

类的加载顺序

{} 代码块：
局部代码块：声明在方法中的代码块
	缩减局部变量的生命周期 提高内存是使用率
成员代码块：初始化块
	声明在方法外 类中的代码块
	初始化块在类加载的时候是不会执行的
	在创建对象之前会被调用(对于对象中的一些初始进行初始化操作)
静态代码块:
	声明在类中 方法外 且使用static修饰
	类加载的时候就会被加载 并且只加载1次 静态内容

类中的执行顺序：
	1：首先执行静态内容(加载) 静态代码块
	2：初始化块
	3：构造器

类什么时候被加载：
	使用当前类中的静态方法、静态变量
	创建当前类的实例对象
	
先加载静态内容 -> 先执行静态代码块 由于父子关系 所以子类加载之前需要先加载父类
* 执行的父类的初始化块和构造器
* 准备执行子类的构造器 先执行初始化块 子类构造器中有一个super()
* 
* 父类的静态代码块
* 子类的静态代码块
* 父类的初始化块
* 父类的构造器
* 子类的初始化块
* 子类的构造器	

public class Test02 {
	static {
		System.out.println("我是静态代码块");
	} 
	int age ;
	{
		age = 20;
		System.out.println("我是初始化块");
	} 
	public static void main(String[] args) {
	/** 
		{ int num = 10; System.out.println(num); }
	*/
		Test02 t = new Test02();
		System.out.println(t.age);
		new Test02();
	} 
	public Test02() {
		System.out.println("我被调用了");
	}
}

引用类型的类型转换

引用类型也有类型转换：
自动转换
	父类型 变量名 = 子类对象;【new 子类对象|子类对象的变量】
强制转换
	子类型 变量名 = (子类型)父类变量; [事先确定了父类变量中实际存储的对象是什么类型]
	ClassCastException 类型转换异常

public class Test03 {
// F 是父类 存在 fun方法 S1 S2子类重写了fun方法 并且每个类中都存在一个自己的独有方法m1
	public static void main(String[] args) {
		F f = new F();
		f.fun();
		S1 s1 = new S1();
		s1.fun();
		f = s1;
		//f.m1();//编译出错
		S1 ss = (S1)f;
		//ss.m1();
		//S2 s2 = (S2)f;//编译
		//s2.m1();
		//s2.fun();
	}
}
class F{
	public void fun() {
		System.out.println("f f");
	}
}
class S1 extends F{
	public void m1() {
		System.out.println("S1 m1");
	}
	public void fun() {
		System.out.println("S1 f");
	}
}
class S2 extends F{
	public void m1() {
		System.out.println("S2 m1");
	}
	public void fun() {
		System.out.println("S2 f");
	}
}

final修饰静态常量进过方法

final 修饰的基本数据类型变量 无法进行修改的
final 修饰的引用类型的变量 只保证地址不变 对象中的内容可以发生改变
final修饰的静态成员常量不会导致类加载
*静态成员常量的值在加载前无法确定 那么会导致类加载