[14]继承-1

继承：

A is B。

比如苹果是水果。所以水果是苹果的父类。而水果不一定是苹果，所以苹果不是水果的父类。

再比如，犬科是动物类的一种，所以犬科继承于动物类。动物类是父类。

而继承与父类，会拥有父类的属性。比如动物可以移动，所以犬科也会移动。并且在此基础上重写，是4条腿移动。

1.成员变量

父类中private修饰的成员变量，子类无法直接访问。

子类无法直接进行访问，但在堆内的对象中是占有内存的，只是没有权限。

class Fu{
    private int num1=3;
}

class Zi{
    int num2=4;
    void show(){
        System.out.println(num1); //报错
        System.out.println(num2);    
    }
}

特殊情况：

当子类和父类拥有拥有同名的变量。会先访问子类的，如果子类没有，才会访问父类的。

public class Fu {
	int num1=1;
}

public class Zi extends Fu{
	int num1=0;
	void show() {
		System.out.println(num1);
	}
}

public class Demo1 {
	public static void main(String[] args) {
		Zi zi=new Zi();
		zi.show();//显示结果为0，如果将子类的num1去掉，结果为1
	}
}

如果要直接访问父类的元素。用super.变量

如果要访问当前的对象用this.变量

super: 代表父类的内存空间

this:代表当前的对象的引用

2.成员函数

特殊情况：子类父类有同名的方法时，先调用子类的方法，如果没有的话，那么调用父类

函数继承关系运用了重写

举例手机

public class Demo {
	public static void main(String[] args) {
		Phone phone=new Phone();
		phone.setName("phone");
		phone.show();
		SmartPhone smartPhone=new SmartPhone();
		smartPhone.setName("sPhone");
		smartPhone.show();
	}
}

public class Phone {
	private String name;
	
	public void setName(String name) {
		this.name = name;
	}
	
	public String getName() {
		return name;
	}
	
	void show() {
		System.out.println(this.name+"  打电话");
	}
}

public class SmartPhone extends Phone{
	void show() {
		super.show();
		System.out.println(this.getName()+"  打游戏");
	}
}

1.setName和getName方法,name属性都可以通过继承使用。

2.show方法也可以直接使用，但如果对某些方法不够满意，可以自己重写该方法。

3.例如：以前的翻盖手机只能用来打电话。而现在的智能手机可以打游戏。而也有打电话的功能

那么我们不仅要保留以前的打电话功能也要延伸打游戏的功能

4.如果要保留父类的方法内容，通过super.方法名

重写（override）注意事项：

1.子类重写父类必须保证权限大于等于父类的权限。若父类是private那么无论子类是什么都可以重写

2.静态只能重写静态，静态也只能被静态重写。

因为非静态是对象的创建才产生，静态是随着类加载就产生。

3.和重载不一样，必须方法名，返回值修饰符，形参一致

3.构造函数

子类实例化过程：

1.调用子类的构造函数进行初始化，子类的构造函数中第一句有隐式的super()，所以就会调用父类的构造函数。

2.调用父类中的构造函数，执行完后，再执行自身。

如果初始化子类的构造函数时不想要默认的父类构造函数，super(有参)父类的构造函数就行

父类也必须写一个有参的构造函数。父类如果只有有参构造函数，那么子类就必须显示写super(有参)

 子类实例化细节：

1.this和super有且只能有一个在构造函数的第一行。默认为super。

2.无论怎么this,必须有一个构造参数为super。

class Fu{
    String name;
    public Fu(){
        //super();
    }
}

class Zi{
    public Zi(){
        //super();
        //如果这里写this肯定不行，因为this()就是调用当前对象的构造函数
        //如果写this(name)那么就会进入死循环，有些编译器会直接报错，不让通过
    }

    public Zi(String name){
        this();
    }
}

所有的类都有一个父类：Object

所以无论是什么类，就算一个父类并没有extends类，其实构造函数的第一句都有一个隐式super()

继承的弊端：打破封装性

封装：隐藏代码细节，仅对外提供访问方式。

而父类封装的代码，子类会原封不动的继承，可以直接使用。或是重写。打破了封装性。

开发原则：

高内聚，低耦合

内聚：独立性

耦合：类与类之间的关系

因为继承， 类与类之间的关系就更加强烈。例如父类有name，子类用到了name。但如果后来修改程序，去除了name这个属性，那么所有继承于此类的子类，都必须经过删改。

所以多提升代码的独立性。