【JAVA语法】03Java-继承性

• 继承的实现
• 继承的限制
• 子类对象的实例化
• 方法的重写
• Super关键字
• 重写与重载的区别
• final关键字
• 抽象类
• 接口

一、继承的实现

1.1 格式

	class 子类 extends 父类 {}
	class Student extends Person{}

二、继承的限制

2.1 Java中只允许单继承

	class Student extends People,Worker {}
	//error,不允许多继承(一个人只允许有一个亲生父亲)

2.2 子类不能直接访问父类的私有成员

需要用get及set方法实现访问

三、子类对象的实例化

必须先调用父类中的构造方法，再调用子类构造方法

四、方法的重写

4.1 定义

子类定义了与父类同名的方法(方法名称、返回值类型和参数均完全相同)

class Parent{
	public void tell(){
		System.out.println("Parent");
	}

}
class Sub extends Parent{
	public void tell(){
		System.out.println("Sub");
	}
}
public class test {

	public static void main(String[] args)
	{
		Sub subFunc = new Sub();
		subFunc.tell();
	}

	}
OUTPUT: Sub

4.2 重写限制

被子类重写的方法不能拥有比父类更加严格的访问权限 (一般和父类一样即可)

private(更严格)<default<public

五、Super关键字

5.1强行调用父类的方法

若想调用父类同名方法——Super关键字

class Parent{
	public void tell(){
		System.out.println("Parent");
	}

}
class Sub extends Parent{
	public void tell(){
		super.tell();
		System.out.println("Sub");
	}
}
public class test {

	public static void main(String[] args)
	{
		Sub subFunc = new Sub();
		subFunc.tell();
	}

	}
OUTPUT:
Parent
Sub

5.2 Super不一定在重写中使用，也可以表示那些方法是从父类继承而来的(提高代码可读性)

六、重写与重载区别

七、Final关键字

7.1 用途: 完结、最终

使用final声明的类不能被继承;

使用final声明的方法不能被重写;

使用final声明的属性不能被修改(常量)。

八、抽象类

8.1 概念

抽象类:包含一个抽象方法的类(不能直接实例化对象，需通过其子类实例化对象)

抽象方法:声明而未被实现的方法(使用abstract关键字声明)

重写：抽象类被子类继承，子类(如果不是抽象类)必须重写并实现抽象类中所有抽象方法

abstract class Abs{
	private int age;
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public abstract void say();//抽象方法
}
class SubAbs extends Abs{
	public void say(){

	}
}
public class test {

	public static void main(String[] args)
	{
		SubAbs a = new SubAbs();
		a.setAge(20);
	}

	}

九、接口

9.1 概念

接口:特殊的类，全部由全局常量和公共抽象方法所组成

实现:接口必须通过子类实现(类比抽象方法)，使用关键字implements

多实现：接口可以多实现(多继承，区分"类"的单继承)

9.2 格式

	interface interfaceName{
	全局常量
	抽象方法
	}

9.3 一个子类可以同时继承抽象类和实现接口

	interface Inter1{
	public static final int AGE = 100;
	public abstract void tell();
}
interface Inter2{

	public abstract void say();
}

abstract class Abs1{
	public abstract void print();
}

class Sub extends Abs1 implements Inter1,Inter2{	//多继承(多实现)
	public void tell(){}
	public void say(){}
	public  void print(){							//一个子类可以同时继承抽象类和实现接口

	}
}

9.4 接口的继承——相当于间接实现"类的多继承"

一个接口不能继承一个抽象类，但是可以通过extends关键字同时继承多个接口，实现接口的多继承

interface Inter1{
	public static final int AGE = 100;
	public abstract void tell();
}
interface Inter2{

	public abstract void say();
}

interface Inter3 extends Inter1,Inter2{

}