Javase之——面向对象编程的三大特性（封装、继承、多态）

public class Encapsulation {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("xinian");//调用set方法设置name属性的值
        person.setAge(23);//调用set方法设置age属性的值
        System.out.println("我的姓名是：" + person.getName() + "\n我的年龄是：" + person.getAge());
    }
}


class Person {
    private String name;//将name属性私有化
    private int age;//将age属性私有化

    public String getName() {
        return name;
    }//提供公共的get方法,用于获取name属性的值

    /**
     * 注：可以用Alt+Insert快捷键生成set方法和get方法
     */

    public void setName(String name) {
        this.name = name;
    }//提供公共的set方法,用于设置name属性的值

    public int getAge() {
        return age;
    }//提供公共的get方法,用于获取age属性的值

    public void setAge(int age) {
        this.age = age;
    }//提供公共的set方法,用于设置age属性的值
}

运行结果

二、继承

介绍

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

例如：

作用

继承可以提高代码复用性，使得编程更接近人类思维。

基本语法

class 父类 {

}

class 子类 extends 父类 {

}

演示案例

public class People {
    public String name;//父类name属性
    public int age;//父类age属性

    public void info(){
        System.out.println("My name is " + name + " and I am " + age + " years old");
    }//父类info方法

    public void eat(){
        System.out.println("I can eat");
    }//父类eat方法
}

class Student extends People{

    public void add(int m,int n) {
        int p = m + n;
        System.out.println("加法结果为： "+p);
    }//子类Student的add方法
}
class UniversityStudent extends Student{
    public void sub(int a,int b){
        int c = a - b;
        System.out.println("减法结果为："+c);
    }//子类UniverStudent的sub方法
}

class test {
    public static void main(String[] args) {
        UniversityStudent universityStudent = new UniversityStudent();
        universityStudent.name = "xinian";//调用父类People的name属性
        universityStudent.age = 20;//调用父类People的age属性
        universityStudent.add(5,6);//调用父类Student的add方法
        universityStudent.sub(5,6);//调用自己的sub方法
        universityStudent.info();//调用父类People的info方法
        universityStudent.eat();//调用父类People的eat方法
    }
}

该案例中，People是父类，Student是People的子类，UniversityStudent是Student的子类，等同于UniversityStudent也是People的子类，这样是可行的，即多重继承。但如果Student不是People的子类，就会出现错误，因为Java中不可以有多继承。

运行结果

细节

1、子类继承了所有的属性和方法，但是私有属性和私有方法不能在子类中直接访问，应通过公共方法去访问。

2、子类必须调用父类的构造器，完成父类的初始化。

3、创建子类对象时，不管子类使用哪个构造器，默认调用父类的无参构造器，若父类未提供无参构造器，则必须用super关键字来指定调用父类的构造器完成对父类的初始化工作。（以下为讲解说明）

注：super关键字在使用时必须放在构造器的第一行

默认调用父类的无参构造器：

package com.xinian.Extends;

public class Base {
    public Base() {
        System.out.println("父类的Base()构造器被调用");
    }// 父类的无参构造器
    public Base(String name, int age){
        System.out.println("父类的Base(String name, int age)构造器被调用");
    }// 父类的有参构造器
}

class Sub extends Base{
    public Sub(){
        System.out.println("子类的Sub()构造器被调用");
    }//子类的无参构造器
    public Sub(String name){
//        super("父亲", 30); // 指定父类的有参构造器
        System.out.println("子类的Sub(String name)构造器被调用");
    }// 子类的有参构造器
}


class Main {
    public static void main(String[] args) {
        Sub sub = new Sub();// 调用子类的无参构造器
        System.out.println("==============");
        Sub sub1 = new Sub("小明");// 调用子类的有参构造器

    }
}

父类未提供无参构造器且子类未指定调用父类的构造器：

package com.xinian.Extends;

public class Base {
//    public Base() {
//        System.out.println("父类的Base()构造器被调用");
//    }// 父类的无参构造器
    public Base(String name, int age){
        System.out.println("父类的Base(String name, int age)构造器被调用");
    }// 父类的有参构造器
}

class Sub extends Base{
    public Sub(){
        System.out.println("子类的Sub()构造器被调用");
    }//子类的无参构造器
    public Sub(String name){
//        super("父亲", 30); // 指定父类的有参构造器
        System.out.println("子类的Sub(String name)构造器被调用");
    }// 子类的有参构造器
}


class Main {
    public static void main(String[] args) {
        Sub sub = new Sub();// 调用子类的无参构造器
        System.out.println("==============");
        Sub sub1 = new Sub("小明");// 调用子类的有参构造器

    }
}

编译报错。

父类未提供无参构造器，子类必须使用super关键字来指定调用父类的构造器：

package com.xinian.Extends;

public class Base {
//    public Base() {
//        System.out.println("父类的Base()构造器被调用");
//    }// 父类的无参构造器
    public Base(String name, int age){
        System.out.println("父类的Base(String name, int age)构造器被调用");
    }// 父类的有参构造器
}

class Sub extends Base{
    public Sub(){
        super("父亲", 30);// super关键字指定父类的有参构造器
        System.out.println("子类的Sub()构造器被调用");
    }//子类的无参构造器
    public Sub(String name){
        super("父亲", 30); // super关键字指定父类的有参构造器
        System.out.println("子类的Sub(String name)构造器被调用");
    }// 子类的有参构造器
}


class Main {
    public static void main(String[] args) {
        Sub sub = new Sub();// 调用子类的无参构造器
        System.out.println("==============");
        Sub sub1 = new Sub("小明");// 调用子类的有参构造器

    }
}

三、多态

介绍

多态是同一个行为具有多个不同表现形式或形态的能力。是面向对象的第三大特征，建立在封装和继承的基础之上。

作用

可以使程序有良好的扩展，并可以对所有类的对象进行通用处理，提高代码复用性。

具体体现：

1、方法的多态

演示案例

package com.xinian.PloyMethod;

public class A {
    public void say() {
        System.out.println("A say");
    }
}
class B extends A {
    public int sum(int a, int b) {
        return a + b;
    }
    public int sum(int a, int b, int c) {
        return a + b + c;
    }// 重载sum()方法
    @Override
    public void say() {
        System.out.println("B say");
    }//重写父类say()方法
}

class Test{
    public static void main(String[] args) {
        B b = new B();
        System.out.println(b.sum(1, 2));
        System.out.println(b.sum(1, 2, 3));//体现方法的多态
        A a = new A();
        a.say();
        b.say();//体现方法的多态
    }
}

运行结果：

2、对象的多态

演示案例

package com.xinian.PloyMethod;

public class Animal {
    public void eat(){
        System.out.println("动物在吃...");
    }//父类eat()方法
}
class Dog extends Animal {
    public void eat() {
        System.out.println("小狗在吃骨头...");
    }//重写父类的eat()方法
}
class Cat extends Animal {
    public void eat() {
        System.out.println("小猫在吃鱼...");
    }//重写父类的eat()方法
}
class Main{
    public static void main(String[] args) {
        Animal animal = new Dog();//创建Dog对象
        animal.eat();//调用Dog类的eat()方法
        System.out.println("==========");
        animal = new Cat();//修改了animal的指向，将其实例化为一个Cat对象
        animal.eat();//调用Cat类的eat()方法
    }
}