六、面向对象之继承——小白秃头史07

继承

什么是继承？

继承是java中的一种机制，子类可以继承父类的所有属性和方法，子类也可以添加新的属性与方法

关键字 extends

extends关键字用于继承，中文意思延伸，
class A extends B;表示A 是B的延伸 ，在java中被继承的类称为父类或超类，新类叫做子类

继承的作用

提高了代码的复用性

属性与方法的重写

会继承父类的属性和方法，那么子类可以修改所继承父类的属性和方法吗？
当然可以，如果子类仅仅是将父类的属性和方法复制一份，那么子类的存在就没有意义了；
子类既是父类的扩展，那子类定然会有父类没有的东西

属性的重写

子类重写父类属性前：

//定义一个A类
public class A{
	static String name = "张翠山";
    static int age = 43;
    public static void main(String[] args) {
        System.out.println("姓名:" + name);
        System.out.println("年龄:" + age);
    }
}

//定义一个B类，继承与A类
public class B extends A{
	public static void main(String[] args) {
        System.out.println("姓名:" + name);
        System.out.println("年龄:" + age);
    }
}

/*
* A类输出结果：
* 姓名:张翠山
* 年龄:43
*/
/*
* B类输出结果：
* 姓名:张翠山
* 年龄:43
* B类中的name和age是继承父类的，所以输出结果与父类相同
*/

子类重写父类属性后：

//定义一个A类
public class A{
	static String name = "张翠山";
    static int age = 43;
    public static void main(String[] args) {
        System.out.println("姓名:" + name);
        System.out.println("年龄:" + age);
    }
}

//定义一个B类，继承与A类
public class B extends A{
	static String name = "张无忌";
    static int age = 19;
    public static void main(String[] args) {
        System.out.println("姓名:" + name);
        System.out.println("年龄:" + age);
    }
}

/*
* A类输出结果：
* 姓名:张翠山
* 年龄:43
*/
/*
* B类输出结果：
* 姓名:张无忌
* 年龄:19
* B类中的name和age是自己复制的，所以输出结果与父类相同
*/

方法的重写

子类重写父类属性前：

//父类
public class A {                             
    private String name = "张翠山";   
    
	//main方法
    public static void main(String[] args) { 
        kungFu();                            
    }                                        
                                             
    public static void kungFu(){             
        System.out.println("武当长拳");          
    }                                        
}    

//子类
public class B extends A{
    private String name = "张翠山";

    public static void main(String[] args) {
        kungFu();
    }
}

/*
* A类输出结果：
* 我会的功夫有：
* 武当长拳
* 
* B类输出结果：
* 我会的功夫有：
* 武当长拳
*/

张无忌是张翠山的儿子，从父亲那里学会了武当长拳，后又学会九阳神功和乾坤大挪移
子类重写父类属性后：

//父类
public class A {                             
    private String name = "张翠山";   
    
	//main方法
    public static void main(String[] args) { 
        kungFu();                            
    }                                        
                                             
    public static void kungFu(){             
        System.out.println("武当长拳");          
    }                                        
}    

//子类
public class B extends A{
    private String name = "张翠山";

    public static void main(String[] args) {
        kungFu();
    }

    //重写方法
    public static void kungFu(){
        System.out.println("我会的功夫有：");
        System.out.println("武当长拳");
        System.out.println("九阳神功");
        System.out.println("乾坤大挪移");
    }
}

/*
* A类输出结果：
* 我会的功夫有：
* 武当长拳
* 
* B类输出结果：
* 我会的功夫有：
* 武当长拳
* 九阳神功
* 乾坤大挪移
*/

方法覆盖重写的注意事项：

1. 须保证父子类之间方法的名称相同，参数列表也相同。
   @Override：写在方法前面，用来检测是不是有效的正确覆盖重写。
   这个注解就算不写，只要满足要求，也是正确的方法覆盖重写。
2. 子类方法的返回值必须【小于等于】父类方法的返回值范围。
   小扩展提示：java.lang.Object类是所有类的公共最高父类(祖宗类)，java.lang.String
   就是Object的子类。
3. 子类方法的权限必须【大于等于】父类方法的权限修饰符。
   小扩展提示：public > protected > (default) > private
   备注：(default)不是关键字，default而是什么都不写，留空

super

• 概念：
  • 只能出现继承关系中的子类中
  • 代表当前类的父类的对象

用法：

• 在子类的成员方法中，访问父类的成员变量。
• 在子类的成员方法中，访问父类的成员方法。
• 在子类的构造方法中，访问父类的构造方法。
  继承关系中，父子类构造方法的访问特点：
  1. 子类构造方法当中有一个默认隐含的"super()"调用，所有一定是先调用父类构造，后执行子类构造
  2. 子类构造可以通过super关键字来调用父类重载构造。
  3. super的父类构造调用，必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。
  4. 总结：
     子类必须调用父类构造方法，不写则赠送super();写了则用写的指定的super调用，super只能有一个，还必须是子类构造方法的第一个。

再谈this

super关键字用来访问父类内容，而this关键字用来访问本类内容。
用法也有三种

1. 用在本类的成员方法中，访问本类的成员变量
2. 在本类的成员方法中，访问本类的另一个成员方法
3. 在本类的构造方法中，调用本类的另一个构造方法
   在第三种用法中要注意：
   • 调用也必须是构造方法的第一个语句
   • super和this构造方法调用，不能同时使用

抽象

• 关键字：abstract
• 抽象方法：在修饰符后面加上abstract，然后去掉大括号，分号结束
• 抽象类：在class前面加上abstract即可

抽象的特点

1. 不能直接创建(new)抽象类对象
2. 必须用一个子类来继承抽象父类
3. 子类必须重写抽象父类的所有抽象方法

abstract 关键字，和哪些关键字不能共存 :

• final：被final修饰的类不能有子类（不能被继承）。而被abstract修饰的类一定是一个父类（一定要被继承）。
• private: 抽象类中的私有的抽象方法，不被子类所知，就无法被复写。而抽象方法出现的就是需要被复写。
• static：如果static可以修饰抽象方法，那么连对象都省了，直接类名调用就可以了。