Java继承封装多态

0x001:继承

类的继承格式

  • 在Java中通过extends关键字可以申明一个类是从另外一个类继承而来的,一般形式如下:
    class 父类 {
    }
    class 子类 extends 父类 {
    }

类继承的作用

  • 从这下面两段代码可以看出来,代码存在重复了,导致后果就是代码量大且臃肿,而且维护性不高(维护性主要是后期需要修改的时候,就需要修改很多的代码,容易出错),简单来说就是代码复用

    public class Dog {
         private String name;
         private int id;
         public Dog(String myName, int  myid) {
             name = myName;
             id = myid;
         }
         public void eat(){
             System.out.println(name+"正在吃");
         }
         public void sleep(){
             System.out.println(name+"正在睡");
         }
         public void introduction() {
             System.out.println("大家好!我是" + id + "号" + name + ".");
         }
    }
    public class Cat {
         private String name;
         private int id;
         public Cat(String myName, int myid) {
             name = myName;
             id = myid;
         }
         public void eat(){
             System.out.println(name+"正在吃");
         }
         public void sleep(){
             System.out.println(name+"正在睡");
         }
         public void introduction() {
             System.out.println("大家好!我是" + id + "号" + name + ".");
         }
    }
  • 所以要从根本上解决这两段代码的问题,就需要继承,将两段代码中相同的部分提取出来组成 一个父类,例如:

    public class Animal { 
         private String name;  
         private int id; 
         public Animal(String myName, int myid) { 
             name = myName; 
             id = myid;
         } 
         public void eat(){ 
             System.out.println(name+"正在吃"); 
         }
         public void sleep(){
             System.out.println(name+"正在睡");
         }
         public void introduction() { 
             System.out.println("大家好!我是" + id + "号" + name + "."); 
         } 
    }
  • 这个Animal类就可以作为一个父类,然后狗类和猫类继承这个类之后,就具有父类当中的属性和方法,子类就不会存在重复的代码,维护性也提高,代码也更加简洁,提高代码的复用性(复用性主要是可以多次使用,不用再多次写同样的代码) 继承之后的代码:

    public class Dog extends Animal { 
         public Dog (String myName, int myid) { 
             super(myName, myid); 
         } 
    }
    public class Cat extends Animal { 
         public Cat (String myName, int myid) { 
             super(myName, myid); 
         } 
    }

继承的特点

  • 子类会继承父类的所有public的字段和方法
  • 对于父类的private的字段和方法, 子类中是无法访问的
  • 子类可以拥有自己的属性和方法,即子类可以对父类进行扩展
  • Java 的继承是单继承,但是可以多重继承,单继承就是一个子类只能继承一个父类,多重继承就是,例如 B 类继承 A 类,C 类继承 B 类,所以按照关系就是 B 类是 C 类的父类,A 类是 B 类的父类

继承注意事项

  • 私有的属性和方法不能继承
  • 父类的构造方法不能继承
  • 使用final定义的类不可继承
  • 使用super()调用父类,必需放在第一行
  • 一个子类只能继承一个父类

0x002:封装

封装作用

  • 在面向对象程式设计方法中,封装是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。
  • 封装可以被认为是一个保护屏障,防止该类的代码和数据被外部类定义的代码随机访问。
  • 要访问该类的代码和数据,必须通过严格的接口控制。
  • 封装最主要的功能在于我们能修改自己的实现代码,而不用修改那些调用我们代码的程序片段。
  • 适当的封装可以让程式码更容易理解与维护,也加强了程式码的安全性。

封装的实现

  1. 修改属性的可见性来限制对属性的访问(一般限制为private)
    public class Person {
        /* name和age为私有的,只能本类才能访问 */
        private String name;
        private int age;
    }
  2. 对每个值属性提供对外的公共方法访问,也就是创建一对赋取值方法,用于对私有属性的访问如:get\set方法
    public class Person {
        private String name;
        private int age;
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
    }
  3. 实例化
    class TestDemo{
        public static void main(String[] args) {
            Person person = new Person();
            person.setAge(18);
            person.setName("cjl");
            System.out.println(person.getName());
            System.out.println(person.getAge());
        }
    }

封装的优点

  • 良好的封装能够减少耦合。
  • 类内部的结构可以自由修改。
  • 可以对成员变量进行更精确的控制。
  • 隐藏信息,实现细节

0x003:多态

向上转型

  • 向上转型,JAVA中的一种调用方式。向上转型是对A的对象的方法的扩充,即A的对象可访问B从A中继承来的和B“重写”A的方法。
    public class Animal {
         public String name;
         public int age;
         public Animal(String name, int  age) {
             this.age = age;
             this.name = name;
         }
         public void eat() {
             System.out.println(this.name + "在吃东西");
         }
         public void sleep() {
             System.out.println(this.name + "在睡觉");
             }
    }
    class Pig extends Animal{
         public Pig(String name, int age){
             super(name, age);
         }
         void funcPig(){
         }
         public void eat(){
             System.out.println(this.name + "吃桃子");
         }
         void func(){
             System.out.println(super.age);
             this.eat();    //调用自己的eat()方法
             super.eat();   //调用父类的eat()方法
             this.funcPig();
         }
    }
    

class Test{
public static void main(String[] args) {
/* 正常使用 /
Animal animal1 = new Animal(“gougou”,12);
animal1.eat();
Pig pig = new Pig(“zhuzhu”,8);
pig.eat();
/
向上转型 */
Animal animal =new Pig(“bajie”,78);
animal.eat();
}
}

/*
执行结果:
gougou在吃东西
zhuzhu在吃桃子
bajie在吃桃子
*/

```

动态绑定

  • 在Java中调用某个类的方法,究竟执行了哪段代码(是父类方法的代码还是子类方法的代码), 要看究竟这个引用指向的是父类对象还是子类对象。这个过程是程序运行时决定的(而不是编译期), 因此称为动态绑定,上面的Animal animal = new Pig("bajie", 78);animal.eat();就发生了动态绑定
  • 构造方法也可以发生动态绑定(也叫运行时绑定)
  • 动态绑定的条件:
    • 一定有向上转型
    • 子类重写了父类的方法,发生了方法的重写
    • 通过父类的引用来调用被重写的方法

多态注意事项

  • 多态存在的三个必要条件:
    • 继承
    • 重写
    • 父类引用指向子类对象
  • 多态的实现方式:
    • 方式一:重写
    • 方式二:接口
    • 方式三:抽象类和抽象方法

文章作者:Torres-圣君
文章链接:http://www.cjlblog.vip/posts/b1b44365.html
版权声明:本博客所有文章除特別声明外,均采用 CC BY 4.0 许可协议。转载请注明来源 Torres-圣君


  转载请注明: Torres-圣君 Java继承封装多态

评论
  目录