Java学习第12天

abstract关键字

• 如果一个方法暂时无法给出实现，那么可以将其声明为抽象方法 - abstract关键字
• 抽象方法没有方法体
• 如果一个类中有抽象方法(说明这个类不完整)，那么必须被声明为抽象类。
  有抽象类，不一定有抽象方法。有抽象方法，必须写成抽象类
• 抽象类不能实例化(不能创建抽象类的对象)
• 抽象类是专门留给其他类去继承的类

package org.mobiletrain;

/**
 * 宠物
 * @author apple
 *
 */
public abstract class Pet {

    protected String name;
    protected String color;
    private Sex sex;
    
    /**
     * 构造器
     * @param name 昵称
     * @param color 颜色
     * @param weight 重量
     */
    public Pet (String name,Sex sex){
        this.name = name;
        this.sex = sex;
    }
    

    /**
     * 发出声音
     */

    public abstract void makeVoice();
                                    
    /**
     * 玩
     * @param gameName
     */
    public void paly(String gameName){
        System.out.println(color + "的" + name + "正在玩" + gameName);
    }
    
    /**
     * 吃
     * @param foods
     */
    public void eat(String foods){
        System.out.println(name + "在吃" + foods);
    }
    
    /**
     * 获得性别
     * @return 公或者母
     */
    public String getSex(){
        return sex == Sex.MALE ? "公" : "母";
    }
}

重写

• cat类继承了pet类，对pet类中的抽象方法进行了重写。
• 重写(置换、覆盖、覆写)：父类有这个方法，可能实现了，可能没有实现
  子类把父类的这个方法重新实现一次(给出自己的实现版本)
• 重载与重写的区别：
  重载：同一个类中有同名的方法，只要参数列表不一样，就可以共存 - overload
  重写：子类继承父类的过程中对父类已有的方法给出新的实现版本 - override

package org.mobiletrain;

public class Cat extends Pet {
    private String colorOfEye;

    public Cat(String name, Sex sex,String colorOfEye) {
        super(name, sex);
        this.colorOfEye = colorOfEye;
    }

    public void climbUpTheTree(){
        System.out.println(name + "正在爬树");
    }
    
    public String getColorOfEye() {
        return colorOfEye;
    }
    @Override
    public void makeVoice() {
        System.out.println(name + ": 喵~");      
    }
}

多态

• 多态：同样的类型调用相同的方法(发同样的消息)，但是做了不同的事情 -，这就是"多态"(polymorphism)
• 如何实现多态：
  1. 方法重写 - 子类在继承父类的过程中对父类的方法给出自己的实现版本
  2. 对象造型 - 用父类型的变量保存子类对象
• instanceof运算符：用来判定对象是不是某种类型，该运算符是在程序运行的时候去判定对象的类型 - RTTI

package org.mobiletrain.test;

import org.mobiletrain.Cat;
import org.mobiletrain.Dog;
import org.mobiletrain.Pet;
import org.mobiletrain.Mistress;
import org.mobiletrain.Sex;

public class PetTest {

    public static void main(String[] args) {
        //栈 - 快，小 - 放临时变量/局部变量(对象的引用)
        //堆 - 稍慢，大 - 放对象(对象的本身)
        //方法区 - 代码，常量
        Pet temp = new Cat("花花", Sex.FEMALE, "蓝色");
        //temp在栈上，它保存了堆上的cat对象的地址
        //通过temp就可以找到堆上对应的cat对象并给对象发消息
        //所以我们通常把对象类型的变量称为对象的引用
        //java中的类型分为两大类：
        // - 基本数据类型(8种)和枚举类型
        // - 引用类型
        System.out.println(temp);
        Pet[] petsArray = {
                new Dog("旺财", Sex.MALE, true),
                new Cat("咪咪", Sex.FEMALE, "绿色"),
                new Dog("欢欢", Sex.MALE, false),
                new Mistress("狗蛋", Sex.FEMALE)
        };  
        for (Pet pet : petsArray) {
            pet.eat("饭");
            pet.makeVoice();
            if (pet instanceof Dog){
                ((Dog) pet).keepTheDoor();
            }
            else if (pet instanceof Cat) {
                ((Cat) pet).climbUpTheTree();
            }
            else if (pet instanceof Mistress) {
                ((Mistress) pet).makeTrouble();
            }
        }
    }
}

• 面向对象的四大支柱：
  1.抽象 - 定义一个类的过程就是一个抽象的过程（数据抽象、行为抽象），通过 抽象，我们可以将数据和操作数据的方法以"对象"的概念绑定到一起.抽象的过程是一个仁者见仁智者见智的过程。同一个对象做抽象可能会产生不同的结果

2.封装 - 隐藏一切可以隐藏的实现细节，只向外界提供最简单的编程接口

3.继承 - 从一个已有的类创建新类的过程，提供继承信息的叫父类（超类，基类），得到继承信息的叫子类（派生类，衍生类），继承是实现代码复用的一种手段

4.多态 - 同样的引用类型调用相同的方法，但是做了不同的事情

• 实现多态的两个关键步骤：1.方法重写 2. 对象造型

多态练习：

• 员工类:

package org.moblietrain;

/**
 * 员工(抽象类)
 * @author apple
 *
 */
public abstract class Employee {

    protected String name;
    
    /**
     * 构造器
     * @param name 员工姓名
     */
    public Employee(String name){
        this.name = name;
    }
    
    /**
     * 获得员工姓名
     * @return 员工姓名
     */
    public String getName() {
        return name;
    }
    
    /**
     * 计算月薪
     * @return 月薪
     */
    public abstract double getSalary();
}

• 经理类:

package org.moblietrain;

/**
 * 部门经理
 * @author apple
 *
 */
public class Manager extends Employee {

    public Manager(String name) {
        super(name);
        
    }

    @Override
    public double getSalary() {
        return 12000;
        
    }
    
}

• 程序员类：

package org.moblietrain;

/**
 * 程序员
 * @author apple
 *
 */
public class Programmer extends Employee {

    private int hour;
    
    /**
     * 构造器
     * @param name
     */
    public Programmer(String name) {
        super(name);
    }
    
    /**
     * 设置工作时间
     * @param hour 工作时间（小时为单位）
     */
    public void setHour(int hour) {
        this.hour = hour;
    }
    
    @Override
    public double getSalary() {
        return 150 * hour;
    }
}

• 销售员类：

package org.moblietrain;
/**
 * 销售员
 * @author apple
 *
 */
public class Salesman extends Employee{

    private double sales;
    
    /**
     * 构造器
     * @param name 销售员姓名
     */
    public Salesman(String name) {
        super(name);
        
    }

    /**
     * 设置销售额
     * @param sales 销售额（以元为单位）
     */
    public void setSales(double sales) {
        this.sales = sales;
    }
    
    @Override
    public double getSalary() {
        
        return 1500 + sales * 0.05;
    }

}

• 测试类：
  Java中有4种访问修饰符：
  private < default < protected < public
  类前面不加public,在同一文件夹下的其他类可以访问，对于外部的其他类，不能访问

package org.moblietrain.test;

import java.util.Scanner;

import org.moblietrain.Employee;
import org.moblietrain.Manager;
import org.moblietrain.Programmer;
import org.moblietrain.Salesman;

class SalarySystem {

    public static void main(String[] args) {
        Employee[] empsArray = {
            new Manager("曹操"),
            new Manager("刘备"),
            new Programmer("诸葛亮"),
            new Salesman("张飞")
        };
        Scanner input = new Scanner(System.in);
        for (Employee employee : empsArray) {
            if (employee instanceof Programmer) {
                System.out.print("请输入" + employee.getName() + "本月工作时间:");
                int hour = input.nextInt();
                ((Programmer) employee).setHour(hour);
            }
            else if (employee instanceof Salesman) {
                System.out.print("请输入" + employee.getName() + "本月销售额:");
                double sales = input.nextInt();
                ((Salesman) employee).setSales(sales);
            }
    System.out.printf("%s本月工资为：￥%.2f\n",employee.getName(),employee.getSalary());
        }
        input.close();
    }

}

窗口类：

package org.moblietrain.ui;

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;

import javax.swing.JFrame;
@SuppressWarnings("serial")
public class MyFrame extends JFrame {

    public MyFrame(){
        this.setTitle("五子棋");
        this.setSize(650, 650);
        this.setResizable(false);
        this.setLocationRelativeTo(null);
        this.setDefaultCloseOperation(EXIT_ON_CLOSE);
    }

    @Override
    public void paint(Graphics g) {
        super.paint(g);
        g.setColor(new Color(230, 210, 100));
        g.fillRect(0, 0, 650, 650);
        g.setColor(Color.black);
        for (int i = 0; i < 15; i++) {
            g.drawLine(40, 60 + 40 * i, 600, 60 + 40 * i);
            g.drawLine(40 * (i + 1), 60, 40 * (i + 1), 620);
        }
        ((Graphics2D)g).setStroke(new BasicStroke(3));
        g.drawRect(35, 55, 570, 570);
        g.fillOval(315,335,9,9);
        g.fillOval(155,175,9,9);
        g.fillOval(475,175,9,9);
        g.fillOval(155,496,9,9);
        g.fillOval(475,496,9,9);
    }
}