Java 课堂记录 03 （继承与多态）

1、
Overriding：子类在继承父类方法的同时并改写了此方法。（方法名称，参数个数，类型都不变）.

继承关系里，在子类中使用super关键字调用父类的方法可以增强子类的可维护性。（黑盒机制）
父类成员的引用 : super.成员变量; super.成员方法; 调用父类的构造方法 super(参数列表).

在子类对象创建的时候，初始化的顺序是：1. 父类中的构造函数; 2. 子类的属性初始化; 3. 子类的构造函数。
1.在创建子类时默认的情况( 不指定带参super(..) )下是调用父类中不带任何参数的构造函数，如果父类中不存在此构造函数就会编译出错。
2.在构造函数中可以通过super（...）来调用父类的构造函数，其效果和默认的情况下是一样的。
3.super()用于调用父类的构造函数只能够出现在子类中,且必须出现在子类构造函数的第一行。

因为 protected 可以在不同包之间访问( 对象访问成员)， 所以 protected 可以在不同包之间继承( 出现在继承类中)。 同理 default 可以在同包之间访问，所以可以在同包之间继承。
在不同包的子类中也不能够访问protected类型修饰的成员。
final ： 修饰方法：方法不能被重写； 修饰类　： 不能被继承。
java中的每一个类都是对Object的一个扩展，但是绝对不可以直接继承自Object：eg class student extends Object是错误的。
System.out.println( .. )在输出一个对象时，系统会调用对象的toString（）方法. 否则会出现类似“ @ad3ba4 ”的错误，所以在需要进行输出的对象的类中需显示定义 public String toString(..).

绑定 ：建立method call和method body的关联。
多态：多个类提供相同名称的函数。分为 编译时多态（overloading） + 运行时多态(原因： 继承链中的类型转换 + overriding + 动态绑定 ）
向上转型 ： upcasting ：子类的引用赋值给父类的引用，即子类的对象空间通过父类的引用来访问。产生接口窄化，
接口窄化 ： 编译时只允许访问父类中提供的方法（具体哪些受访问权限限制），如果子类中有该方法，则在运行时采用“动态绑定”机制访问子类方法。
向下转型 ： 必须使用 if（obj1 instaceof subclass） s = (student)p; 判断。
Static 方法 ：
1、被隐藏的父类中的静态方法不能够从子类中访问。
2、Static修饰的方法是可以在子类中继承的，但是在执行upcasting之后，静态方法不会出现动态绑定的现象。

2、代码验证 Test.java
class Person{
private String name;
private int age;
static int temp;
public Person() {}
public Person(String n ){ name = n; }
public void setName(String n){ name = n ; }
public String getName(){ return name; }
public void myInfo(){ System.out.println("My name is:"+name ); }
public static void testStatic(){ System.out.println("In SuperClass test static!"); }
public void testNoStatic(){ System.out.println("In SuperClass test no static!"); }
}

class Student extends Person
{
String major;
public Student() { }
public Student( String str, String str_major){ super( str ); major = str_major; }
public void setMajor( String s ) { major = s; }
public void myInfo() { super.myInfo(); System.out.println("My major is:"+ major + "/n" ); }
public static void testStatic(){ System.out.println("In SubClass test static!"); }
public void testNoStatic(){ System.out.println("In SubClass test no static!"); }
// super.testStatic(); // Error ： 子类不能访问父类中被隐藏的static方法。
int temp = super.temp ; // OK : 子类能访问父类中被隐藏的static属性。
}

public class Test
{
public static void main( String[] args )
{
Person zp_p = new Person( "ZP_P" );
Student zp_s = new Student( "ZP_S", "SEI" );
zp_p.testNoStatic(); zp_p.testStatic();
zp_p = zp_s; System.out.println( "/nAfter dynamic binding /n" );
zp_p.testNoStatic(); zp_p.testStatic(); // 只有testNoStatic 发生了动态绑定。

zp_p.myInfo(); // 因为zp_p 的定义类型Person 中也有myInfo(),所以编译通过，运行时动态绑定。
dynamicBind( zp_s ); // 因为对象应用做形参是传值，动态绑定。

Person[] persons = new Person[1];
persons[0] = zp_s;
persons[0].myInfo(); // 因为对象数组中每个位置存放的是引用，动态绑定。

// zp_p.setMajor( "Economy" );
// Error ： 找不到符号 ：符号： 方法 setMajor(java.lang.String)。因为编译器只知道zp_p 是Person 类型，而Person 类中没有setMajor() 方法。
Student zp_s_new = null;
// zp_s_new = zp_p;
// Error : 不兼容的类型, 找到： Person, 需要： Student. 因为未用 instanceof 判断的向下转型是不安全的，编译器统统禁止。
if( zp_p instanceof Student ) { zp_s_new = (Student)zp_p; System.out.println( "OK, safe DownCasting " ); }
}

public static void dynamicBind( Person prs ) { prs.myInfo(); }
}

输出为 ：
In SuperClass test no static!
In SuperClass test static!

After dynamic binding

In SubClass test no static!
In SuperClass test static!
My name is:ZP_S
My major is:SEI

My name is:ZP_S
My major is:SEI

My name is:ZP_S
My major is:SEI

OK, safe DownCasting