java面向对象高级篇--继承

二、继承

1、在java中只允许单继承，和多层继承，但不允许多重继承。

2、继承关键字extends
class Student extends Person

3、子类不可以访问父类的私有操作，但可以通过其他操作间接访问父类的私有属性。

4、子类通过拥有自己的属性及方法扩展父类。

5、子类对象实例化过程
在子类对象实例化之前，必须先调用父类的构造函数，再调用子类自己的构造函数。（此操作由java完成）

6、子类可以通过覆写父类方法，即在子类中指定与父类中同名的方法，来修改方法的功能。
6.1、在子类覆写父类方法时应该注意，覆写方法的访问权限不能低于父类方法的访问权限。
6.2、子类不能覆写父类的私有方法。（子类不能继承父类的私有方法，自然不能覆写）
但是在子类中可以存在与父类中私有方法同名的方法且被当作子类的扩展方法被直接调用，但不属于覆写。
例：

class Demo{ 
	 
    private void print() {
		System.out.println("this is father");
	}
    public void pri() {
    	print();
    }
 
}

class Demo1 extends Demo{
	public void print() {
		System.out.println("this is child");
	}
	 
}

public class ExtendsDemo {
	public static void main(String[] args) {
		Demo1 d1=new Demo1();
		d1.pri();
		d1.print();
	}

}

结果：

6.3、
此处需要提及一下子类在继承父类时对父类的成员变量及方法继承的问题。对于使用protected或者public修饰的成员变量及方法，会被子类继承，且可通过子类直接调用，那么，对于子类不可见的private成员，以及没有修饰词修饰的成员（若子类与父类在不同的包中，这一类成员也是对子类不可见的），他们不被子类继承，那么在子类的实例所代表的内存空间中，这些成员是否存在呢？答案是肯定的，父类的私有变量及方法虽然不会被子类继承，对于子类来说不可见，但当创建了子类的实例的时候，这些成员一样会被加载入内存，并“隐藏”在内存当中。

7、子类可以覆盖父类中的属性
子类覆盖父类的属性，与方法覆写并不一样，属性覆盖，只是在子类中访问同名属性时，访问到的是子类中定义的属性，而在父类中访问到的还是父类中的属性。

class DemoF{
	public final int A=1;
	public void printF() {
		System.out.println("father:"+A);
	}
}
class DemoC extends DemoF{
	public final int A=2;
	public void printC() {
		System.out.println("child:"+A);
	}
	
}
public class AttributeOverride {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		DemoC dc=new DemoC();
		dc.printF();
		dc.printC();

	}

}

8、super关键字的作用
super关键字可以在子类中调用父类的构造方法，普通方法，和属性。
注意：在使用super调用父类构造函数时，必须放在子类构造方法的首行。

三、抽象类

在java中可以创建一种类专门用来当作父类，这种类称为抽象类，抽象类的作用类似于模板，其目的是要设计者根据他的格式类修改并创建新的类。但是并不能直接由抽象类创建对象，只能通过抽象类派生出新的类，在由他来创建对象。但是在抽象类的使用中同样存在单继承的局限，即一个子类只能继承一个抽象类。
抽象类定义及使用规则：
1、包含抽象方法的类必须是抽象类。
2、抽象类和抽象方法都需要使用abstract关键字声明。
3、抽象方法只需要声明，而不需要实现。
4、抽象类必须被子类继承，子类如果不是抽象类则必须覆写抽象类中的全部抽象方法。
5、抽象类中可以定义构造方法，但是只能通过子类来调用。

四、接口

1、接口可以被理解为一种特殊的类，由全局常量和公共的抽象方法组成。
2、在java中类可以实现多个接口
3、接口可以继承接口 （extends） 且类可以继承多个接口

注意：再类设计中，一个类不要继承已实现好的类，只能继承抽象类或者接口，且最好继承接口

五、对象的多态

1、在java中多态是面向对象的一个重要概念，在java中多态主要有两种体现形式：
（1）方法重载与覆写
（2）对象的多态。（通过向上转型，和向下转型实现）
2、例：

package com.shuai.ChapterSix;
/**
 * 对象多态
 * @author guai
 *
 */
class A{
	public void fun1() {
		System.out.println("A-->public void fun1()");
	}
	public void fun2() {
		System.out.println("A-->public void fun2()");
	}
}
class B extends A{
	public void fun1() {
		System.out.println("B-->public void fun1()");
	}
	public void funt3() {
		System.out.println("B-->public void fun3()");
	}
}
public class ObjectPolymorphism {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		B b=new B();
		A a=b;  //向上转型 ，子类-->父类
		a.fun1();
 
		
		
		//向下转型，需要先向上转型  父类-->子类
		//为啥向下转型要先司昂上转型？
		//建立父类与子类的关系，告知父类B，A是它的子类， 
		/*A a=new B();
		B b=(B)a;
		b.fun1();
		b.fun2();
		b.funt3();*/
	}
}

向上转型结果：

向下转型结果：

3、实际使用将通过下面instanceof关键字中的例子说明。
4、注意：无论向上转型，还是向下转型，调用的方法若被子类覆写过，则调用的是子类覆写过的方法。

六、instanceof关键字

1、instanceof用于判断一个对象到底是哪个类的实例
对象 instanceof 类 ->返回boolean类型
例：

```java
class A1{
	public void fun1() {
		System.out.println("A-->public void fun1()");
	}
	public void fun2() {
		System.out.println("A1-->public void fun2()");
	}
}
class B1 extends A1{
	public void fun1() {
		System.out.println("B1-->public void fun1()");
	}
	public void funt3() {
		System.out.println("B1-->public void fun3()");
	}
}
class C1 extends A1{
	public void fun1() {
		System.out.println("C1-->public void fun1()");
	}
	public void fun3() {
		System.out.println("C1-->public void fun3()");
	}
}

public class InstranceofKeywords {
	public static void main(String[] args) {
		fun(new B1());
		fun(new C1());
		
	}
	public static void fun(A1 a1) {
		if(a1 instanceof B1) {  //判断是哪个类的实例 
		向下转型
			B1 b1=(B1)a1;
			b1.funt3();
		}else if(a1 instanceof C1) {
			C1 c1=(C1)a1;
			c1.fun3();
		}
	}
}

## 七、抽象类与接口的应用

1、通过对象的多态为抽象类和接口实例化，这样使用抽象类和接口时可调用被子类覆写过的方法。
2、抽象类的实际应用——模板设计
3、接口的实际应用——制定标准