java中的继承

1.继承

1.1概述

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。

1.2格式

	通过extends关键字可以实现类与类的继承

class 子类名 extends 父类名 {}

单独的这个类称为父类，基类或者超类；这多个类可以称为子类或者派生类。

1.3继承的好处和弊端

1.3.1继承的好处

  a:提高了代码的复用性
  b:提高了代码的维护性
  c:让类与类之间产生了关系，是多态的前提

1.3.2继承的弊端

类的耦合性增强了。
开发的原则：高内聚，低耦合。
  耦合：类与类的关系
  内聚：就是自己完成某件事情的能力

1.4类的继承特点

a:Java只支持单继承，不支持多继承。
  有些语言是支持多继承，格式：extends 类1,类2,…
b:Java支持多层继承(继承体系)

案例演示

Java中类的继承特点

public class demo1 extends Object {
    public static void main(String[] args) {
     D d=new D();
     d.hehe();
     D.hehe();
     d.a();
    }
}
class A extends Object{
    private int a=10;
    public void a(){}
}
class B extends A{
    int b=100;
    private void b(){}
}
class C extends B{
    int c=70;
    public void c(){}
    public static void hehe(){
        System.out.println("静态");
    }
}
class D extends C{

}

1.5继承的注意事项

  a:子类只能继承父类所有非私有的成员(成员方法和成员变量)
  b:子类不能继承父类的构造方法，但是可以通过super关键字去访问父类构造方法。
  c:不要为了部分功能而去继承

1.6什么时候使用继承

继承其实体现的是一种关系：“is a” .
采用假设法。
如果有两个类A,B。只有他们符合A是B的一种，或者B是A的一种，就可以考虑使用继承。

1.7继承中成员变量的关系

A:子类中的成员变量和父类中的成员变量名称不一样
B:子类中的成员变量和父类中的成员变量名称一样
  在子类中访问一个变量的查找顺序(“就近原则”)
  a: 在子类的方法的局部范围找,有就使用
  b: 在子类的成员范围找,有就使用
  c: 在父类的成员范围找,有就使用
  d:如果还找不到,就报错

1.7.1 this和super的区别和应用

A:通过问题引出super
  子类局部范围访问父类成员变量
B:说说this和super的区别
  this  代表的是本类对象的引用
  super  代表的是父类存储空间的标识(可以理解成父类的引用,可以操作父类的成员)
C:this和super的使用
  a:调用成员变量
  this.成员变量  调用本类的成员变量
  super.成员变量  调用父类的成员变量
  b:调用构造方法
  this(…)  调用本类的构造方法
  super(…)   调用父类的构造方法
  c:调用成员方法
  this.成员方法  调用本类的成员方法
  super.成员方法  调用父类的成员方法

1.8继承中构造方法的关系

案例演示

  子类中所有的构造方法默认都会访问父类中空参数的构造方法

1.8.1为什么呢?
  因为子类会继承父类中的数据，可能还会使用父类的数据。
  所以，子类初始化之前，一定要先完成父类数据的初始化。
其实：
每一个构造方法的第一条语句默认都是：super()
Object类。否则有人就会针对父类的构造方法有疑问。Object在没有父类了。

1.8.2继承中构造方法的注意事项

1.8.2.1父类没有无参构造方法,子类怎么办?

a: 在父类中添加一个无参的构造方法
b:子类通过super去显示调用父类其他的带参的构造方法
c:子类通过this去调用本类的其他构造方法
  本类其他构造也必须首先访问了父类构造

1.8.2.2注意事项

super(…)或者this(….)必须出现在第一条语句上

案例演示
看程序写结果1

class Fu{
			public int num = 10;
			public Fu(){
				System.out.println("fu"); 
			}
		}
		class Zi extends Fu{
			public int num = 20;
			public Zi(){
				System.out.println("zi"); 
			}
			public void show(){
				int num = 30;
				System.out.println(num);
				System.out.println(this.num); 
				System.out.println(super.num); 
			}
		}
		class Test {
			public static void main(String[] args) {
				Zi z = new Zi();
				z.show();
			}
		}	

案例演示
看程序写结果2

		class Fu {
			static {
				System.out.println("静态代码块Fu"); 
			}
	
			{
				System.out.println("构造代码块Fu"); 
			}
	
			public Fu() {
				System.out.println("构造方法Fu"); 
			}
		}
	
		class Zi extends Fu {
			static {
				System.out.println("静态代码块Zi");
			}
	
			{
				System.out.println("构造代码块Zi"); 
			}
	
			public Zi() {
				super();
				System.out.println("构造方法Zi"); 
			}
		}
		
		class Test{
			public static void main(String[] args){
				Zi z = new Zi(); 
			}
		}

1.8.3子类会继承父类的构造方法么？

public class MyTest {
    public static void main(String[] args) {
        Son son = new Son();
    }
}
class Father{
    String name;
    //父类的无参构造
    public Father(){
        System.out.println("父类的无参构造");
    }
}
class Son extends Father{
    //子类的无参构造
    public Son(){
        System.out.println("子类的无参构造");
    }
}

结果：

父类的无参构造
子类的无参构造

由输出结果可知，JVM调用了父类的构造方法。那这是否能说明子类会继承父类的构造方法呢？
再来看一个例子：

public class MyTest {
    public static void main(String[] args) {
        Son son = new Son("JAVA");
    }
}
class Father{
    String name;
    //父类的无参构造
    public Father(){
        System.out.println("父类的无参构造");
    }
    //父类的有参构造
    public Father(String name){
        this.name=name;
        System.out.println("父类的有参构造" + name);
    }
}
class Son extends Father{
    //子类的有参构造
    public Son(String name){
        System.out.println("子类的有参构造"+name);
    }
}

结果：

父类的无参构造
子类的有参构造JAVA

从输出可以看出，子类实例化时，JVM调用了父类的无参数的构造器，而没有调用父类的有参数的构造器。如果子类会继承父类的构造方法，那为什么不执行另一个构造方法呢？
原因：

构造方法是一个类独有的方法不会被它的子类继承，但是子类在实例化对象时：如果子类的构造器没有显示的调用父类的构造器，则将自动调用父类默认的构造器（无参）。相当于默认省略了super()。

假如父类只有有参的构造方法时，又会如何呢 ？将上面父类的代码改为：

public class MyTest {
    public static void main(String[] args) {
        Son son = new Son("JAVA");
    }
}
class Father{
    String name;
    //父类的有参构造
    public Father(String name){
        this.name=name;
        System.out.println("父类的有参构造" + name);
    }
}
class Son extends Father{
    //子类的有参构造
    public Son(String name){
        System.out.println("子类的有参构造"+name);
    }
}

结果：

Error:(28, 28) java: 无法将类 org.gouzao.Father中的构造器 Father应用到给定类型;
  需要: java.lang.String
  找到: 没有参数
  原因: 实际参数列表和形式参数列表长度不同

那么子类要使用父类带参数的构造方法又要如何做呢？，看下面代码：

public class MyTest {
    public static void main(String[] args) {
        Son son = new Son("JAVA");
    }
}
class Father{
    String name;
    //父类的有参构造
    public Father(String name){
        this.name=name;
        System.out.println("父类的有参构造" + name);
    }
}
class Son extends Father{
    //子类的有参构造
    public Son(String name){
        super(name);
        System.out.println("子类的有参构造"+name);
    }
}

结果：

父类的有参构造JAVA
子类的有参构造JAVA

原因：

子类如果想使用父类有参的构造方法，必须在子类的构造方法中使用super（参数）表示，而且super必须是子类构造方法中的头一条语句。

所以每个子类构造方法的第一条语句，都是隐含地调用super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。所以父类中的构造方法是不能继承的，但是在实例化子类的时候会调用父类的构造方法
总结：

• 类实例化对象时，会先调用父类的构造器
• 如果子类的构造器没有显示的调用父类的构造器 ，默认调用super();
• 子类要使用父类有参的构造器，使用super（参数）形式，且super必须是子类构造方法中的头一条语句。
• 如果父类没有不带参数的构造器，且子类的构造器中又没显示的调用父类其他构造器，则Java编译器将报告错误。

1.9继承中成员方法关系

a:当子类的方法名和父类的方法名不一样的时候
b:当子类的方法名和父类的方法名一样的时候
  通过子类调用方法:
    a: 先查找子类中有没有该方法,如果有就使用
    b:再看父类中有没有该方法,有就使用
    c: 如果没有就报错