day10

学习了继承和多态,重在理解记忆,父类与子类的优先顺序是重难点,学习了final关键字与super关键字.对继承的理解比较透彻,对多态的掌握还是有所欠缺.

1:final关键字可以干什么?有什么特点?
final的应用:
可以修饰类,无法被继承!
可以修饰变量,此时这个变量是常量,被final修饰的变量,只能赋值一次!
可以修饰成员方法,此时该方法不能被重写.
特点:
2:final关键字的面试题?
A:修饰局部变量
1)final可以修饰基本数据类型的变量,当前该变量的值不能被改变!
2)final可以修饰引用数据类型,当前该类对象的地址值不能被改变!
B:初始化时机
final修饰变量的初始化时机:
1)变量只能被初始化一次
2)当前变量只是定义了,在构造方法执行之前必须初始化
3:多态是什么，前提是什么?
多态:
在同一时刻体现出事物的不同状态!
动物(猫,狗,猪…)
水(气态,固态,液态…
在面向对象Java语言中,多态的前提条件:
1)必须有继承关系
如果没有继承关系,无意义
2)必须有方法重写
在继承关系中,父类比较抽象(动物类),
动物类
eat(){…}
子类:
狗类,
eat(“狗吃骨头”){}
猫类
eat(“猫吃鱼”){}
3)必须父类引用指向子类对象(向上转型) ;
格式:
父类名 对象名 = new 子类名() ;
4:多态中成员访问的特点?
成员变量:
编译看左边,运行看左边
构造方法:在多态中,父类对象的创建时通过new 子类名(),优先让父类进行数据初始化
成员方法(非静态):
编译看左边,运行看右边

	静态的成员方法:(静态成员方法算不上方法重写,因为静态跟类有关系)
		编译看左边,运行看左边
		
	我们以后说的成员方法,都是指的是非静态(如果子类出现和父类一模一样的方法声明,那么存在方法重写)
		在多态中成员方法	编译看左,运行看右

5:多态的好处及弊端？如何解决多态的弊端？
好处: 1)提高了程序的维护性(由继承关系保证)
2)提高了代码的扩展性(由多态的保证)
弊端:多态中无法直接访问子类的特有功能

	如何解决?
		多态的第三个前提条件:
			父类引用指向子类对象	Fu fu = new Zi() ;	向上转型
			
		在多态中,如果能够去使用子类本身的引用,就能够访问子类的特有功能?
		1)子类new子类对象
			Zi zi = new Zi() ;
			zi.playGame() ;
			虽然可以,但是从内存角度考虑,比较消耗内存空间
			
		2)将父类引用强制转换为子类对象	(向下转型)
				Zi zi = (Zi)fu;

6:什么是向上转型？什么是向下转型？
向上转型:1。父类引用指向子类对象，而子类引用不能指向父类对象。
2。把子类对象直接赋给父类引用叫upcasting向上转型，向上转型不用强制转换。
向下转型: 3。把指向子类对象的父类引用赋给子类引用叫向下转型(downcasting)，要强制转换。
7:多态编程题
a)不同地方饮食文化不同的
南方人吃米饭
北方人爱吃面
请使用多态的方式进行测试。

提示：
	1:人要吃饭
	2:南方人吃炒菜和米饭
	3:北方人吃烩菜和馒头
	先基本的调用，后多态调用。
	
	class Person{
public void eat(){
	System.out.println("吃");	
}

}
class Northern extends Person{
public void eat(){
System.out.println(“北方人爱吃面”);
}
}
class Southern extends Person{
public void eat(){
System.out.println(“南方人爱吃米饭”);
}
}
class PersonTest{
public static void main(String[] args){
//基本调用
Northern n = new Northern();
n.eat();

Southern s = new Southern();
s.eat();

 //多态调用
Person p1 = new Northern();
p1.eat();

Person p2 = new Southern();
p2.eat();
}

}

b)在猫狗案例，使用多态方式进行测试
class Test{
public static void main(String[] args){
	
	Animal a = new Cat() ; 
		a.eat();
		a.sleep();
	Animal a1 = new Dog();
	    a1.eat();
		a1.sleep();
		
	
}

}

8：看程序，写结果
1:看程序写结果（先判断有没有问题，如果没有，写出结果）
class Fu {
public void show() {
System.out.println(“fu show”);
}
}
class Zi extends Fu {
public void show() {
System.out.println(“zi show”);
}
public void method() {
System.out.println(“zi method”);
}
}
class Test { public static void main(String[] args) {
Fu f = new Zi();
f.method();
}
}
错误,父类中没有method变量.无法调用.
2:看程序写结果（先判断有没有问题，如果没有，写出结果）
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 Test {
public static void main(String[] args) {
A a = new B();
a.show();
B b = new C();
b.show();
}
}
爱你,当出现show2的时候,优先子类.
9：请描述下this和super的区别？
this.成员变量; 访问本类中的成员变量
super.成员变量;访问父类中的成员变量
10：方法重写和方法重载的区别？
方法重写:
子类出现了和父类一模一样的方法---->方法重写(也叫方法覆盖,方法复写)
方法名相同,返回值其他都一样.

方法重载:
	方法名相同,参数列表不同,与返回值没有关系.
		1)参数类型不同
		2)参数个数不同