Java面向对象程序设计（高级篇）

一：封装

1.封装概述

概述
面向对象编程语言是对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。 封装可以被认为是一个保护屏障，防止该类的代码和数据被其他类随意访问。要访问该类的数据，必须通过指定的 方式。适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。
原则
将属性隐藏起来，若需要访问某个属性，提供公共方法对其访问。

2.封装的步骤

1. 使用 private 关键字来修饰成员变量。
2. 对需要访问的成员变量，提供对应的一对 getXxx 方法 、 setXxx 方法。

3.封装的操作——private关键字

private的含义

1. private是一个权限修饰符，代表最小权限。
2. 可以修饰成员变量和成员方法。
3. 被private修饰后的成员变量和成员方法，只在本类中才能访问。

private的使用格式

private 数据类型 变量名 ；

1. 使用 private 修饰成员变量，代码如下：

public class Student { 
   private String name; 
   private int age; 
}

2. 提供 getXxx 方法 / setXxx 方法，可以访问成员变量，代码如下：

public class Student { 
   private String name; 
   private int age; 
   public void setName(String n) { 
       name = n; 
   }
   public String getName() { 
       return name; 
   }
   public void setAge(int a) { 
       age = a; 
   }
   public int getAge() { 
       return age; 
   } 
}

4.封装优化1——this关键字

this的含义
this代表所在类的当前对象的引用（地址值），即对象自己的引用。 记住 ：方法被哪个对象调用，方法中的this就代表那个对象。即谁在调用，this就代表谁。

this使用格式

this.成员变量名；

使用 this 修饰方法中的变量，解决成员变量被隐藏的问题，代码如下：

public class Student { 
    private String name; 
    private int age; 
    public void setName(String name) { 
       //name = name; 
       this.name = name; 
    }
    public String getName() { 
       return name; 
    }
    public void setAge(int age) { 
       //age = age; 
       this.age = age; 
    }
    public int getAge() { 
        return age;
    } 
}

5.封装优化2——构造方法

当一个对象被创建时候，构造方法用来初始化该对象，给对象的成员变量赋初始值。
小贴士：无论你与否自定义构造方法，所有的类都有构造方法，因为Java自动提供了一个无参数构造方法， 一旦自己定义了构造方法，Java自动提供的默认无参数构造方法就会失效。

构造方法的定义格式

修饰符 构造方法名(参数列表){ 
    // 方法体 
}

构造方法的写法上，方法名与它所在的类名相同。它没有返回值，所以不需要返回值类型，甚至不需要void。使用 构造方法后，代码如下：

public class Student { 
    private String name; 
    private int age; 
    // 无参数构造方法 
    public Student() {} 
    // 有参数构造方法 
    public Student(String name,int age) { 
         this.name = name; 
         this.age = age; 
    }
}

注意事项

1. 如果你不提供构造方法，系统会给出无参数构造方法。
2. 如果你提供了构造方法，系统将不再提供无参数构造方法。
3. 构造方法是可以重载的，既可以定义参数，也可以不定义参数。

二：继承

1.概述

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要 继承那一个类即可。其中，多个类可以称为子类，单独那一个类称为父类。

2.定义

继承：就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接 访问父类中的非私有的属性和行为。

3.继承的格式

通过 extends 关键字，可以声明一个子类继承另外一个父类。

继承演示，代码如下：

/*
 * 定义员工类Employee，做为父类
 */ 
 class Employee { 
    String name; // 定义name属性 
    // 定义员工的工作方法 
    public void work() { 
       System.out.println("尽心尽力地工作"); 
    } 
  }
  
/*
 * 定义讲师类Teacher继承员工类Employee 
 */ 
 class Teacher extends Employee { 
    // 定义一个打印name的方法 
    public void printName() {   
       System.out.println("name=" + name); 
    } }
    
/*
 * 定义测试类 
 */ 
 public class ExtendDemo01 { 
      public static void main(String[] args) { 
      // 创建一个讲师类对象 
      Teacher t = new Teacher(); 
      // 为该员工类的name属性进行赋值 
      t.name = "小明"; 
      // 调用该员工的printName()方法 
      t.printName();  // name = 小明 
      // 调用Teacher类继承来的work()方法 
      t.work(); // 尽心尽力地工作 
      }
 }

4.继承后的特点——成员变量

成员变量不重名
如果子类父类中出现不重名的成员变量，这时的访问是没有影响的。

成员变量重名
子父类中出现了同名的成员变量时，在子类中需要访问父类中非私有成员变量时，需要使用 super 关键字，修饰 父类成员变量，类似于之前学过的 this 。

使用格式：

super.父类成员变量名

子类方法需要修改，代码如下：

class Fu { 
   // Fu中的成员变量。 
   int num = 5; 
}
class Zi extends Fu { 
   // Zi中的成员变量 
   int num = 6; 
   public void show() { 
     //访问父类中的num 
     System.out.println("Fu num=" + super.num); 
     //访问子的num 
     System.out.println("Zi num=" + this.num); 
   } 
}

演示结果： 
Fu num = 5 
Zi num = 6

5.继承后的特点——成员方法

成员方法不重名
如果子类父类中出现不重名的成员方法，这时的调用是没有影响的。对象调用方法时，会先在子类中查找有没有对 应的方法，若子类中存在就会执行子类中的方法，若子类中不存在就会执行父类中相应的方法。
成员方法重名——重写(Override)
如果子类父类中出现重名的成员方法，这时的访问是一种特殊情况，叫做方法重写 (Override)。

方法重写 ：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效 果，也称为重写或者复写。声明不变，重新实现。

代码如下：

class Fu { 
   public void show() {    
      System.out.println("Fu show"); 
   } 
}
class Zi extends Fu { 
   //子类重写了父类的show方法 
   public void show() { 
      System.out.println("Zi show"); 
   } 
}
public class ExtendsDemo05{ 
   public static void main(String[] args) {  
        Zi z = new Zi(); 
        // 子类中有show方法，只执行重写后的show方法 
        z.show(); // Zi show 
   } 
}

6.继承后的特点——构造方法

1. 构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的。
2. 构造方法的作用是初始化成员变量的。所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构造方法中默认有一个 super() ，表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用。

代码如下：

class Fu { 
  private int n; 
  Fu(){ 
    System.out.println("Fu()"); 
  } 
}

class Zi extends Fu { 
   Zi(){ 
     // super（），调用父类构造方法 
     super(); 
     System.out.println("Zi（）"); 
   } 
}

public class ExtendsDemo07 { 
   public static void main (String args[]){ 
      Zi zi = new Zi(); 
   } 
}

输出结果： 
Fu（） 
Zi（）

7.继承的特点

1. Java只支持单继承，不支持多继承。

//一个类只能有一个父类，不可以有多个父类。
 class C extends A{} //ok 
 class C extends A，B... //error

2. Java支持多层继承(继承体系)。

class A{} 
class B extends A{} 
class C extends B{}

顶层父类是Object类。所有的类默认继承Object，作为父类。

3. 子类和父类是一种相对的概念。

三：多态

1.定义

多态是继封装、继承之后，面向对象的第三大特性。
多态： 是指同一行为，具有多个不同表现形式。

2.多态的体现

（1）方法的重载（overload）
（2）方法的重写（override）

3.静态多态性（编译时多态）

体现在方法的重载

方法重载是指在一个类中定义多个同名的方法，但要求每个方法具有不同的参数的类型或参数的个数。

public class Person {
   private String name;
   private int age;
   public void initInfo(String n,int a) {
       name = n;
       age = a;
   }
   
   public void initInfo(String n) {  //同名方法
       name = n;
   }
   
   public void showInfo(String n) {  
       System.out.println("尊敬的"+name+",您的年龄为："+age); 
   }

4.动态多态性（运行时多态）

体现在方法的重写

5.多态实现的条件

（1）继承
（2）方法的重写
（3）向上转型

向上转型：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。 当父类引用指向一个子类对象时，便是向上转型。

使用格式：

父类类型 变量名 = new 子类类型(); 
如：Animal a = new Cat();