自学JAVA知识点总结 - 初级

150 0

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

继承（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（"喵喵喵！"）;
  }
}