Java 三大特性

　一、Java第一大特性：封装

　　封装：将属性私有化，提供共有方法访问私有属性，实现细节隐藏，并且程序也更加容易维护。

class Dish {
    private final String name;
    private final boolean vegetarian;
    private final int calories;
    public Dish(String name,boolean vegetarian,int calories){
        this.name=name;
        this.vegetarian=vegetarian;
        this.calories=calories;
    }

    public boolean isVegetarian() {
        return vegetarian;
    }

    public int getCalories() {
        return calories;
    }

    public String getName() {
        return name;
    }

    public String toString() {
        return name;
    }

}
public class App
{
    public static void main( String[] args )
    {
         List<Dish> menu = Arrays.asList(
                 new Dish("pork",false,800),
                 new Dish("beef",false,700),
                 new Dish("pizza",true,300),
                 new Dish("chicken",true,500)

        );
        List<String> high=
                menu.stream()
                .filter(a->a.getCalories()>400)
                .filter(d->d.getName().contains("ke"))
                .map(Dish::getName)
                .limit(2)
                .collect(toList());
        System.out.println(high);
    }
}

　　上述代码中，在类Dish中声明了属性name、vegetarian和calorie,修饰符为private和final。这说明这三个参数对其他类是不可见的，其他类要想访问Dish类的属性，必须要通过Dish类的共有方法访问Dish类的私有属性，比如外部可以通过getName()方法访问Dish的name属性。

　二、Java第二大特性：继承

　　　继承：根据已有的类创建新类，重用父类代码

三、Java第三大特性：多态

　　　1.多态：在程序中定义的引用变量所指向的具体类型和通过该引用发出的方法调用在程序运行时才确定。由于在程序运行期间才确定具体的类和方法，因此可以动态的决定引用变量调用的类和方法，让程序选择多种运行状态。这就是多态性。

　　　2.多态的实现

　　　　 2.1 Java 实现多态有三个必要条件

　　　　　　继承：必须存在有继承关系的子类和父类

　　　　　　重写：子类对父类的方法进行重新定义

　　　　　　　　　需要注意的是，重写后子类和父类的对应函数名称是一致的，只是具体方法有所变化。但是重载后却是不同的函数，比如父类函数A(),重载后为A(int)，这两个函数为不同的　　　　　　　　　函数

　　　　　向上转型：(1)将子类对象赋给父类引用，比如父类A a=new 子类B();引用类型a指向B类型的对象，由于B是继承A的，因此new B()自动转型为A，即a指向B类实例对象（可以认　　　　　　　　　　　　　将子类对象转为父类对象），因此子类对象B可以调用父类的方法。如果子类重写了父类的方法，那么会调用子类的方法。

　　　　　　　　　　　(2)向上转型是安全的：向上转型会丢失子类比父类多出的方法，即使子类中方法f(int)是重载父类的f(),向上转型后仍然会丢失f(int)方法。

　　　　2.2 Java实现多态的形式

　　　　　 (1)基于继承实现的多态：主要利用了子类对父类方法的重写（注意和重载的区别，上文已提到）

 public class Wine {
     private String name;

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public Wine(){
     }

     public String drink(){
         return "喝的是 " + getName();
     }

     /**
      * 重写toString()
      */
     public String toString(){
         return null;
     }
 }

 public class JNC extends Wine{
     public JNC(){
         setName("JNC");
     }

     /**
      * 重写父类方法，实现多态
      */
     public String drink(){
         return "喝的是 " + getName();
     }

     /**
      * 重写toString()
      */
     public String toString(){
         return "Wine : " + getName();
     }
 }
 public class Test {
     public static void main(String[] args) {
         Wine jnc = new JNC();
         System.out.println(wines[i].toString() + "--" + wines[i].drink());
     }
 }
 OUTPUT:
 Wine : JNC--喝的是 JNC

　　　　　在上面的代码中(来自某位大神博客)，子类重写了父类的toString()和drink()方法(???),因此jnc调用了子类的方法。这就是多态性。

　　　　 (2)基于接口实现的多态

　　　　　　　继承关系中，子类只允许有一个父类，父类可以有多个子类。

　　　　　　接口实现中，一个类可以实现多个接口。因此，接口实现比继承更加灵活。