day09-1学习过程笔记

1.final关键字(掌握)

• 表示最终，可以修饰类，方法，变量
• 特点：
• 它修饰的类，叫最终类，不能被继承
• 它修饰的方法，不能被重写
• 它修饰的变量，是一个常量，叫自定义常量，只能被赋值一次
  //常量分为字面值常量：“hello”,10,true；和自定义常量：final int x=10;

权限修饰符修饰局部变量没有意义，因为本来局部变量就在方法里，就是被封装好的东西，外面的方法看不到

但final不一样 ：

• 面试题：final修饰局部变量的问题

• 修饰基本类型时，表示基本类型的值不能发生改变

• 修饰引用类型时，表示引用类型的地址值不能发生改变，但是对象的内容是可以改变的

  class Student {
  	int age = 10;
  }
  
  class FinalTest {
  	public static void main(String[] args) {
  		
  		//局部变量是基本数据类型
  		final int y = 10;
  		//无法为最终变量y分配值
  		//y = 100;
  		System.out.println(y);
  	
  		//局部变量是引用数据类型
  		final Student s = new Student();
  		//对象内容可以发生改变
  		s.age = 100;
  		System.out.println(s.age);
  	
  		//重新分配内存空间
  		//无法为最终变量ss分配值
  		s = new Student();
  	}
  }
  

• 初始化时机

• 只能初始化一次 //因为被final修饰的变量，只能被赋值一次

• 常见的给值
  构造方法完毕前（构造方法前或构造方法中，但这只适用非静态常量）

• 定义的时候（推荐，适用静态常量和非静态常量）

2.多态(掌握) //多应用在抽象类

• 定义：同一个对象在不同时刻体现出来的不同状态

• 多态的前提：

• 要有继承或者实现关系

• 要有方法重写，才有意义

• 要有父类或者父接口引用指向子类对象：
  父 f = new 子();

• 多态中的成员访问特点（参考就好）

• 构造方法
  子类的构造都会默认访问父类构造

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

• 成员方法
  编译看左边，运行看右边 //因为成员方法存在重写，所以不同

  特殊： 静态方法 //而静态方法算不上重写，因为它是和类相关的
  编译看左边，运行看左边

• 多态的好处：

• 提高代码的维护性(继承体现)

• 提高代码的扩展性(多态体现)：2019-08-19com包

• 多态的弊端：
  父不能使用子的特有功能

  现象： 子可以当作父使用，父不能当作子使用

• 多态的三种方式：

• 具体类多态（几乎不用）

  	class Fu {}
  	class Zi extends Fu {}
  	Fu f = new Zi();
  

• 抽象类多态（常用）

  	abstract class Fu {}
  	class Zi extends Fu {}
  	Fu f = new Zi();
  

• 接口多态（最常用）

  	interface Fu {}
  	class Zi implements Fu {}
  	Fu f = new Zi();
  

3.多态中的向上、向下转型

/*
	多态的弊端：
		不能使用子类的特有功能。
		
	我就想使用子类的特有功能?行不行?
		行。
		
	怎么用呢?
		A:创建子类对象调用方法即可。(可以，但是很多时候不合理，而且太占内存)
		B:把父类的引用强制转换为子类的引用。(向下转型)
		
	对象间的转型问题：
		向上转型：
			Fu f = new Zi(); //本身是Zi类，外界看到是Fu类
		向下转型：
			Zi z = (Zi)f; //要求该f必须是能够转换为Zi的
					   		以动物是父类，狗是子类为例，f本身是狗才能转为狗
	   		  				如果f是动物猫，就不能转为子类狗
*/
class Fu {
	public void show() {
		System.out.println("show fu");
	}
}

class Zi extends Fu {
	public void show() {
		System.out.println("show zi");
	}
	
	public void method() {
		System.out.println("method zi");
	}

}

class DuoTaiDemo4 {
	public static void main(String[] args) {
		
		Fu f = new Zi();	//向上转型
		f.show();
		//f.method();	//报错，编译看左边，Fu类没有method方法
		
		//创建子类对象
		//Zi z = new Zi();	//可行，但不合理，且太占内存
		//z.show();
		//z.method();
		
		//你能够把子的对象赋值给父亲，那么我能不能把父的引用赋值给子的引用呢?
		//如果可以，但是如下
        
        //Zi z = f；//报错，因为系统会考虑兼容类型
		Zi z = (Zi)f; //之所以可以强转，因为f本质上就是子的类型
		z.show();
		z.method();
	}
}

4.图解:

• 多态继承的内存图解

• 多态对象变化的内存图解
  

5.多态案例：

/*
	看程序写结果:先判断有没有问题，如果没有，写出结果
	
	多态的成员访问特点：
		方法：编译看左边，运行看右边。
		
	继承的时候：
		子类中有和父类中一样的方法，叫重写。
		子类中没有父亲中出现过的方法，方法就被继承过来了。
*/
class A {
	public void show() {
		show2();
	}
	public void show2() {
		System.out.println("我");
	}
}
class B extends A {

	public void show2() {
		System.out.println("爱");
	}
}
class C extends B {
	public void show() {
		super.show();
	}
	public void show2() {
		System.out.println("你");
	}
}
public class DuoTaiTest4 {
	public static void main(String[] args) {
		A a = new B();
		a.show();	//A中有show，编译成功
                    //运行，找B的show，执行show2()，也是执行B中show2()
					//打出“爱”
		
		B b = new C();
		b.show();	//B继承了A的show，所以编译成功
				    //运行，找C的show，super.show是指B中的，B又是继承的A的，
			   		  所以也执行show2()，当然执行的是C中show2()
					//打出“你”
	}
}