了解Java三大特征，让你学习不再痛哭失声

Java面向对象编程作为一种编程思想，有三大特性，封装，继承，多态。对于一个类而言， 如何封装 呢？继承是父类和子类的关系， 继承关系如何实现的呢？父类和子类继承时的方法体是怎么样的关系呢？多态是多个类之间的关系，类有不同的行为和属性，其他类也有这样的方法和属性，就实现了多态的关系，不同类的多态实现是怎么样实现的呢？
————————————————

在了解面对对象三大特征之前，让我们先来了解一下什么是类和对象：
类：是抽象的概念集合，表示的是一个共性的产物，类之中定义的是属性和行为（方法）；
对象：对象是一种个性的表示，表示一个独立的个体，每个对象拥有自己独立的属性，依靠属性来区分不同对象。

封装

• 什么是封装：
  也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。
• 封装的目的
  是为了保证变量的安全性，使用者不必在意具体实现细节，而只是通过外部接口即可访问类的成员
• 如何封装
  利用权限修饰符来描述方法体或属性。private修饰的属性或方法为该类所特有，在任何其他类中都不能直接访问；default修饰的属性或方法具有包访问特性，同一个包中的其他类可以访问；protected修饰的属性或方法在同一个中的其他类可以访问，同时对于不在同一个包中的子类中也可以访问；public修饰的属性或方法外部类中都可以直接访问。
• 封装的好处
  1.隐藏类的实现细节；
  2.只能通过规定方法访问数据；
  3.方便加入控制语句；
  4.方便修改实现；
• getter和setter方法
  针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作
  提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰
  提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰

代码示例:

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

    public void show() {
        System.out.println("姓名："+name+" 年龄："+age);
    }
}
public class Test {
    public static void main(String[] args) {
        People people = new People();
        people.setName("小明");
        people.setAge(18);
        people.show();
    }
}

了解成员变量和局部变量。
成员变量：类中方法外的变量
局部变量：方法中的变量

成员变量与局部变量的区别:

继承

• 什么是继承
  Java中的继承是指在一个现有类（父类）的基础上在构建一个新类（子类），子类可以拥有父类的成员变量以及成员方法（但是不一定能访问或调用，例如父类中private私有的成员变量以及方法不能访问和调用）。

继承可以使得子类具有父类的属性和方法，还可以在子类中重新定义，追加属性和方法。

• 格式
  格式：public class 子类名 extends 父类名( )
• 继承的好处和弊端
  好处:
  提高了代码的复用性（多个类相同的成员可以放到同一个类种）
  提高了代码的维护性（如果方法的代码需要修改，修改一处即可）
  弊端：
  继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性
• 什么时候使用继承
  继承体现的关系：is a
  假设法：我们有两个类A和B，如果他们满足A是B的一种，或者B是A的一种，就说明他们存在继承关系，这个时候就可以考虑使用继承来体现，否则就不能滥用继承
  举例：苹果和水果，猫和动物，猫和狗
• super
  子类如果说需要直接访问父类的变量和方法时,需要用到super
  
  注意：每一个子类构造方法的第一条默认都是 super（）
• 成员访问特点
  就近原则:
  通过子类对象访问一个方法，先在子类成员范围找，再到父类成员范围找.
  子类访问一个变量，先在子类局部变量中寻找，然后再子类成员变量，然后再父类成员变量.
  
• 继承注意事项:
  Java中类只支持单继承，不支持多继承
  Java中类支持多层继承
• 方法重写：
  子类中出现了和父类中一模一样的方法声明，叫做方法重写
  
  注意：私有方法不能被重写，子类方法访问权限不能更低

@Override,是一个注解，帮助我们检查重写方法的方法声明的正确性

• object
  基类——所有类最大的父类,何一个类时候如果没有明确的继承一个父类的话，那么它就是Object的子类.
  object，有很多的方法，常用的有toString，equals
  我们还可以通过方法重写来实现更多具体要求

继承代码示例:

public class Fu {
    public void show() {
        System.out.println("父类中的show方法被调用");
    }
    public void method() {
        System.out.println("父类中的method方法被调用");
    }
}
public class Zi extends Fu {
    @override
    public void method() {
        System.out.println("子类中的method方法被调用");
    }
}
public class Demo {
    public static void main(String[] args) {
        //创建对象，调用方法
        Fu f = new Fu();
        f.show(); // 父类中的show方法被调用

        Zi z = new Zi();
        z.method(); // 子类中的show方法被调用
        z.show(); // 父类中的show方法被调用
    }
}

多态

• 什么是多态
  多态指的是同一个对象可以表现出多种形态，通俗来说就是一个对象的引用类型既可以是实际类也可以是实际类的父类。

多态具有通用性

• 多态的前提和体现
  有继承或实现关系
  有方法重写
  有父类引用指向子类对象

举例:
创建对象:
Animal a = new Cat();

• 成员访问特点
  成员变量：编译看左边，执行看左边
  成员方法：编译看左边，执行看右边

• 多态的好处与弊端
  多态好处：
  提高了程序的拓展性
  体现在定义方法的时候以父类作为参数，使用时，使用具体的子类型参与操作
  多态弊端：
  不能使用子类特有的功能

• 多态中的转型:
  向上转型：
  从子类到父类，父类引用指向子类对象
  父类Animal和一个子类Dog来说明，当父类的引用可以指向子类的对象时，就是向上类型转换。如：

Dog dog = new Dog();
Animal animal = dog;//自动类型提升 向上类型转换

向下转型：
从父类到子类，父类引用转为子类对象
父类Animal和一个子类Dog来说明，当父类的引用可以转为子类的对象时，就是向上类型转换。如：

Dog dog = new Dog();
Animal animal = dog;//自动类型提升 向上类型转换
Dog dog2 = (Dog)animal;//向下类型转换 强制类型转换

• instanceof运算符
  来解决引用对象的类型，避免类型转换的安全性问题。
  instanceof是Java的一个二元操作符，和==，>，<是同一类。由于它是由字母组成的，所以也是Java的保留关键字。它的作用是测试它左边的对象是否是它右边的类的实例，返回boolean类型的数据。
  举个列子:

if (animal instanceof Cat){
    Cat cat = (Cat)animal;//1. 编译时 Cat类型 2. 运行时Dog类型
}

多态代码示例：

public class Animal {
    public int age = 40;

    public void eat() {
        System.out.println("动物吃东西");
    }
}
public class Cat extends Animal {
    public int age = 20;
    public int weight = 10;

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    public void playGame() {
        System.out.println("猫捉迷藏");
    }
}
public class AnimalDemo {
    public static void main(String[] args) {
        //有父类引用指向子类对象，向上转型
        Animal a = new Cat();
        Cat c = new Cat();

        System.out.println(a.age); // 40
        a.eat; // 猫吃鱼
        // 向下转型
        Cat t = (Cat) a;
		System.out.println(t.age); // 20
        System.out.println(t.weight); // 10

        System.out.println(c.age); // 20
        System.out.println(a.weight); // 10

    }
}