Java面向对象编程的三大特性：封装、继承、多态。

一、封装

　　封装的核心在于私有化（private），大部分情况下，来封装对象的属性，很少有封装方法的。通过将对象的属性封装，提供对外的公共方法来访问属性是最常见的方式。

public static class FengZhuang{
        // 通过封装，设置私有属性
        private String name;
        private int age;
        //通过提供公共的对外接口，访问私有属性
        public void setName(String name){
            this.name = name;
        }

        public int getAge() {
            return age;
        }
        public void setAge(int age){
            if (age < 10 || age > 110){
                System.out.println("年龄设置不符合要求!!!");
                return;
            }else {
                this.age = age;
            }
        }

public static void main(String[] args) {
        FengZhuang fengZhuang = new FengZhuang();
        fengZhuang.setAge(242);
        fengZhuang.setName("Gao");

        System.out.println(fengZhuang.getAge());
    }

二、继承

　　继承是子类继承父类的方法和属性，私有方法不能被继承，java只能进行单继承，也就是说一个子类只有一个父亲，但是一个父亲可以有多个儿子。

// 定义一个Vehicle类 : 父类
    public  static class Vehicle {
        //	定义属性
        private int wheels;
        private double weight;
        //	有参构造方法
        public Vehicle(int wheels, double weight) {
            super();//继承Object有参构造方法
            this.wheels = wheels;
            this.weight = weight;
        }
        //	无参构造方法
        public Vehicle() {
            super();//继承Object无参构造方法
        }
        //	配合private使用，防止恶意篡改数据
        public int getWheels() {
            return wheels;
        }
        public void setWheels(int wheels) {
            this.wheels = wheels;
        }
        public double getWeight() {
            return weight;
        }
        public void setWeight(double weight) {
            this.weight = weight;
        }
        //	方法show1
        public void show1(){
            System.out.println("车轮个数："+this.wheels);
            System.out.println("车重："+this.weight+"吨");
        }
    }
    // 创建一个Car类:子类
    public static class Car extends Vehicle{//extends Vehicle：声明父类为Vehicle
        private int loader;

        public Car(int wheels, double weight, int loader) {
            super(wheels, weight);//继承Vehicle有参构造方法
            this.loader = loader;
        }

        public Car() {
            super();//继承Vehicle无参构造方法
        }

        public int getLoader() {
            return loader;
        }

        public void setLoader(int loader) {
            this.loader = loader;
        }
        //	方法show2
        public void show2(){
            System.out.println("车载人数为："+this.loader);
        }
    }
    // 创建一个Truck类:子类
    public static class Truck extends Car {//extends Car：声明父类为Car

        private double payload;

        public Truck(int wheels, double weight, int loader, double payload) {
            super(wheels, weight, loader);//继承Car有参构造方法
            this.payload = payload;
        }

        public Truck() {
            super();//继承Car无参构造方法
        }

        public double getPayload() {
            return payload;
        }

        public void setPayload(double payload) {
            this.payload = payload;
        }
        //	方法show3
        public void show3(){
            System.out.println("有载重量为："+this.payload+"吨");
        }
    }
    public static void main(String[] args) {
      // 创建子类对象
        Truck cm = new Truck();
        cm.setWheels(4);
        cm.setWeight(1.5);
        cm.setLoader(5);
        cm.setPayload(2);
        //调用 方法
        cm.show1();
        cm.show2();
        cm.show3();
    }

三、多态

　　多态，顾名思义有多种形式，它允许不同的对象对同一个消息做出不同的响应。多态是同一个接口，通过使用不同的实例而执行不同的操作。

　　多态主要分为两种：重写和重载。重载是编译型多态，重写是运行时多态。编译看左边，运行看右边。

　　首先，对 “重写” 作一番解释，重写 发生于 继承关系中，子类在继承父类的原有方法。但是我们在有些情况下，不想要继承原有的方法，所以要对继承的方法进行重写，但是有一点需要注意，就是子类函数的访问修饰符权限不能够少于父类。重写是一个“动态绑定”，只有在运行的时候，我们才能确定访问具体方法是哪一个。

class Vegetable{
    public void vegetable(){
        System.out.println("蔬菜");
    }
}

class Cucumber extends Vegetable{
    @Override
    public void vegetable() {//子类Cycle对父类Vegetable的vegetable方法的重写
        System.out.println("黄瓜");
    }
}

class Bittermelon extends Vegetable{
    @Override
    public void vegetable(){//子类Bittermelon对父类Vegetable的vegetable方法的重写
        System.out.println("苦瓜");
    }
}

　　其次是重载，重载相比较于重写，简单一些，要求在于 “同名方法” 的参数列表不同。例子：fangfaming(int A) 与 fangfaming(int A，int B)是多态中的重写。　

public class A {

    public static void main(String[] args) {
        A a=new A();
        a.test(1,2);
        a.test(1);
    }
    public void test(int i,int j){
        System.out.print("A");
    }
    public void test(int i){
        System.out.print("B");
    }
}
//答案：AB