Java三大特性

导语：Java是一门面向对象的编程语言，有三大特性：封装、继承、多态。

本篇文章主要讲述的是Java的这三大特性。

1 封装

1.1 概念

封装指的是属性私有化，根据需要提供setter和getter方法来访问属性。即隐藏具体属性和实现细节，仅对外开放接口，控制程序中属性的访问级别。

1.2 封装的目的

封装目的：增强安全性和简化编程，使用者不必在意具体实现细节，而只是通过外部接口即可访问类的成员。

1.3 封装的代码实现

// 创建一个Animal类
public class Animal{
    // 私有属性，name
    private String name;
    // 私有属性，age
    private Integer age; 
    // 公开的getName方法
    public String getName(){
        return this.name;
    }
    // 公开的setName方法
    public void setName(String name){
        this.name = name;
    }
    // 公开的getAge方法
    public Integer getAge(){
        this.age = age;
    }
    // 公开的setAge方法
    public void setAge(Integer age){
        this.age = age;
    }
}

通过代码可以看出，别人在访问这个Animal类的属性时，只能通过提供的公开方法进行访问，可以很好的保护属性的安全，假如想要保护 name属性不被修改，那就可以只对外提供 getName()方法，而不提供 setName()方法，进而可以保护 name属性不被修改。

2 继承

2.1 概念

继承是指将多个相同的属性和方法提取出来，新建一个父类。
Java中一个类只能继承一个父类，且只能继承访问权限非private的属性和方法。 子类可以重写父类中的方法，命名与父类中同名的属性。

2.2 继承的目的

继承的目的：继承可以很好的提升代码的复用性。简化了人们对事物的认识和描述，能清晰体现相关类间的层次结构关系。

2.3 继承的代码实现

// 创建一个Animal类
public class Animal{
    String name;
    // 无参构造
    public Animal(){}
    // 有参构造
    public Animal(String name){
        this.name = name
    }
    // 所有动物都有sleep方法
    public void sleep(){
        System.out.println("animal sleep : "+ name);
    }
}
// 创建一个Dog类，继承Animal
// 可以继承Animal中的非私有属性和方法
class Dog extends Animal{
    public void eat(){
        System.out.println("dog eat : "+ name);
    }
}
// 创建一个Cat类，继承Animal
// 可以继承Animal中的非私有方法和属性
// 也可以重写父类的方法
class Cat extends Animal{
    @Override
    public void sleep(){
        System.out.println("cat sleep : "+ name);
    }
}

// 创建测试类
public class TestAnimal{
    public static void main(String[] args){
        Animal a = new Animal("小动物");
        a.sleep();
        Dog dog = new Dog("旺财");
        dog.sleep();
        dog.eat();
        Cat cat = new Cat("喵喵");
        cat.sleep();
    }
}
运行结果：
    animal sleep : 小动物
    animal sleep : 旺财
    dog eat : 旺财
    cat sleep : 喵喵

3 多态

3.1 概念

多态最核心的一句话就是：将子类对象放入父类引用中，从而实现多种状态。

多态可以分为两种：设计时多态和运行时多态。
设计时多态：即重载，是指Java允许方法名相同而参数不同（返回值可以相同也可以不相同）。
运行时多态：即重写，是指Java运行根据调用该方法的类型决定调用哪个方法。

3.2 多态的目的

多态的目的：增加代码的灵活度。

在实际操作中，多态可以让我们不用关心某个对象具体时什么类型，就可以使用该对象的某些方法，而这些方法通过一个抽象类或者接口来实现，多态就是提供父类调用子类代码的一个手段而已。

3.3 多态的代码实现

// 创建一个Animal类
public class Animal{
    String name;
    // 无参构造
    public Animal(){}
    // 有参构造
    public Animal(String name){
        this.name = name
    }
    // 所有动物都有sleep方法
    public void sleep(){
        System.out.println("animal sleep : "+ name);
    }
}
// 创建一个Dog类，继承Animal
// 可以继承Animal中的非私有属性和方法
class Dog extends Animal{
    public void eat(){
        System.out.println("dog eat : "+ name);
    }
}
// 创建一个Cat类，继承Animal
// 可以继承Animal中的非私有方法和属性
// 也可以重写父类的方法
class Cat extends Animal{
    @Override
    public void sleep(){
        System.out.println("cat sleep : "+ name);
    }
}

// 创建测试类
public class TestAnimal{
    public static void main(String[] args){
        Animal a = new Animal("小动物");
        a.sleep();
        Animal b = new Dog("旺财");
        b.sleep();
        // b不能调用eat方法，只能调用父类中已经声明的方法
       // b.eat();
        // 可以使用向下强制类型转换，转换成Dog类型
        Dog dog = (Dog)b;
        dog.eat();
        Animal c = new Cat("喵喵");
        c.sleep();
    }
}
运行结果：
    animal sleep : 小动物
    animal sleep : 旺财
    dog eat : 旺财
    cat sleep : 喵喵

总而言之，多态的核心就是一句话：将子类对象放入父类引用中，从而实现多种状态。

使用多态后，对象只能调用父类已经声明的方法，如果想要调用字类特有的方法，可以使用向下强制类型转换。

如果想要判断一个对象是否是属于一个类，可以使用 instanceof关键字进行判断。

// 创建测试类
public class TestAnimal{
    public static void main(String[] args){
        Animal b = new Dog("旺财");
        System.out.println(b instanceof Animal);
        System.out.println(b instanceof Dog);
        System.out.println(b instanceof Cat);
    }
}
运行结果：
    true
    true
    false

4 小结

本篇文章简单介绍了Java的三大特性，由于纯手打，难免会有纰漏，如果发现错误的地方，请第一时间告诉我，这将是我进步的一个很重要的环节。