面向对象 - 继承、封装、多态、转型

返回目录

继承（Extends）

    • 面向对象继承：子类继承父类，子类是父类的扩展，例如你的财产、经验、知识可以继承给你的孩子；但不是所有类都可以继承，例如很私密的东西，就不能继承给你的孩子。继承实现了代码重用，不用再敲重复的代码了。 
      public class Test {
  public static void main(String[] args) {
    // 由于Student继承了Person，只需创建Student对象就可以直接使用Person中的变量、方法
    Student stu = new Student();
    stu.name = "黄泽风";
    stu.age = 21;
    stu.rest();
    
    Student stu2 = new Student("黄泽雨",18,"山东南翔开挖掘机");
    
    System.out.println(stu.name + "\t" + stu.age);
    System.out.println(stu2.name + "\t" + stu2.age + "\t" + stu2.major);
  }
}
 
class Person{
  String name;
  int age;
  public void rest() {
    System.out.println("休息一会！");
  }
}
 
// 继承Person类
class Student extends Person {
  String major;
  public void study() {
    System.out.println("学习2小时！");
  }
  // 构造器，可直接调用父类的变量
  public Student(String name, int age, String major) {
    this.name = name;
    this.age = age;
    this.major = major;
  }
  // 手动修改构造器后，IDE软件将不会自动添加空构造器
  public Student() {}
}
      • 父类也称作超类、基类、派生类等。
      • Java中只有单继承，没有像C++那样的多继承。多继承会引起混乱，使得继承链过于复杂，系统难于维护。
      • Java中类没有多继承，接口有多继承。
      • 子类继承父类，可以得到父类的全部属性和方法（除了父类的构造方法），但不见得可以直接访问（比如，父类私有的属性和方法）。
      • 如果定义一个类时，没有调用extends，则它的父类是：java.lang.Object。
        在Eclipse中选中类按Ctrl+T可查看类的继承关系

 

封装（Encapsulation）

    • 封装的作用：做一个产品要追求“高内聚，低耦合”，高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合是仅暴露少量的方法给外部使用，尽量方便外部调用。封装可以提高代码安全性、复用性、可维护型、使用者便捷性。利用修饰符public(公共)、default(缺省)、protected(保护)、private(私有)来控制访问权限。 
      package me.hzyis.test;
 
public class Test {
  public static void main(String[] args) {
      Info i = new Info();
      i.setAge(-10);
      i.setName("黄泽雨");
      i.setFalg(true);
      System.out.println(i);
  }
}
class Info{
  private int age;
  private String name;
  private boolean falg;
  
  // 使用get或set方法代替直接修改私有变量
  // age的get和set方法
  public int getAge() {
    return age;
  }
  public void setAge(int age) {
    // 判断age是否合法
    if(age<0 || age>130) {
      this.age = 0; //不合法默认0
    }else {
      this.age = age; //合法才能赋值给属性age
    }
  }
  // name的get和set方法
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  // flag的is和set方法，boolean值的不是get是is
  public boolean isFalg() {
    return falg;
  }
  public void setFalg(boolean falg) {
    this.falg = falg;
  }
  @Override
  public String toString() {
    return "Person [name=" + name + ", age=" + age + "]";
  }
}

多态（Polymorphism）

    • java包：多态指的是同一个方法调用，由于对象不同可能会有不同的行为；多态与属性无关，指的是方法的多态；多态存在有3个必要条件：继承，方法重写，父类引用指向子类对象；父类引用指向子类对象后，用该父类引用调用子类重写的方法，此时多态就出现了。 
      package me.hzyis.test;

public class Test {
  public static void main(String[] args) {
    Animal a = new Animal();
    animalCry(a);
    
    Dog d = new Dog();
    //多态，可避免过多重载方法
    animalCry(d); //子类对象给父类引用，也就是父类引用 指向 子类对象
    animalCry(new Cat());
  }
  static void animalCry(Animal a) { //传入Animal类的实例a
    a.shout(); //Animal类的实例a的方法shout
  }
}
class Animal {
  public void shout() {
    System.out.println("叫了一声！");
  }
}
class Dog extends Animal { //继承
  // 重写
  public void shout() {
    System.out.println("旺旺旺！");
  }
}
class Cat extends Animal {
  public void shout() {
    System.out.println("喵喵喵！");
  }
}

 

对象转型（Casting）

    • 对象转型：父类引用指向子类对象，我们称这个过程为向上转型，属于自动类型转换；向上转型后的父类引用变量只能调用它编译类型的方法，不能调用它运行时类型的方法，这时我们就需要进行类型的强制转换，我们称之为向下转型！ 
      package me.hzyis.test;

public class Test {
  public static void main(String[] args) {
    Animal a = new Animal();
    animalCry(a);
    
    Dog d = new Dog(); //自动向上转型
    animalCry(d);
    animalCry(new Cat());
    
    Dog d2 = (Dog)d; //强制向下转型
    d2.seeDoor();
  }
  static void animalCry(Animal a) {
    a.shout();
  }
}
class Animal {
  public void shout() {
    System.out.println("叫了一声！");
  }
}
class Dog extends Animal {
  public void shout() {
    System.out.println("旺旺旺！");
  }
  public void seeDoor() {
    System.out.println("看门！！！");
  }
}
class Cat extends Animal {
  public void shout() {
    System.out.println("喵喵喵！");
  }
}