码迷,mamicode.com
首页 > 编程语言 > 详细

java自学之路六(继承)

时间:2019-09-22 13:13:33      阅读:88      评论:0      收藏:0      [点我收藏+]

标签:不能   调用父类构造方法   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

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!