一、封装

  1. 封装的概述
    封装是面向对象三大特征之一（封装，继承，多态）
    封装是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的
  2. 封装原则
    将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问
    成员变量private，提供对应的getXxx()/setXxx()方法
  3. 封装好处
    通过方法来控制成员变量的操作，提高了代码的安全性
    把代码用方法进行封装，提高了代码的复用性
  4. 代码如下：
/*
    学生类
 */
class Student {
    //成员变量
    private String name;
    private int age;

    //get/set方法
    public void setName(String n) {
        name = n;
    }

    public String getName() {
        return name;
    }

    public void setAge(int a) {
        age = a;
    }

    public int getAge() {
        return age;
    }

    public void show() {
        System.out.println(name + "," + age);
    }
}

二、继承

1. 继承的实现

  • 继承的概念
  • 继承是面向对象三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，以及追加属性和方法
  • 实现继承的格式
  • 继承通过extends实现
  • 格式：class 子类 extends 父类 { }
  • 举例：class Dog extends Animal { }
  • 继承带来的好处
  • 继承可以让类与类之间产生关系，子父类关系，产生子父类后，子类则可以使用父类中非私有的成员。
  • 代码如下：
public class Fu {
    public void show() {
        System.out.println("show方法被调用");
    }
}
public class Zi extends Fu {
    public void method() {
        System.out.println("method方法被调用");
    }
}
public class Demo {
    public static void main(String[] args) {
        //创建对象，调用方法
        Fu f = new Fu();
        f.show();

        Zi z = new Zi();
        z.method();
        z.show();
    }
}

2.继承的好处和弊端

  • 继承好处
  • 提高了代码的复用性(多个类相同的成员可以放到同一个类中)
  • 提高了代码的维护性(如果方法的代码需要修改，修改一处即可)
  • 继承弊端
  • 继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性
  • 继承的应用场景：
  • 使用继承，需要考虑类与类之间是否存在is…a的关系，不能盲目使用继承
  • is…a的关系：谁是谁的一种，例如：老师和学生是人的一种，那人就是父类，学生和老师就是子类

3. Java中继承的特点

  • Java中继承的特点
  1. Java中类只支持单继承，不支持多继承
  • 错误范例：class A extends B, C { }
  1. Java中类支持多层继承

三、多态

1.多态的概述

  • 什么是多态
    同一个对象，在不同时刻表现出来的不同形态
  • 多态的前提
  • 要有继承或实现关系
  • 要有方法的重写
  • 要有父类引用指向子类对象
  • 代码如下：
class Animal {
    public void eat(){
        System.out.println("动物吃饭");
    }
}
class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
public class Test1Polymorphic {
    /*
        多态的前提:
            1. 要有(继承 \ 实现)关系
            2. 要有方法重写
            3. 要有父类引用, 指向子类对象
     */
    public static void main(String[] args) {
        // 当前事物, 是一只猫
        Cat c = new Cat();
        // 当前事物, 是一只动物
        Animal a = new Cat();
        a.eat();
    }
}

2.多态中的成员访问特点

  • 成员访问特点
  • 成员变量
    编译看父类，运行看父类
  • 成员方法
    编译看父类，运行看子类
  • 代码如下：
class Fu {
    int num = 10;

    public void method(){
        System.out.println("Fu.. method");
    }
}

class Zi extends Fu {
    int num = 20;
    public void method(){
        System.out.println("Zi.. method");
    }
}

public class Test2Polymorpic {
    /*
         多态的成员访问特点:
                成员变量: 编译看左边 (父类), 运行看左边 (父类)
                成员方法: 编译看左边 (父类), 运行看右边 (子类)
     */
    public static void main(String[] args) {
        Fu f = new Zi();
        System.out.println(f.num);
        f.method();
    }
}

3.多态的好处和弊端（记忆）

  • 好处
    提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作
  • 弊端
    不能使用子类的特有成员

4.多态中的转型（应用）

  • 向上转型
    父类引用指向子类对象就是向上转型
  • 向下转型
    格式：子类型 对象名 = (子类型)父类引用;
  • 代码演示
class Fu {
    public void show(){
        System.out.println("Fu..show...");
    }
}

class Zi extends Fu {
    @Override
    public void show() {
        System.out.println("Zi..show...");
    }

    public void method(){
        System.out.println("我是子类特有的方法, method");
    }
}

public class Test3Polymorpic {
    public static void main(String[] args) {
        // 1. 向上转型 : 父类引用指向子类对象
        Fu f = new Zi();
        f.show();
        // 多态的弊端: 不能调用子类特有的成员
        // 1: 直接创建子类对象
        // 2. 向下转型 : 从父类类型, 转换回子类类型
        Zi z = (Zi) f;
        z.method();
    }
}