继承:
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这个属性,那么所有继承于此类的子类,都必须经过删改。
所以多提升代码的独立性。