java自学之路六（继承）

标签：不能   调用父类构造方法   system   double   行修改   访问   cte   return   必须   

继承

格式：

• public class 子类名称 extends 父类名称 {}

public class Employee {
    public void method() {
        System.out.println("方法执行！");
    }
}

public class Teacher extends Employee{
    public static void main(String[] args) {
        Teacher teacher = new Teacher();
        teacher.method();
    }
}

super

访问父类的重名变量

    public void method(){
        int age = 20;
        System.out.println(age);  //20
        System.out.println(this.age);  //25
        System.out.println(super.age);  //30
    }

重写

用@Override可以检测是否重写成功

注意：

• 子类方法的返回值，必须小于等于父类方法的返回值范围。java.lang.object是所有类的公共最高父类

• 子类方法的权限必须 大于等于 父类方法的权限修饰符。

  public > protected > (default) > private，default不是关键字，而是什么都不写，留空。

设计原则

对于已经投入使用的类，尽量不要进行修改，推荐定义一个新的类，来重复利用其中共性内容，并且添加改动新内容

父子类构造方法的访问特点

注意：

1. 子类构造方法当中有一个默认隐含的super()调用，所以一定是先调用父类，后调用子类。
2. 可以通过super关键字来构造调用父类重载构造
3. super的父类构造调用，必须是子类构造方法的第一个语句，不能一个子类构造调用多次super构造

public class Father {
    public Father(){
        System.out.println("父类构造方法");
    }
}

public class Son extends Father {
    public Son(){
        System.out.println("子类构造方法");
    }

    public static void main(String[] args) {
        Son son = new Son();
    }
}

带参数的情况，用super调用父类重载的构造方法

    public Father(int age){
        System.out.println(age);
    }

    public Son(){
        super(13);
        System.out.println("子类构造方法");
    }

    public static void main(String[] args) {
        Son son = new Son();
    }

总结：子类必须调用父类构造方法，不写则赠送super()，写了则用写的指定super调用，必须在第一行。

this的用法

public class Daughter {
    public Daughter(){
        this(23);  // 本类的无参构造，调用本类的有参构造。
    }
    public Daughter(int n){
        
    }
}

1. 在本类的成员方法中，访问本类的成员变量。
2. 在本类的成员方法中，访问本类的另一个成员方法。
3. 在本类的构造方法中，访问本类的另一个构造方法。（this（...）调用必须是构造方法的第一个语句，唯一一个。）

继承特性（重要）

java语言是单继承的

抽象方法

加上abstract关键字，去掉大括号，直接分号结束

抽象方法所在的类，必须是抽象类，在class之前写上abstract即可

public abstract class Animal {
//    抽象方法
    public abstract void eat();
    public void method(){
        
    }
}

如何使用抽象方法和抽象类

1. 不能直接创建new抽象类对象。

2. 必须用一个子类来继承抽象父类。

3. 子类必须覆盖重写父类当中所有的抽象方法，去掉抽象方法的abstract关键字，然后不上方法体大括号。

4. 创建子类对象进行使用

   public abstract class Animal {
   //    抽象方法
       public abstract void eat();
       public void method(){
           System.out.println("执行了animal方法");
       }
   }
   

   public class Dog extends Animal{
       public void eat(){
           System.out.println("小狗吃东西");
       }
   }

   public class Demo01 {
       public static void main(String[] args) {
           Dog dog = new Dog();
           dog.eat();
       }
   }
   

如果继承了抽象类并没有重写所有方法，则还是个抽象类。

习题分红包

总结：

1. 范型首字母大写

2. 子类用get set获取父类属性

   public class User {
       private String name;
       private double money;
   
       public User() {
       }
   
       public User(String name, double money) {
           this.name = name;
           this.money = money;
       }
   
       public void show(){
           System.out.println("我是"+name+",有"+getMoney()+"元");
       }
   
       public String getName() {
           return name;
       }
   
       public double getMoney() {
           return money;
       }
   
       public void setName(String name) {
           this.name = name;
       }
   
       public void setMoney(double money) {
           this.money = money;
       }
   }
   

   public class Host extends User{
       public Host() {
       }
   
       public Host(String name, double money) {
           super(name, money);
       }
   
       public ArrayList<Double> send(double gift, int count){
           ArrayList<Double> moneyArray = new ArrayList<>();
           double money = super.getMoney() - gift;
           if(gift > getMoney()){
               System.out.println(getMoney());
               System.out.println("余额不足");
               return moneyArray;
           }
           for (int i = 0; i < count; i++) {
               if(i==count-1){
                   double lastGift = gift;
                   moneyArray.add(lastGift);
               }else{
                   double perGift = new Random().nextDouble()*(Math.floor(gift));
                   gift -= perGift;
                   moneyArray.add(perGift);
               }
           }
   
   
   
           setMoney(money);
           return moneyArray;
       }
   }
   

   public class Customer extends User{
       public Customer() {
       }
   
       public Customer(String name, double money) {
           super(name, money);
       }
   
   
       public double receive(ArrayList<Double> moneyArray){
           int index = new Random().nextInt(moneyArray.size());
           double delta = moneyArray.get(index);
           moneyArray.remove(index);
           super.setMoney(super.getMoney() + delta);
           return delta;
       }
   }

   public class Demo02Test {
       public static void main(String[] args) {
           Host host = new Host();
           Customer customer1 = new Customer();
           Customer customer2 = new Customer();
           Customer customer3 = new Customer();
           Customer customer4 = new Customer();
           host.setName("群主");
           customer1.setName("二哈");
           customer2.setName("三哈");
           customer3.setName("四哈");
           customer4.setName("五哈");
           host.setMoney(29);
           customer1.setMoney(0);
           customer2.setMoney(0);
           customer3.setMoney(0);
           customer4.setMoney(0);
   
   
           ArrayList<Double> res = host.send(27, 4);
           host.show();
           double r1 = customer1.receive(res);
           customer1.show();
           double r2 = customer2.receive(res);
           customer2.show();
           double r3 = customer3.receive(res);
           customer3.show();
           double r4 = customer4.receive(res);
           customer4.show();
           System.out.println(r1 + r2 + r3 + r4);
       }
   }
   

java自学之路六（继承）

标签：不能   调用父类构造方法   system   double   行修改   访问   cte   return   必须   

原文地址：https://www.cnblogs.com/jimmyhe/p/11566910.html