Java面向对象的三大特性

Java面向对象的三大特性

继承

• 关键字：extends

• 概念：继承机制是面向对象程序设计不可缺少的关键概念，是实现软件可重用的根基，是调高软件系统的可扩展性与可维护性的主要途径。所谓继承是指一个类的定义可以基于另外一个已经存在的类，即子类基于父类，从而实现父类代码的重用，子类能吸收已有类的数据属性和行为，并能扩展新的能力。

• 在Java中，类的继承是单继承。

• 继承中构造方法的调用

  • 子类构造方法总是先调用父类构造方法
  • 默认情况下，调用父类无参构造方法
  • 可以在子类构造方法的第一行，使用super关键字调用父类任意一个构造方法

• **子类实例化调用父类构造方法原因：**Java语言中，要求子类有责任保证它所继承的父类尽快进入到一个稳定、完整的状态中。如果没有这个约束，那么子类的某个继承自父类的方法可能会使用到父类中的一些变量，而这些变量并没有进行初始化，从而产生一些难以预料的后果。

• 代码重写：

  public class Father{
  public void eat(){
    System.out.pringln("爸爸吃饭！");
  } 
  } 
  public class Sun extends Father{
  public void eat(){
    System.out.pringln("儿子吃饭！");
  } 
  }

• this关键字的作用：

  • 使用this关键字引用成员变量。
  • 使用this关键字在自身构造方法内部引用其它构造方法。
  • 使用this关键字代表自身类的对象。
  • 使用this关键字引用成员方法。
  • **注意：**this关键字必须放在非静态方法里面。

• this引用成员变量：

  在一个类的方法或构造方法内部，可以使用“this.成员变量名”这样的格式来引用成员变量名，常常用来区分同名的成员变量和局部变量。

  public class ReferenceVariable {
  private int a;
  
  public ReferenceVariable(int a){
      this.a = a;
  }
  
  public int getA(){
      return a;
  }
  
  public void setA(int a){
      this.a = a;
  }
  }

• this引用成员变量：

  在一个类的构造方法内部，也可以使用this关键字引用其它的构造方法，这样可以降低代码的重复，也可以使所有的构造方法保持统一，这样方便以后的代码修改和维护，也方便代码的阅读。

  public class ReferenceConstructor {
  int a;
  
  public ReferenceConstructor(){
      this(0);
  }
  
  public ReferenceConstructor(int a){
      this.a = a;
  }
  }

• this引用成员方法

  在一个类的内部，成员方法之间的互相调用时也可以使用“this.方法名(参数)”来进行引用。

  public class ReferenceObject {
  ReferenceObject instance;
  
  public void hello(){                System.out.println("helloWorld");
  }
  public void sayHello(){
       this.hello();
  }
  }

• this代表自身对象：

  在一个类的内部，也可以使用this代表自身类的对象，或者换句话说，每个类内部都有一个隐含的成员变量，该成员变量的类型是该类的类型，该成员变量的名称是this

  public class ReferenceObject {
  ReferenceObject instance;
  
  public ReferenceObject(){
      instance = this;
  }
  
  public void test(){
      System.out.println(this);
  }
  }

• **super关键字：**super通常指代父类对象

• 在子类构造方法中要调用父类的构造方法，需要注意：super语句只能出现在子类构造方法体的第一行。

  class Base {
  Base() {
      System.out.println("Base");
  }
  }
  
  public class Checket extends Base {
  Checket() {
      super();
      System.out.println("Checket");
  }
  public static void main(String argv[]) {
      Checket c = new Checket();
  }
  }
  

• 当子类方法体中的局部变量或者子类的成员变量与父类成员变量同名时，即子类局部变量覆盖父类成员变量时，用“super.成员变量名”来引用父类成员变量

• 当子类的成员方法覆盖了父类的成员方法时，也就是子类和父类有完全相同的方法定义（方法体可以不同），此时，用“super.方法名（参数列表）”的方式访问父类的方法。

  封装

  概念：封装就是把对象的属性和操作（或服务）结合为一个独立的整体，并尽可能隐藏对象的内部实现细节。封装是一种信息隐藏技术，在Java中通过关键字private，protected和public实现封装。封装把对象的所有组成部分组合在一起，封装定义程序如何引用对象的数据，封装实际上使用方法将类的数据隐藏起来，控制用户对类的修改和访问数据的程度。 适当的封装可以让程式码更容易理解和维护，也加强了程式码的安全性。

  public class Man{
  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;
  　　}
  }

多态

含义：对外一种表现形式，内在有多种具体实现。

具体体现：

• 方法重载

• 方法覆盖

• 多态参数

  运行期类型和编译期类型

  A  a = new A();
  a.show();

  声明A的时候，使用到的类型A表示对象的类型，被称为编译期类型。

  在编译期，虚拟机认为a的类型是A，对于a所使用的属性和方法的有效性将到类A中去验 证。

  构造方法A()中的A是运行期类型。

  在运行期，将执行运行期类型中的方法

  父类引用指向子类对象

  class  Animal{
               …… 
  }
  class Cat  extends Animal{
               ……
  }
  Animal x = new Cat()
  

  多态环境下对成员方法的调用

  class  Animal{
           void show() {
             System.out.println(“Anmial");
          }
  }
  class Cat  extends Animal{
              void show() {
                    System.out.println(“cat");
              }
  }
  Animal x = new Cat() 
   x.show()//调用的是子类中的方法

  多态环境下对静态方法的调用

  class  Animal{
          static  void show() {
             System.out.println(“Animal");
          }
  }
  class Cat extends Animal {
             static  void show() {
                    System.out.println(“Cat");
              }
  }
  Animal x = new Cat() 
   x.show() //调用的是动物类中的静态成员方法。

  多态环境下对成员变量的调用

  class Animal{
       int num = 3;
  }
  class Cat  extends Animal {
       int  num = 4;
  }
  Animal x = new Cat() 
   x.num; //调用的是动物类中的成员变量。

  多态环境下对象造型

  当存在多态环境时，有时候需要类型转换。这里将涉及到一个概念叫
  强制类型转换，但是记住，强制是有前提的，只能强制转换成这个对象的运行期类型

  Animal animal=new Cat();
  Cat cat=(Cat)animal;

  instanceof运算符

  多态环境下的对象有两种类型，其中运行期类型往往在运行时才能确定。

  有时候需要根据运行期类型的不同，进行不同处理，这时候就需要使用instanceof操作符 来 判断一个对象的运行期类型。