美文网首页java基础回顾
一篇文章说明白继承、封装、多态

一篇文章说明白继承、封装、多态

作者: IT楠老师 | 来源:发表于2020-01-26 13:18 被阅读0次

      某公园出台新政策不让宠物狗进入园区,需要立一个牌子,那牌子上写的绝对是“宠物狗禁止入内”,而不是“泰迪不能入内”,更不应该是“张三家的那条棕色的会打滚的泰迪不得入内”。

      如果我们将宠物狗理解成为一种事物,那它既可以是泰迪,也可以是阿拉斯加,他一样可以是“张三家的那条棕色的会打滚的泰迪”。

      我们进行一次归纳,首先肯定的是“张三家的那条棕色的会打滚的泰迪”是泰迪,当然泰迪也是狗,对吧!这些东西本应就是理所应当,谁都知道的事情。而在我们java的世界里恰恰正是利用这种简单的思想把面向对象使用的极其灵活。在java里泰迪是“张三家的那条棕色的会打滚的泰迪”的父类,狗是泰迪的父类,反之我们称之为子类。众所周知,“张三家的那条棕色的会打滚的泰迪”他一定拥有泰迪这个品种所共有的的特征和能力,而泰迪一样拥有狗这种事物所共有的能力和特征。

    总结一下:

    1、子类拥有父类一切的特征和能力,我们将这种情况称之为继承。

    举例:

      宠物狗能汪汪叫,泰迪一定也能。

    public class Dog {
        //名字
        private String name = "狗";
        //狗叫
        public void bark(){
            System.out.println("【"+ this.name + "】在汪汪汪叫");
        }
    
        public void setName(String name) {
            this.name = name;
        }
        public String getName() {
            return name;
        }
    }
    
    //定义泰迪
    public class Teddy extends Dog {
        //玩耍
        public void play(){
            System.out.println("【"+ getName() + "】会打滚!!");
        }
    }
    
    public class Test {
        public static void main(String[] args) {
            Teddy teddy = new Teddy();
            //以下两个方法泰迪都没有,但是父类有,他拥有父类的一切,所以他能调用
            //也可以这么说,有一哥们问你借钱,你发现自己没有,于是说我看看我爸有没有,有的话借给你
            teddy.setName("小黑");
            teddy.bark();
            //除了父类的方法,泰迪还能有自己的特有的方法
            teddy.play();
        }
    }
    
    结果:
    【小黑】在汪汪汪叫
    【小黑】会打滚!!
    

    但是泰迪的叫可能又和一般的狗都不一样,不一样怎么办,我们就要把狗的叫声重新实现一下,这叫个过程叫重写,重写是重写父类的方法,是使他拥有和父类名字一样,实现不一样的方法,那么以后调用条件的叫的方法时就是泰迪叫,而非狗叫。

    public class Teddy extends Dog {
        @Override
        public void bark(){
              System.out.println("【"+ this.name + "】在泰迪叫");
        }
    }
    

    2、因为子类拥有父类一切的能力,子类就能当父类用,你定义一个父类,就能使用一个子类的实例去帮助他完成工作(父类引用指向子类对象),反之不可以。多种子类使用不同的实现方式完成同一种功能时,叫做多态。也就是不同的子类调用相同的方法产生不同的结果,就叫做多态。

    思考:我这么说,有条金毛犬(new 出来的)即是金毛犬类,又是狗类对不对。
    既然我金毛犬类的引用可以指向这个实例,因为这个实例就是金毛。
    那狗类的引用当然能指向这个实例,因为这个实例就是个狗。
    反之不然。

    举例:
    public class Cibotium extends Dog {
         @Override
        public void bark(){
              System.out.println("【"+ this.name + "】在金毛叫");
        }
    }
    
    public static void main(String[] args) {
        //大概的意思就是子类泰迪能当成狗来用
        Dog dog = new Teddy();          //父类引用指向子类对象
        dog.setName("小泰迪");
        dog.bark();
        //大概的意思就是子类金毛能当成狗来用
        Dog dog1 = new Cibotium();
        dog1.setName("小金毛");
        dog1.bark();
    
        //两种狗因为重写了父类的方法,导致都在叫,但是叫的方式不一样了。
    }
    
    结果:
    【小泰迪】在泰迪叫
    【小金毛】在金毛叫
    

    3、面向对象还有一个重要思想,叫封装。我觉得一句话解释就是所有高级的东西都是由简单的事物封装而成。

      类就是一种封装,java里有狗吗?没有。有泰迪吗?依然没有。那我们所写的类本身就是利用基础类型,方法,以及包括其他的类共同组织打包封装而成的,所以每一个类都是一种封装。封装的目的是让事物更高级,人用起来更简单。java里没有什么就封装一个,什么类不好用就进一步封装。

    例子:

      我们使用基本类型int ,引用类型String,以及方法封装一个学生类,然后使用学生加其他封装一个班级类,再使用班级类进一步封装学校类。我们可以使用班级或学校作为整体进行操作。

    public class Student {
        private String name;
        private int age;
    
        public Student(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        public void say(String words){
            System.out.println("【" + this.name + "】说:“"+ words +"”");
        }
    }
    
    public class MyClass {
    
        private String myClassName;
        private List<Student> students = new ArrayList<>();
    
        public MyClass(String myClassName) {
            this.myClassName = myClassName;
        }
    
        public void play(){
            for (Student student : students) {
                student.say(myClassName+"组织的活动真好玩!");
            }
        }
    
        public void addStudent(Student student){
            this.students.add(student);
        }
    
        public List<Student> getStudents(){
            return this.students;
        }
    }
    
    public class School {
    
        private String schoolName;
        private List<MyClass> myClasses = new ArrayList<>();
    
        public School(String schoolName) {
            this.schoolName = schoolName;
        }
    
        //学校组织娱乐活动
        public void play(){
            for (MyClass myClass : myClasses) {
                for (Student student : myClass.getStudents()) {
                    student.say(schoolName+"组织的活动真好玩!");
                }
            }
        }
    
        public void addClass(MyClass myClass){
            this.myClasses.add(myClass);
        }
    
        public List<MyClass> getMyClass(){
            return this.myClasses;
        }
    
        public int classSize(){
            return this.myClasses.size();
        }
    }
    
    public class Test {
        public static void main(String[] args) {
            Student lucy = new Student("lucy",18);
            Student jerry = new Student("Jerry",16);
            Student david = new Student("David",18);
            Student bill = new Student("Bill",14);
    
            MyClass myClassOne = new MyClass("一年级一班");
            MyClass myClassTwo = new MyClass("二年级二班");
            myClassOne.addStudent(lucy);
            myClassOne.addStudent(jerry);
            myClassOne.play();
            System.out.println("--------------------------------------------");
            myClassTwo.addStudent(david);
            myClassTwo.addStudent(bill);
            myClassTwo.play();
            System.out.println("--------------------------------------------");
            School school = new School("实验小学");
            school.addClass(myClassOne);
            school.addClass(myClassTwo);
            school.play();
        }
    }
    
    结果:
    【lucy】说:“一年级一班组织的活动真好玩!”
    【Jerry】说:“一年级一班组织的活动真好玩!”
    --------------------------------------------
    【David】说:“二年级二班组织的活动真好玩!”
    【Bill】说:“二年级二班组织的活动真好玩!”
    --------------------------------------------
    【lucy】说:“实验小学组织的活动真好玩!”
    【Jerry】说:“实验小学组织的活动真好玩!”
    【David】说:“实验小学组织的活动真好玩!”
    【Bill】说:“实验小学组织的活动真好玩!”
    

    相关文章

      网友评论

        本文标题:一篇文章说明白继承、封装、多态

        本文链接:https://www.haomeiwen.com/subject/qayjthtx.html