Java学习-继承

Java 继承(inheritance)是 Java 面向对象的三大重要特性之一（封装-encapsulation, 继承-inheritance, 多态-polymorphsim) Java 继承很好的管理了具有相似特征的类之间的关系(主要集中在成员变量、方法), 使程序可扩展、易修改，并且成为java多态的基础。

Java中继承的特点：
1.Java只支持单继承：一个父类被多个子类继承，但一个子类只能继承一个父类。与接口不同的是，一个类可以实现(implement)多个接口；
2.Java支持多层继承：一个子类只能继承一个父类，但是这个父类还可以有其他父类；
3.父类定义了继承树中共性的内容，子类定义了该类个性的内容；
使用语法
在Java之中，如果要实现继承的关系，可以使用如下的语法：

public class super{}
public class sub extends super{}
//sub：子类/派生类
//super：父类/超类/基类

1.在我们不重写(overwrite) 或重载(override)父类中的方法、不增添新的方法、不更改原始的成员变量或增加新的变量的情况下，子类会自动继承父类可继承的所有属性。
A：继承必须合理性
B：父类中成员是共性的内容
C：子类自动拥有父类的成员并且可以直接使用非私有的父类成员

2.继承中子父类的成员变量的特点：
a.子父类的成员变量不同名时，没有任何问题；
b.子父类的成员变量同名时，使用子类的对象访问该成员变量时，优先访问子类的；

3.继承中子父类的成员方法的特点：
a.子父类的成员方法不同名时，没有任何问题；
b.子父类的成员方法同名时，使用子类的对象访问该成员方法时，优先调用子类的；

4.无论是成员方法还是成员变量，优先访问或调用子类的，如果子类没有就访问或调用父类的，如果父类也没有则报错；

5.构造方法不能被继承；

This
this相当于是指向当前对象本身；
当局部变量和成员变量重名时，this.xxx进行区分；
Super
super相当于是指向当前对象的父类；
当父类的成员变量或方法和子类的重名时，可以用super.xxx来引用父类的成员区分父类和子类；

package com.jagger.secondtry;

public class super_demo {
	String name = "父类成员变量";
	
	public String TestSuperFu2(String name) {
		return name;
	}
}

package com.jagger.secondtry;

public class sub_demo extends super_demo{
	
	//this的直接引用
	public String TestThis(String name) {
		System.out.println("This引用前：" + name);//this引用前输出局部变量
		name = this.name;//this引用
		
		return name;
	}
	
	//super的直接引用
	public String TestSuperMe(String name) {
		System.out.println("Super引用前：" + name);
		name = super.name;//super引用父类成员变量
		return name;
	}
	
	public String TestSuperFu1(String name) {
		name = super.TestSuperFu2("父类方法");//super引用父类的成员方法
		return name;
	}
}

package com.jagger.secondtry;

public class Extend_demo {

	public static void main(String[] args) {
		sub_demo subb = new sub_demo();
		
		System.out.println("This引用后：" + subb.TestThis("子类局部变量"));;
		System.out.println("Super引用后：" + subb.TestSuperMe("子类局部变量"));
		System.out.println("Super引用后：" + subb.TestSuperFu("子类方法输入"));
	}
}
console输出结果：
This引用前：子类局部变量
This引用后：子类成员变量
Super引用前：子类局部变量
Super引用后：父类成员变量
Super引用后：父类方法

super()：默认，无论调用子类的哪一个构造，都先会执行父类的无参构造
super(参数)：由其中的参数调用父类中的哪一个构造函数（应该为构造函数中的第一条语句）。
this(参数)：由其中的参数决定调用本类中的哪一个构造函数（应该为构造函数中的第一条语句）。

package com.jagger.forthtry;

public class Parent {
	String name;
	int age;
	
	public Parent() {
		System.out.println("父类的无参构造");
	}
	
	public Parent(String name) {
		System.out.println("父类的name参数构造：" + name);
	}
	
	public Parent(String name,int age) {
		System.out.println("父类的name&age参数构造：" + name + age);
	}
}

package com.jagger.forthtry;

public class Child extends Parent {
	public Child( ) {
		super();//表示引用父类的无参构造
		System.out.println("子类的无参构造");
	}
	
	public Child(String name) {
		//super();//不使用任何super构造默认调用父类的无参构造
		//super(name);//引用相同参数类型的父类构造函数
		this();//调用子类的无参构造
		System.out.println("子类的age参数构造：" + name);
	}
	
	public Child(String name,int age) {
		super(name,age);
		//this(name);//调用子类中的相同参数类型的构造
		System.out.println("子类的age&name参数构造：" + name + age);
	}
}

package com.jagger.forthtry;

public class ThisSuper {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Child Tom = new Child();
		Child Saly = new Child("SS");
		Child Jack = new Child("JJ",20);
	}
}
console输出结果：
父类的无参构造
子类的无参构造
父类的无参构造
子类的无参构造
子类的age参数构造：SS
父类的name&age参数构造：JJ20
子类的age&name参数构造：JJ20

Overload方法的重载
在同一个类中，方法名相同，但是参数类型和个数不一样，返回值类型可以相同可以不同，可以有不同的访问修饰符，可以抛出不同的异常，这时候这几个方法被称为方法的重载；
Override方法的重写
若子类中的方法与父类中的某一方法具有相同的方法名，返回类型，参数列表，则新方法将覆盖原有的方法即方法的重写/覆盖；

package thirdtry;

public class Phone {
	int price;
	int color;
	int name;
	
	public void call() {
		System.out.println("拨打电话");
	}
	
	public void Msg(){
		System.out.println("发送短信");
	}
}

package thirdtry;

public class SmartPhone extends Phone{
	public void call() {
		super.call();//父类的功能必须存在
		System.out.println("面对面视频");
	}
	
	public void Msg(){
		super.Msg();//父类的功能必须存在
		System.out.println("发送图片");
		System.out.println("发送语音");
	}
}

package thirdtry;

public class override_demo {
	public static void main(String[] args) {
		SmartPhone Mi8 = new SmartPhone();
		
		Mi8.call();
		Mi8.Msg();
	}
}
console输出结果：
拨打电话
面对面视频
发送短信
发送图片
发送语音

重写的注意事项：
子类的方法重写/覆盖父类的方法，必须要保证子类权限大于等于父类权限
（Java的四种权限：public>protected>default>private）；
如果父类的方法权限是private修饰的，在子类中无法重写；
重写方法时必须一模一样（方法名，返回类型，参数列表必须一样）；

猜你喜欢