JAVA笔记:Java中的继承总结

继承:在Java中使用extends关键字来实现类的继承  ,extends意思就是派生,所以子类也叫派生类,继承的主要目的是扩展类的内容

操作格式: class A{}; class B extends A{};

子类B可以继承父类A中的公用方法,也可以扩展自己的方法

示例代码:

package OOP2;

class Person{
	private String name;
	private int age;
	public void setName(String name){
		this.name = name;
	}
	public void setAge(int age){
		this.age = age;
	}
	public String getName(){
		return this.name;
	}
	public int getAge(){
		return this.age;
	}
};

class Student extends Person{
	private String school;
	public void setSchool(String school){
		this.school = school;
	}
	public String getSchool(){
		return this.school;
	}
};
	
public class extendsOne {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Student stu = new Student();
		stu.setName("李帅");
		stu.setAge(20);
		stu.setSchool("霍格沃茨");
		System.out.println("名字:"+stu.getName()+","+"年龄"+stu.getAge()+","+"学校:"+stu.getSchool());
		
	}

}

继承的限制:Java中只允许单继承,意思就是一个子类只能继承一个父类,一个孩子只能有一个亲爸

但是可以进行多层继承,意思就是父类还可以有父类


访问限制:在父类中的私有成员不能被子类访问,所以通过setter 和getter方法供子类访问父类中的非私有方法。

在Java机制中,首先执行父类中的内容,再执行子类中的内容,即没有父亲就没有孩子,对于子类的构造方法中,隐含了super();,所以有时也将父类称为超类。


方法的覆写:在继承的关系中也存在方法的覆写,即子类中覆写父类中的方法。但是被子类覆写的方法不能拥有比父类更低的访问权限。 目前接触的权限有:private<default<public。

如果子类中的方法权限实在低于父类中的权限,只能通过super的方法来实现,实例如下:

class Person{		// 定义父类
	void print(){	// 默认的访问权限
		System.out.println("Person --> void print()。") ;
	}
};
class Student extends Person{	// 定义继承关系
	public void print(){
		super.print() ;	// 访问父类中被子类覆写过的方法
		System.out.println("Student --> void print()。") ;
	}
};
public class OverrideDemo03{
	public static void main(String args[]){
		Student s = new Student() ;
		s.print() ;
	}
};

研究此问题意义不大。


方法重载和覆写的区别:

JAVA笔记:Java中的继承总结_第1张图片


super关键字

super关键字的作用是在子类中调用父类的指定操作,例如:调用属性、方法、构造等。

但在子类中要调用父类的有参构造,必须要声明参数,super(参数,参数)

JAVA笔记:Java中的继承总结_第2张图片


继承的应用:

实例:定义一个整形数组类,要求包含构造方法,增加数据及输出数据成员方法,并利用数组实现动态内存分配,在此基础上定义出以下子类:

A:排序类,实现数组的排序

B:数组反转类,实现数据的反向存放


代码:

class Array{		// 表示数组
	private int temp[] ;		// 整型数组
	private int foot ;	// 定义添加位置
	public Array(int len){
		if(len>0){
			this.temp = new int[len] ;
		}else{
			this.temp = new int[1] ;	// 最少维持空间是1个
		}
	}
	public boolean add(int i){	// 增加元素
		if(this.foot<this.temp.length){	// 还有空间
			this.temp[foot] = i ;	// 增加元素
			this.foot ++ ;// 修改脚标
			return true ;
		}else{
			return false ;
		}
	}
	public int[] getArray(){
		return this.temp ;
	}
};
class SortArray extends Array{	// 排序类
	public SortArray(int len){
		super(len) ;
	}
	public int[] getArray(){	// 覆写方法
		java.util.Arrays.sort(super.getArray()) ;	// 排序操作
		return super.getArray() ;
	}
};
class ReverseArray extends Array{	// 反转操作类
	public ReverseArray(int len){
		super(len) ;
	}
	public int[] getArray() {
		int t[] = new int[super.getArray().length] ;	// 开辟一个新的数组
		int count = t.length - 1 ;
		for(int x=0 ;x<t.length;x++){
			t[count] = super.getArray()[x] ;	// 数组反转
			count-- ;
		}
		return t ;
	}
};
public class ArrayDemo{
	public static void main(String args[]){
		// ReverseArray a = null ;	// 声明反转类对象
		// a = new ReverseArray(5) ;	// 开辟5个空间大小
		SortArray a = null ;
		a = new SortArray(5) ;
		System.out.print(a.add(23) + "\t") ;
		System.out.print(a.add(21) + "\t") ;
		System.out.print(a.add(2) + "\t") ;
		System.out.print(a.add(42) + "\t") ;
		System.out.print(a.add(5) + "\t") ;
		System.out.print(a.add(6) + "\t") ;
		print(a.getArray()) ;

	}
	public static void print(int i[]){	// 输出数组内容
		for(int x=0;x<i.length;x++){
			System.out.print(i[x] + "、") ;
		}
	}
};




你可能感兴趣的:(JAVA笔记:Java中的继承总结)