Java面对对象三大特征：封装，继承，多态详解笔记；Java多态例题：乐手演奏乐器，披萨工厂；

一，封装

                  封装目的：  为了代码的安全性。

                  数据封装：通过公有的方法，访问私有的属性。

     例：

                

因为User的age属性未封装，在用户输入时可以随意输入，明显超出实际。

所以将age属性私有化

然后提供一个公有方法，对数据进行保护（安检符合要求的才可以赋值）

  封装数据同时需要共有赋值和调用方法：

注：  封装数据同时需要共有赋值和调用方法： 

   封装数据使用：

                      补： 标准的实体类：

                                                     1.属性私有化
                                                     2.提供get/set方法(分析属性是只有get还是都有)
                                                     3.构造方法：有无参和全参构造方法
                                                     4.由题（需求）分析出要具有的成员方法。

二，继承

                  继承目的：为了代码的重用性

             使用继承的前提场所：

                                        当前系统/要求/题中有多个参与者，且多个参与者是同一大类对象。（具有相同重复的属性和共同的行为（方法））的一组对象。这样的类之间可以通过代码实现代码重用性。

            继承实现步骤：

                                  1.找到各个类中相同的属性和行为，提取出，放入单独的类，这个单独的类称父类。父类也称超类。
                                  2.各个类中特有的的属性和行为，仍放入各自的类，这个类称子类。
                                  3.借助   extends + 父类  实现继承

              补：“寻找”父类技巧： 

                                 继承可以抽出父类 ：学生，教室，员工     提出父类person  可以说成：学生是一个人，老师是一个人
                                不能继承不可以抽出父类：飞机，鸟（虽然也有相同的属性和行为：重量，颜色，飞，但不能提取为一大类）
                                 考虑是否可以继承，考虑所要考虑的类是否可以来自一个  与生俱来的  的场所，出生即带有飞机和鸟与生俱来的不同，所以不能继承。第一个提出person  可以说成：学生是一个人，老师是一个人。而第二个提不出一个a，可以实现飞机是a，鸟也是a。所以第一个可以继承和提出父类，第二个不可以 。

           继承的特性：

                                       单根性：（只有一个父类）     传递性：c继承a，b继承c 则b也可以继承a。

          继承方式：

                                    显式继承：  写类名 extends  父类
                                    隐式继承：  没有 extends    （都继承了object（根基类））

                    子类继承父类的那些资源：

                                  只有父类构造方法不可以继承，但是可以调用。

                    子类可以使用哪些继承的东西：

                                    除了构造方法外都可以继承，但是可以调用构造方法。

               补：从父类继承的资源的权限问题：

                补：重写和重载区别：

三，多态

                       多态的目的：为了代码的拓展性。

                     什么是多态： 

                                               同一个父类下，不同子类在进行同一行为时，有不同的表现形态，就是多态。（以继承来说）
                                               多态是指同一个实现接口，使用不同的实例而执行不同的操作 。（以接口为准来说）

                    多态要具备的前提条件：

                                            继承父类/实现接口        方法的重写        声明父类new子类  （ 在运行期，会根据实际传入的子类对象动态调用该子类的对应的重写方法。所以多态又称：动态绑定。）

                   多态的两种表现形式：

                    父类做参数：（以乐手弹奏乐器为例）：

首先创建乐器父类：

public abstract class MusicalInstrument {
     public abstract void MakeSound();
}

之后创建子类乐器：

public class Erhu extends MusicalInstrument {
    @Override
    public void MakeSound() {
        System.out.println("二胡声");
    }
}

public class Piano extends MusicalInstrument {
    @Override
    public void MakeSound() {
        System.out.println("钢琴声");
    }
public class Violin extends MusicalInstrument {
    @Override
    public void MakeSound() {
        System.out.println("小提琴声");
    }
}

之后为实现多态的重点：声明父类new子类的乐手类以及测试类：

public class MusicalMan {
    public  void play(MusicalInstrument M){
        M.MakeSound();

    }
}

public class Test {
    public static void main(String[] args) {
      MusicalMan m1=new MusicalMan();
      m1.play(new Erhu());
      m1.play(new Piano());
      m1.play(new Violin());


    }

                    父类做返回值（以披萨工厂问题为例）：

                 

首先创建披萨父类：

public abstract class Pizza {
    private String name;
    private int size;
    private int price;
public abstract void show();
    public String getName() {
        return name;
    }

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

    public int getSize() {
        return size;
    }

    public void setSize(int size) {
        this.size = size;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public Pizza() {
    }

    public Pizza(String name, int size, int price) {
        this.name = name;
        this.size = size;
        this.price = price;
    }
}

之后分别创建两种披萨店子类：

import java.util.Scanner;

public class Becon extends Pizza {
    private int quantitly;

    public int getQuantitly() {
        return quantitly;
    }

    public Becon(String name, int size, int price, int quantitly) {
        super(name, size, price);
        this.quantitly = quantitly;
    }

    public void setQuantitly(int quantitly) {
        this.quantitly = quantitly;
    }

    public Becon(String name, int size, int price) {
        super(name, size, price);
    }

    public Becon() {
    }

    @Override
    public void show() {
        setName("培根披萨");
        System.out.println("名称："+getName());
        System.out.println("价格："+getPrice());
        System.out.println("大小："+getSize()+"寸");
        System.out.println("培根数："+quantitly);
    }
}

import java.util.Scanner;

public class Sea extends Pizza {
    private String material;

    public Sea(String name, int size, int price, String material) {
        super(name, size, price);
        this.material = material;
    }

    public Sea(String name, int size, int price) {
        super(name, size, price);
    }

    public Sea() {
    }

    @Override
    public void show() {

        System.out.println("名称："+getName());
        System.out.println("价格："+getPrice());
        System.out.println("大小："+getSize()+"寸");
        System.out.println("配料："+material);
    }
}

然后是实现多态的披萨工厂类

import java.util.Scanner;

public class PizzaFactory {
    public Pizza produce(){

        Scanner input = new Scanner(System.in);
        System.out.println("请选择想要制作的披萨:(1.培根披萨，2海鲜披萨)");
        int i = input.nextInt();
        Pizza pizza;//
        if(i==1) {
            System.out.println("请输入培根克数：");
            int keShu = input.nextInt();
            System.out.println("请输入披萨大小：");
            int size = input.nextInt();
            System.out.println("请输入披萨价格：");
            int price = input.nextInt();
           pizza = new Becon("培根披萨",keShu,size,price);//

        }else{
            System.out.println("请输入配料信息：");
            String peiLiao = input.next();
            System.out.println("请输入披萨大小：");
            int size = input.nextInt();
            System.out.println("请输入披萨价格：");
            int price = input.nextInt();
             pizza = new Sea("海鲜披萨",size,price,peiLiao);//


        }
        pizza.show();//
        return pizza;//

    }
}

test类如下

public class Test {
    public static void main(String[] args) {


        Pizza p2=new PizzaFactory().produce();//
        System.out.println(p2);
    }
}

补：可能有点同学不理解以父类为返回值怎么实现多态了？其实上述例题中以父类为返回值的部分仍缺失Java中反射的基础代码；披萨功能添加反射的2.0版会在之后给各位奉上(≧∀≦)ゞ