继承，super关键字，方法重写，final关键字

 

继承

描述类的时候，我们如果发现几个类有重复的属性和方法我们就可以采用继承的方法来设计。

子类会把父类所有的属性和方法继承下来（不能继承final修饰的方法）。

子类使用extends关键字继承父类的共同属性以外，子类还可以有自己特有的属性或方法。

父类更通用，子类更具体。

子类只能获得父类中的非private的属性，如果想要使用父类就要提供公共的set和get方法。私有的方法是无法继承下来的。

Java中只能做单继承。

Java支持多级继承。

//首先定义一个父类
class Dog{
    //添加属性和方法
    private String name;
    private int age;
    public void setName(String name){
        this.name = name;
        }
    public String getName(){
        return name;
    }
    public void setAge(int name){
        this.age = age;
        }
    public int getAge(){
        return age;
        }
    public void sleep(){
        System.out.println(this.name+"在睡觉");
        }
    }
    
//定义一个子类
class SmallDog extends Dog{
    public void eat(){
        System.out.println(getName()+"在啃骨头");
        }
    }
    
class BigDog extends Dog{
    public void ProtectedHome(){
        System.out.println(getName()+"在看家");
        }
    }
    
class ExtendsDemo{
    public static void main(String[] args){
        //对象实例化，然后分别调用父类和子类里的方法
        SmallDog sg = new SmallDog();
        sg.setName("旺财");
        String name = sg.getName();
        sg.sleep();
        sg.eat();
        /**BigDog bg = new BigDog();
        bg.name = "小丑";
        bg.sleep();
        bg.ProtectedHome();
        */
        }
    }

 

 

super的特点：

1.子类实例化的过程中父类的构造器先被调用，然后在调用子类的构造器。

2.子类的构造器被调用的时候父类的默认构造器就会被调用（父类如果存在着有参数的构造器，一定要把默认的构造器显示的定义出来）。

3.子类在调用父类的有参数的构造器的时候使用super（参数列表...），这时父类默认的构造器就不会再被调用了，super一定是在第一行。

class Cat{
    //使用super
    String name;
    int age;
    //在父类中定义两个构造器，一个有参数，把默认的构造器也显式的定义出来
    public Cat(){
        System.out.println("父类默认的构造器被调用了");
        }
    public Cat(String name){
        System.out.println("父类有参数的构造器被调用了");
        }
}
//子类
class SmallCat extends Cat{
    //在子类中也分别定义两个构造器，一个默认构造器和一个有参数的构造器
    public SmallCat(){
        //这里被隐藏的有一个super()，它是用来调用父类默认构造器的
        //在这里，父类默认的构造器要比子类的默认构造器先调用
        System.out.println("子类的默认构造器被调用了");
    }
    public SmallCat(String name){
        /**
        *如果在这里加上super(name)，那么父类的默认构造器则不会被调用了，被调用的会是父类的有参数的构造器
        */
        System.out.println("子类的有参数的构造器被调用了");
        }
    }
    
class TestCat{
    public static void main(String[] args){
        SmallCat sc = new SmallCat();
        System.out.println();
        SmallCat sc1 = new SmallCat("大黑");
        }
    }

 

 

方法重写：

父类和子类有相同的方法（方法名，参数个数和类型，返回值相同，方法体不同），子类会覆盖父类的方法，所以外部创建对象调用该方法时一定是调用的子类的方法。

class Cat{
    //使用super
    String name;
    int age;
    //在父类中定义两个构造器，一个有参数，把默认的构造器也显式的定义出来
    public Cat(){
        System.out.println("父类默认的构造器被调用了");
        }
    public Cat(String name){
        System.out.println("父类有参数的构造器被调用了");
        }
    public void eat(){
        System.out.println("在吃鱼");
        }
}
//子类
class SmallCat extends Cat{
    //在子类中也分别定义两个构造器，一个默认构造器和一个有参数的构造器
    public SmallCat(){
        //这里被隐藏的有一个super()，它是用来调用父类默认构造器的
        //在这里，父类默认的构造器要比子类的默认构造器先调用
        System.out.println("子类的默认构造器被调用了");
    }
    public SmallCat(String name){
        /**
        *如果在这里加上super(name)，那么父类的默认构造器则不会被调用了，被调用的会是父类的有参数的构造器
        */
        super(name);
        System.out.println("子类的有参数的构造器被调用了");
       }
        public void eat(){
        System.out.println("在吃大鱼");
        
        }
    }
    
class TestCat{
    public static void main(String[] args){
        SmallCat sc = new SmallCat();
        sc.eat();
        System.out.println();
        SmallCat sc1 = new SmallCat("大黑");
        sc1.eat();
        }
    }

 

final关键字：

修饰在方法上：

final修饰的方法不能被重写

语法：

        权限修饰符    final    返回值类型    方法名（参数列表）{

               方法体

        }

class Cat{
    //final修饰在方法上
    String name;
    public final void eat(){
        System.out.println(this.name+"在吃鱼");
        }
    }
    
class BigCat extends Cat{
    public void eat(){
        System.out.println(this.name+"在吃大鱼");
        }
    }
    
class TestCat{
    public static void main(String[] args){
        BigCat bc = new BigCat();
        bc.name = "大黑";
        bc.eat();
        }
    }

 

修饰在属性上

语法：

         权限修饰符     [static]      final      数据类型      属性名   =    值;

final修饰在属性上，属性的值不能再改变。

class Cat{
    //final修饰在属性上
    String name;
    public final float PAI = 3.14f; 
    
        }
    
    

class TestCat{
    public static void main(String[] args){
        Cat cat = new Cat();
        cat.name = "大黑";
        cat.PAI = 0.8f;
        }
    }

 

修饰在类上

语法：

          final     class   类名{

                 属性

                 方法

}

使用final修饰的类是不可以被继承的。

final class Cat{
    //final修饰在类上
    String name;

}
class BigCat extends Cat{
    public void sleep(){
        System.out.println("在睡觉");
        }
    }
    
    

class TestCat{
    public static void main(String[] args){
        BigCat cat = new BigCat();
        cat.name = "大黑";
        
        }
    }

 

抽象类：

抽象方法概念：当多个具体的实体类存在着共同的行为，但是有不同的表现，在子类继承过程中父类的方法的具体实现不能确定，但是能确定的是他们都有这种行为，把这种行为方法叫做抽象方法。

语法：

        public    abstract     [返回值]      [void]     方法名（参数列表）；没有方法体。

如果一个类中存在这样一个方法，那么这个类一定是抽象类。这个类上也要有abstract标识。

抽象类的语法：

        abstract     class     类名{

              属性

              方法

}

注意：抽象类中可以没有抽象方法，但是有抽象方法的类一定是抽象类。

抽象类的特点：

1.抽象类不能被实例化。

2.如果一个子类继承了抽象类就必须实现抽象类中的所有抽象方法。

3.抽象类必须被子类继承才能使用子类实例化。

4.抽象类也可以继承抽象类，这样不需要实现父抽象类的方法。

5.抽象类的抽象方法不能和private，final，static共存。

abstract class Cat{
    //抽象类
    String name;
    int age;
    public abstract void sleep();
}

class BigCat extends Cat{
    public void sleep(){
        System.out.println(this.name+"在地毯上睡觉");
        }
    }
    
class SmallCat extends Cat{
    public void sleep(){
        System.out.println(this.name+"在窝里睡觉");
        }
    }
class TestCat{
    public static void main(String[] args){
        BigCat bg = new BigCat();
        bg.name = "大黑";
        bg.sleep();
        SmallCat sc = new SmallCat();
        sc.name = "二黑";
        sc.sleep();
        }
    }