Java中继承知识点总结

继承的概念:
将多个类中的共同代码单独提取出来,形成一个独立的类,多个类和当前独立的类产生一种关系: 继承关系 : extends
继承的好处:
1)提高了代码的复用性
2)提高了代码维护性
3)类和类产生这种关系,是多态的前提条件!
Java中的开发原则: Java的所有原则以及Java 23种设计模式,都需要遵循低耦合,高内聚
低耦合,高内聚 (降低耦合性,提高内聚性)
耦合:指的是类和类产生的关系(关系越少越好),一旦一个类中有问题了 ,其他类可能都会受牵连!
内聚:完成一件事情的能力(一个类中如果能完成,尽量一个类完成)
关键字:
extends

		*/
//使用继承前
/*
class Student{
	private String name ;
	private int age ;
		public Student(){}
	public Student(String name ,int age){
		this.name = name ;
		this.age =age ;
	}
	public void setName(String name){
		this.name = name ;
	}
	public void setAge(int age){
		this.age = age ;
	}
	public String getName(){
		return name ;
	}
	public int getAge(){
		return age ;
	}
	public void study(){
	System.out.println("正在学习继承...");
	}
	
}
*/
//使用继承
//定义一个类 Person
class Person{
	private String name ;
	private int age ;
	public Person(){}
	public Person(String name ,int age){
		this.name = name ;
		this.age =age ;
	}
	public void setName(String name){
		this.name = name ;
	}
	public void setAge(int age){
		this.age = age ;
	}
	public String getName(){
		return name ;
	}
	public int getAge(){
		return age ;
	}
		public void study(){
		System.out.println("人都需要学习...");
	}
	
}

//子类继承父类
class Student extends Person{
/*
	public void setName(String name){
		this.name = name ;
	}
	public void setAge(int age){
		this.age = age ;
	}
	public String getName(){
		return name ;
	}
	public int getAge(){
		return age ;
	}
*/
	public Student(){
	}
	public void playGame(){
		System.out.println("会玩游戏") ;
	}
}
//老师类
class Teacher extends Person{
	public Teacher(){}
	public void smoking(){
		System.out.println("会抽烟...") ;
	}
}
class ExtendsDemo{
	public static void main(String[] args){
		//使用继承前
		/*
		Student s = new Student();
		s.setName("高圆圆") ;
		s.setAge(40) ;
		System.out.println(s.getName()+"---"+s.getAge()) ;
		s.study() ;
		*/
			//使用继承之后
		Student s = new Student() ;
		s.setName("赵又廷");
		s.setAge(37) ;
		s.playGame();
		s.study();
		System.out.println(s.getName()+"---"+s.getAge()) ;
		System.out.println("--------------------------") ;
		Teacher t  = new Teacher() ;
		t.setName("里皮") ;
		t.setAge(70) ;
		System.out.println(t.getName()+"---"+t.getAge()) ;
		t.smoking() ;
		t.study();
		}
}

Java中继承的特点:
1)在Java中,只支持单继承,不支持多继承,在别的语言可能有多继承存在
多继承的语言:class 子类名 extends 父类名1,父类名2{}
2)在Java中,虽然不支持多继承,但是可以多层继承! (分层初始化:先让父类初始化再是子类初始化)在Java中,所有的Java类(自己定义的,Jdk提供的)都继承自 Object类 (上帝)
3)不要为了部分使用功能去使用"继承"
看下面代码

class A{
			public void show1(){}
			public void show2(){}
		}
		class B{
			public void show2(){}
			public void show3(){}
		}
		//发现show2()在A类和B类中都存在,让B类继承自A类
		class B extends A{
			public void show3(){}
		}

虽然思路没有问题,但是B继承自A的同时,show1()可能不需要,所以多继承了一个功能
什么时候用继承?
如果一个类A是类B的一种,或者类B是类A一种,就可以使用继承 (继承体现的是一种"is a"的关系)
需求:
1)输出子类的局部范围的变量 就近原则输出即可
2)通过show方法输出,子类的成员范围内的变量
this.成员变量:当前类的成员位置的成员变量
3)想要通过show()方法,输出父类的成员变量num
如果能够有一个关键字和this很类似,就可以访问
Java提供关键字:super
super:代表父类的空间标识(父类对象的地址值引用)
this和super的使用
访问成员变量:
this.成员变量:访问的当前类的成员变量
super.成员变量:访问的父类的成员变量
访问构造方法:
this()/this(…):访问本类中构造方法
super()/super(…):访问父类中的构造方法
访问成员方法:
this.成员方法名():访问本类中的成员方法
super.成员方法名():访问父类中的成员方法

class Fu3{
	//父类的成员变量
	int num = 10 ;
}
class Zi3 extends Fu3{
	//子类的成员变量
	int num = 20 ;
	public void show(){
		int num = 30 ;
		System.out.println(num) ;
		System.out.println(this.num) ;//访问本类的成员
		System.out.println(super.num);//访问父类的成员
	}
}
//测试类
class ExtendsDemo5{
	public static void main(String[] args){
		//创建子类对象
		Zi3 zi = new Zi3();
		zi.show() ;
	}
}

继承中构造方法初始化的特点*(分层初始化!)
1.继承中,子类不能继承父类的构造方法,但是可以通过super访问父类的构造方法
2.子类的构造方法中(无参/有参),都会默认访问父类的无参构造方法,由于子类继承父类,子类可能会用到父类中数据,所以先让父类进行初始化,再让子类初始化!(分层初始化!)
注意事项: 关于super():访问无参构造方法,必须写在子类构造方法中第一句话.
继承中使用构造方法的注意事项:
需求:子类继承父类的时候,子类的构造方法都会默认访问父类的无参,如果父类中不存在无参构造
会出现什么现象?
编译报错
如何解决?
1)手动显示的给出父类的无参构造方法
2)如果父类的无参构造方法不给出,只能通过super(“随便给”)间接的访问父类的有参构造,即在子类的无参和有参构造方法中都给出super(“随便给”);
3)可以在子类有参构造方法中通过this(),访问本类的无参,然后再通过本类的无参间接通过super(“随便给”)访问父类的有参.
总结一句话:
子类有参构造或者无参构造的一个,必须让父类进行初始化!

package com.extend.cn;
class Father3{
	 //父类的无参构造方法
	 // public Father3(){ 
	 System.out.println("这是父类的无参构造方法") ; }
		//父类的有参构造
	public Father3(String name){
		System.out.println("这是父类的有参构造方法") ;
	}
}
//子类
class Son3 extends Father3{
//子类的无参
	public Son3(){
		//每一个子类的构造方法中默认第一句话:super();
		//super("随便给") ;
		super("随便给") ;
		System.out.println("这是子类的无参构造方法") ;
		}
	//子类的有参
	public Son3(String name){
		//super("随便给") ;
		this() ;//访问本类中的无参构造方法
		System.out.println("这是子类的有参构造方法") ;
	}
}
//测试类
class CodeTest{
	public static void main(String[] args){
			Son3 son = new Son3();
	        Son3 son2 = new Son3("world") ;
	}
}

第一种方式输出:
这是父类的无参构造方法
这是子类的无参构造方法
这是父类的无参构造方法
这是子类的有参构造方法

第二种方式输出:
这是父类的有参构造方法
这是子类的无参构造方法
这是父类的有参构造方法
这是子类的有参构造方法

第三种方式输出:
这是父类的有参构造方法
这是子类的无参构造方法
这是父类的有参构造方法
这是子类的无参构造方法
这是子类的有参构造方法