目录

一、封装

1.1 封装的意义

1.2 如何进行封装

二、继承

2.1 继承的意义

2.2 如何继承

2.3 继承的优点

2.4 继承的缺点

三、多态

3.1 多态的定义

3.2 多态的使用要求

---

一、封装

所谓封装就是将对象的属性隐藏起来，不让外界直接访问，而是通过指定的方法来访问对象的属性，就叫封装。Java 中封装是面向对象三大特征之一，它的作用就是让程序的安全性得以提高。

1.1 封装的意义

我们通过下面的示例来说明这个问题。

我们创建一个 Human 类，在这个类中定义两个属性，一个姓名，一个年龄。

class Human {String name;private int age;public void setAge(int newAge) {age = newAge;}public int getAge() {return age;}
}
public class HumanTest {public static void main(String[] args) {Human human = new Human();human.name = "张三";//human.age = -18;human.setAge(18);System.out.println(human.name + " " + human.getAge());}
}

通过上面的示例演示，如果我们不把 age 属性隐藏起来，那么在外部（HumanTest类中的 main 方法中）就可以直接对这个属性进行赋值。这就会产生不确定的因素，如给年龄一个负数或都一个很大的数。这些情况都是不对的。为了避免这种情况的发生，我们需要把这个属性进行隐藏，从而提高程序的健康性。

1.2 如何进行封装

在 Java 中需要使用 private 关键字来修饰要被隐藏的属性。然后提供这个属性对应的两个公共方法：一个用于对这个属性进行赋值，另一个用于对这个属性进行获取值。

class Human {String name;private int age;public void setAge(int newAge) {age = newAge;}public int getAge() {return age;}
}

例如上面代码中的 setAge(int newAge) 和 getAge() 这两个方法都是封装方法。一般来说，给属性赋值的方法取名为 setXXX，而获取属性值的方法取名为 getXXX。其中XXX 表示属性的名称，该名称的首字母大写。

注意：为了安全性，在写实体类中，只要有属性存在都需要进行封装。

二、继承

继承是面向对象程序设计的第二个特征，为了提高代码的复用率，继承应运而生。

2.1 继承的意义

我们通过如下的案例来说明这个问题。

class Woman {public String name;public int age;public void show() {System.out.println(name + " " + age);}
}class Man {public String name;public int age;public void show() {System.out.println(name + " " + age);}
}public class PersonDemo {public static void main(String[] args) {Man man = new Man();man.name="张三";man.age=18;man.show();Woman woman = new Woman();woman.name = "李四";woman.age=19;woman.show();}
}

从上面的代码中可以发现，现个类中除了类名不同以外，其余的代码都是相同的。这样的话代码复用率就不高。为了让代码的复用率更高。我们可以把两个 类中相同的代码提取出来形成一个单独的类，然后让这两个类去继承它即可。

2.2 如何继承

首先我们需要定义一个父类，在这个父类中定义公共的属性或方法。例如上面的示例中我们可以定义一个父类如：Person，然后在这个父类中定义公共的属性和方法。

class Person {public String name;public int age;public void show() {System.out.println(name + " " + age);}
}class Woman extends Person {}class Man extends Person {}public class PersonDemo {public static void main(String[] args) {Man man = new Man();man.name="张三";man.age=18;man.show();Woman woman = new Woman();woman.name = "李四";woman.age=19;woman.show();}
}

子类需要使用 extends 关键字来继承父类。通过这样的操作后，Person类中父类或者叫基类，而Man和 Woman 叫子类或者派生类。

2.3 继承的优点

1. 提高了代码的复用率

2. 它是多态前提条件

2.4 继承的缺点

1. 父类中私有的属性和方法，子类是无法使用的

2. 在java中只支持单继承，不支持多继承，但是可以支持多重继承

3. 继承后子父类的关系就接合得非常的紧密，不利于程序的扩展，从而减少了程序的灵活性。

4. 父类无法访问子类的属性和方法

三、多态

3.1 多态的定义

一个对象在不同条件下表示的不同形态就叫多态，在程序中，多态是父类引用指定子类对象。

// 多态
class Father {String name;public void desc() {System.out.println("----------");System.out.println(name + "小头爸爸");}
}
class Son extends Father {String name;public void desc() {System.out.println("+++++++++++++");System.out.println(name + "大头儿子");}
}public class PolymorphicDemo1 {public static void main(String[] args) {Father father = new Son();father.name = "大头儿子";father.desc();}
}

另一种多态的使用方式是在方法的参数上，一般我们在使用工厂设计模式时会使用多态 。

//
abstract class Animal {abstract void haha();
}
class Cat extends Animal {@Overridevoid haha() {System.out.println("Cat haha()");}
}
class Dog extends Animal {@Overridevoid haha() {System.out.println("Dog haha()");}
}class HelloKit {public static Animal create(Animal animal) {if (animal instanceof Cat) {return new Cat();}else if (animal instanceof Dog) {return new Dog();} else {return null;}}
}
public class HelloKitDemo {public static void main(String[] args) {Cat cat = new Cat();Dog dog = new Dog();Animal animal = HelloKit.create(cat);animal.haha();Animal animal1 = HelloKit.create(dog);animal1.haha();}
}

在参数列表上，使用父类去接收，也是一种多态的使用方式。

3.2 多态的使用要求

1，在多态的情况下，不能使用子类特有的方法

class Person {public int age = 5;public void show() {System.out.println("Person age: " + age);}
}
class Student extends Person {public int age = 10;public String name = "小明";public void show() {System.out.println("Student age: " + age);}public void speak() {System.out.println(name);}
}public class PolymorphicDemo2 {public static void main(String[] args) {Person p = new Student();p.show(); // 可以执行p.speak(); // 报错，因为 speak 方法是子类特有的方法}
}

2，多态在例子中如果属性是非静态的，它的值是看等号左边

// 多态的注意事项
class Person {public int age = 5;public void show() {System.out.println("Person age: " + age);}
}
class Student extends Person {public int age = 10;public String name = "小明";public void show() {System.out.println("Student age: " + age);}public void speak() {System.out.println(name);}
}public class PolymorphicDemo2 {public static void main(String[] args) {Person p = new Student();System.out.println(p.age); // 5 ，是不是 10}
}

原因：我们使用的是多态，也就是说我们输出的 p.age ，而 p 是父为的引用，它获取到的值就是父类中定义的值。

在多态下，编译是看等号的左边，运行时如果是属性则看等号左边。

3，在多态下的非静态方法

// 多态的注意事项
class Person {public int age = 5;public void show() {System.out.println("Person age: " + age);}
}
class Student extends Person {public int age = 10;public String name = "小明";public void show() {System.out.println("Student age: " + age);}
}public class PolymorphicDemo2 {public static void main(String[] args) {Person p = new Student();p.show();}
}

在多态下，编译是看等号的左边，运行时如果方法是非静态的看等号的右边。

4，在多态下的静态成员

// 多态的注意事项
class Person {public static void x() {System.out.println("Person static x");}
}
class Student extends Person {public static void x() {System.out.println("Student static x");}
}
public class PolymorphicDemo2 {public static void main(String[] args) {Person p = new Student();p.x(); // Person static x}
}

在多态下，静态的成员在编译和运行时都看等号的左边。