转：

java 继承和多态

一、继承：

概念：在Java中，类的继承是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类，现有类被称作父类，子类会自动拥有父类所有可继承的属性和方法。
继承的格式：在程序中，如果想声明一个类继承另一个类，需要使用extends关键字。

格式：

class 子类 extends 父类 {}；
继承的好处：

• 继承的出现提高了代码的复用性，提高软件开发效率。
• 继承的出现让类与类之间产生了关系，提供了多态的前提。

重写：
子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为override重写、复写或者覆盖。
重写的注意事项：

• 子类方法覆盖父类方法，必须要保证权限大于等于父类权限。
• 写法上稍微注意:必须一模一样:方法的返回值类型 方法名 参数列表都要一样。
  总结：当一个类是另一个类中的一种时，可以通过继承，来继承属性与功能。如果父类具备的功能内容需要子类特殊定义时，进行方法重写。

---

二、多态：

同一个对象，调用不同类的实例，从而得到不同的结果。
super关键字：
super多用于构造方法中继承父类的方法
super用来表示当前对象中包含的父类对象空间的引用。
在子类中，访问父类中的成员变量格式：
super.父类中的成员变量
final关键字：
修饰类：不能被继承
修饰方法：不能被重写
修饰对象：不能引用其他对象
修饰变量：变为常量
修饰属性，不能被重新赋值

---

实例：

编写程序实现披萨的制作。需求说明编写程序，接收输入信息，选择需要制作的披萨。可供选择的披萨有：培根披萨和海鲜披萨。
实现思路及关键代码
1）分析培根披萨和海鲜披萨。
2）定义披萨类（作为父类）。
属性： 名称、价格、大小；
方法：展示哦（show）；
3）定义培根披萨和海鲜披萨，分别继承披萨类。
4）定义披萨工厂类，根据输入信息生产具体的披萨对象。

：书写思路

1. 创建父类Pizza，创建公共属性name，size，price
2. 创建子类Bacon_pizza（培根披萨），创建私有属性gram（培根克数），重写父类方法show（），输出披萨培根的各种属性
3. 创建子类Seafood_pizza（海鲜披萨），创建私有属性seafood（海鲜口味），重写父类方法show（），输出海鲜培根的各种属性
4. 创建工厂java文件Pizza_factory，创建函数select（），让用户输入披萨的种类，分别进入不同的if语句进行两种披萨的类型选择，并将数据通过set方法进行属性重写，最后创建主函数运行。

一、父类Pizza：

public class Pizza {
    // 定义Pizza属性
    private String name;
    private String size;
    private int price;
//    提供公共的get和set方法让其他的类进行访问
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    // 尺寸
    public String getSize() {
        return size;
    }
    public void setPrice(int price) {
        this.price = price;
    }
    // 价格
    public int getPrice() {
        return price;
    }
    public void setSize(String size) {
        this.size = size;
    }

    //    定义方法
    public void show(){

    }
//    定义无参构造方法
    public Pizza(){
        super();
    }
//    定义有参构造方法
    public Pizza(String name,String size,int price){
        this.name = name;
        this.size = size;
        this.price = price;
    }
}

二、子类Bacon_pizza：

public class Bacon_pizza extends Pizza {
    // 定义培根披萨的私有属性
    private double gram;

    public double getGram() {
        return gram;
    }
    public void setGram(double gram) {
        this.gram = gram;
    }

    // 定义无参的构造方法
    public Bacon_pizza(){

    }
    // 定义有参的构造方法
    public Bacon_pizza(String name,String size,int price,double gram){
        // super 用来继承父类的方法
        super(name,size,price);
        this.gram = gram;
    }
    public void show(){
        System.out.println("披萨名称为："+super.getName());
        System.out.println("培根的克数为："+this.gram);
        System.out.println("尺寸为："+super.getSize());
        System.out.println("价格为："+super.getPrice());
    }
}

三、子类Seafood_pizza：

public class Seafood_pizza extends Pizza {
    private String seafood;

    public String getSeafood() {
        return seafood;
    }
    public void setSeafood(String seafood) {
        this.seafood = seafood;
    }
    // 定义无参的构造方法
    public Seafood_pizza(){
        super();
    }
    // 定义有参的构造方法
    public Seafood_pizza(String name,String size,int price,String seafood){
        super(name,size,price);
        this.seafood=seafood;
    }
    // 重写父类的方法
    public void show(){
        System.out.println("披萨的名称为："+super.getName());
        System.out.println("口味为："+this.seafood);
        System.out.println("尺寸为："+super.getSize());
        System.out.println("价格为："+super.getPrice());
    }
}

四、工厂Pizza_factory：

import java.util.Scanner;

public class Pizza_factory{

    public void select(){
        Scanner scanner = new Scanner(System.in);
        System.out.println("请选择请要制作的披萨种类：（1.培根披萨 2.海鲜披萨）");
        int i = scanner.nextInt();
        if (i==1){
            System.out.println("请输入培根的克数：");
            double gram = scanner.nextDouble();
            System.out.println("请输入披萨的尺寸（大份、中份、小份）：");
            String size = scanner.next();
            System.out.println("请输入披萨的价格：");
            int price = scanner.nextInt();

            Pizza p = new Bacon_pizza();
            Bacon_pizza b = (Bacon_pizza) p;
            b.setGram(gram);
            p.setName("培根披萨");
            p.setSize(size);
            p.setPrice(price);
            p.show();
        }else if (i==2){
            System.out.println("请输入海鲜的口味：");
            String seafood = scanner.next();
            System.out.println("请输入披萨的尺寸（大份、中份、小份）：");
            String size = scanner.next();
            System.out.println("请输入披萨的价格：");
            int price = scanner.nextInt();

            Pizza p = new Seafood_pizza();
            Seafood_pizza b = (Seafood_pizza) p;
            b.setSeafood(seafood);
            p.setName("海鲜披萨");
            p.setSize(size);
            p.setPrice(price);
            p.show();
        }else {
            System.out.println("请输入有效的数字！！！");
            select();
        }
    }

    public static void main(String[] args) {
        Pizza_factory factory = new Pizza_factory();
        factory.select();
    }
}

---

转：

java 继承和多态

java 继承和多态

原文：https://www.cnblogs.com/wangtcc/p/14538137.html