Java 继承的学习

面向对象继承性

• 类继承，继承性是指扩充一个类已有的功能。

class 子类 extends 父类{}

class Person{
	private String name;
	private int age;
	public Person(String name,int age) {
		this.name=name;
		this.age=age;
	}
	public void tell() {
		System.out.print("Name:"+this.name+",Age:"+this.age);
	}
}
class Student extends Person{

	public Student(String name, int age) {
		super(name, age);
		// TODO Auto-generated constructor stub
	}
	
}
public class Java1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Student stu=new Student("Yang",22);
		stu.tell();

	}

}

• 子类对象实例化流程，在继承结构中，子类需要重用父类中的结构，所以在进行子类对象实例化之前往往都会默认调用父类中的无结构方法，为父类对象实例化，然后在进行子类结构调用，为子类对象实例化。

class Per{
	public Per() {
		System.out.println("Person");
	}
}
class Stu extends Per
{
	public Stu() {
		System.out.println("Student");
	}
}
public class Java2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Stu stu=new Stu();

	}

}

Person
Student

子类中的super()作用表示在子类中明确调用父类的无参数构造，不写也会默认调用，super()只能在子类的构造方法中定义，且必须放在子类构造方法的首行。

class Person3{
	private String name;
	private int age;
	public Person3(String name,int age) {
		this.name=name;
		this.age=age;
	}
}
class Student3 extends Person3{
	private String school;
	public Student3(String name,int age,String School) {
		super(name,age);
		this.school=school;
	}
}
public class Java3 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Student3 stu=new Student3("Yang",22,"石家庄铁道大学");

	}

}

• 继承限制，一个子类只能继承一个父类，即单继承局限，但是可以多层继承。一个子类继承，会继承父类的所有操作（方法、属性），但是需要注意对应所有的非私有操作属于显示继承，所有的私有操作属于隐式继承。

class Person4{
	private String name;
	public void setName(String name) {
		this.name=name;
	}
	public String getName() {
		return this.name;
	}
}
class Student4 extends Person4{
	public Student4(String name) {
		setName(name);
	}
	public String getInfo() {
		return "Name:"+getName();
	}
}
public class Java4 {

	public static void main(String[] args) {
		// 继承
		Student4 stu=new Student4("Yang");
		System.out.println(stu.getInfo());

	}

}

Name:Yang

覆写

• 方法覆写，在类继承中，子类可以继承父类中的全部方法，当父类的某些方法无法满足子类设计需求时，就可以针对已有的方法进行扩充，那么此时子类中定义与父类中方法名称、返回值类型、参数类型、个数完全相同的方法叫做方法覆写。

class Channel{
	public void connect() {
		System.out.println("Channel父类");
	}
}
class DatabaseChannel extends Channel{
	public void connect() {
		System.out.println("DatabaseChannel子类");
	}
}
public class Java5 {

	public static void main(String[] args) {
		// TODO 方法覆写
		DatabaseChannel channel=new DatabaseChannel();
		channel.connect();

	}

}

DatabaseChannel子类

• 方法覆写限制，被子类覆写的方法不能拥有比父类更加严格的访问控制权限，private<default<public。
• 方法重载和覆写的区别

区别	重载	覆写
英文	Overloading	Overriding
定义	方法名称相同，参数类型和个数不同	方法名称，参数类型和个数，返回值完全相同
权限	没有权限	被子类所覆写的方法不能拥有比父类更严格的访问控制权限
范围	一个类中	继承关系中

• 属性覆盖，可以对非private定义的父类属性进行覆盖，此时要定义与父类中成员属性相一致的名称。

class Channel1{
	String info="hi Yang";
}
class DatabaseChannel1 extends Channel1{
	int info=12;
	public void fun() {
		System.out.println("父类"+super.info);
		System.out.println("子类"+this.info);
	}
}
public class Java6 {

	public static void main(String[] args) {
		// TODO 属性继承
		DatabaseChannel1 channel=new DatabaseChannel1();
		channel.fun();

	}

}

父类hi Yang
子类12

final关键字

• final在程序中描述为终结器的概念，在Java中使用final关键字可以实现，定义不能被继承的类，定义不能被覆写的方法，定义常量。

Annotation注解

• 准确覆写，当子类继承某个父类之后进行覆写，在子类中明确描述某些方法时覆写而来的，可以利用@Override注解标注。
• 过期声明，@Deprecated。
• 压制警告，@SuppressWarnings。

面向对象的多态性

• 方法的多态性：方法的重载，方法的覆写。

• 对象的多态性：对象向上转型（父类 父类实例=子类实例），对象向下转型（子类 子类实例=（子类）父类实例）。

• 对象向上转型：子类对象实例化之前一定会自动实例化父类对象，所以此时将子类对象通过父类进行接收可以实现对象的自动向上转型，但是本质上还是子类实例，一旦子类中覆写了父类方法，并且调用该方法时所调用的一定是被子类覆写过的方法。

• 对象向上转型最大特点在于可以通过父类对象自动接收子类实例。

• 对象向下转型：子类继承父类后可以对已有的父类功能进行扩充，除了采用方法覆写，也可以定义新的方法，对于子类扩充的方法只有具体子类实例才可以调用。

• 对象向下转型，父类实例不可能强制转化为任何子类实例，必须先通过子类实例化。

class Message{
	public void print() {
		System.out.println("hi Yang");
	}
	public void run() {
		System.out.println("run");
	}
}
class DatabaseMessage extends Message{
	public void print() {
		System.out.println("hello");
	}
}
class NetMessage extends Message{
	public void print() {
		System.out.println("Yang");
	}
	public void fly() {
		System.out.println("fly");
	}
	public void fire() {
		System.out.println("fire");
	}
}
public class Java7 {

	public static void main(String[] args) {
		// TODO 对象向上转型
		Message msgA=new DatabaseMessage();
		msgA.print();
		Message msgB=new NetMessage();
		msgB.print();
		// TODO 对象向下转型
		Message msgC=new NetMessage();
		msgC.run();
		NetMessage msgD=(NetMessage)msgC;
		msgD.fly();
		msgD.fire();

	}

}

hello
Yang
run
fly
fire

• instanceof关键字，对象向下转型存在安全隐患，为了保证转化的安全性，可以在转换前通过instanceof关键字进行对象所属类型的判断。对象 instanceof 类。判断将返回Boolean类型的数据。

		if(msgC instanceof NetMessage) {
			NetMessage msgD=(NetMessage)msgC;
			msgD.fly();
			msgD.fire();
		}

Object类

• 为了方便操作类型的统一，也为了方便每一个类定义一些公共操作，定义了object类是所有的父类。
• object类中提供的toString()方法，可以实现对象信息的获取。

class Person8{
	private String name;
	private int age;
	public Person8(String name,int age) {
		this.name=name;
		this.age=age;
	}
	@Override
	public String toString() {
		return "Name:"+this.name+",Age:"+this.age;
	}
}
public class Java8 {

	public static void main(String[] args) {
		// TODO toString()获取对象信息
		Person8 per=new Person8("Yang",22);
		System.out.println(per);

	}

}

Name:Yang,Age:22

• 对象比较，public boolean equals(Object obj),这个方法中两个对象是基于地址数值判断的。