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)
- 如何实现多态：
- 方法重写 - 子类在继承父类的过程中对父类的方法给出自己的实现版本
- 对象造型 - 用父类型的变量保存子类对象
- 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);
}
}
