JAVA面向对象笔记

写在前面的话

1.看的视频是翁恺老师的Java面向对象程序设计

2.所用的软件和资料

• 开发环境
  eclipse

• 上课用到的代码包
  github链接

https://github.com/wang-weiing/JavaLearning.git

• java开发文档
  文档、代码包和此博客的markdown文件都在以下网盘链接里

链接：https://pan.baidu.com/s/1eu-BtpBue0xiKsfkqrQ8xA?pwd=1234 
提取码：1234

有些章节没有写
有些章节写的不太好，如有错误，欢迎指出

JAVA面向对象

定义类

对象是实体

类是规范

对象 = 数据 + 操作 （数据被隐藏 这一过程叫封装）

代码

package vendingmachine;

public class VendingMachine {
	int price = 50;
	int balance;
	int total;
	
	void showPrompt()
	{
		System.out.println("Welcome");
	}
	
	void inserMomey(int amount)
	{
		balance = balance + amount;
	}
	
	void showBalance()
	{
		System.out.println(balance);
	}
	
	void getFood()
	{
		if (balance >= price)
		{
			System.out.println("Here you are");
			balance = balance - price;
			total = total + price;
		}
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		VendingMachine vm = new VendingMachine();
		VendingMachine vm1 = new VendingMachine();
		vm.showPrompt();
		vm.showBalance();
		vm.inserMomey(100);
		vm1.inserMomey(200);
		vm.getFood();
		vm.showBalance();
		vm1.showBalance();
	}

}

成员变量和成员函数

成员变量

类定义了对象中所具有的变量，这些变量称作成员变量
每个对象都有自己的变量，和同一个类的其他对象是分开的

成员函数

• 在函数中可以直接写成员变量的名字来访问成员变量
• 那么究竟访问的是哪个对象
• 函数是通过对象来调用的
  • v.insertMoney()
• 这次调用临时建立了insertMoneyd()和v之间的关系，让insertMoneyd()内部的成员变量指的是v的成员变量
• this建立联系
  • this是成员函数的一个特殊的固有的本地变量，它表达了调用这个函数的那个对象

this可以这样用

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

本地变量

• 定义在函数内部的变量是本地变量
• 本地变量的生存期和作用域都是函数内部
• 成员变量的生存期是对象的生存期，作用域是类内部
• java有自动回收机制 只需要关注创建对象 不需要关注销毁对象

对象初始化

构造函数

• 如果有一个成员函数的名字和类的名字完全相同，则在创建这个类的每一个对象的时候会自动调用这个函数–>构造函数
• 如果没有写构造函数 java会有默认的构造函数
• 这个函数不能有返回类型
• 函数重载
  • 一个类可以有多个构造函数，只要它们的参数表不同
  • 创建对象的时候给出不同的参数值，就会自动调用不同的构造函数
  • 通过this()还可以调用其他构造函数
  • 一个类里同名但参数不表不同的函数构成了重载关系

package vendingmachine;

public class VendingMachine {
	int price = 50;
	int balance;
	int total = 20;
	
	VendingMachine()  //构造函数
	{
		total = 0;
	}
	
	VendingMachine(int price)  //重载
	{
		this();  //调用其他的构造函数 只能出现在第一句且只能出现一次
		this.price = price;
	}
	
	
	void setPrice(int price)
	{
		this.price = price;
	}
	void showPrompt()
	{
		System.out.println("Welcome");
	}
	
	void inserMomey(int amount)
	{
		balance = balance + amount;
	}
	
	void showBalance()
	{
		System.out.println(balance);
	}
	
	void getFood()
	{
		if (balance >= price)
		{
			System.out.println("Here you are");
			balance = balance - price;
			total = total + price;
		}
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		VendingMachine vm = new VendingMachine();
		vm.showPrompt();
		vm.showBalance();
		vm.inserMomey(100);
		vm.getFood();
		VendingMachine vm1 = new VendingMachine(100);
		vm1.inserMomey(200);
		vm.getFood();
		vm.showBalance();
		vm1.showBalance();
	}

}

对象的识别

11:03 一个时钟 如何划分对象？

一个数字一个对象？

整体为对象？

两位数字为一个对象？

时和分分别为一个对象

时和分有共同的特征

• 加到一个限定数字后归零

package clock;

public class Display {
	private int value = 0;
	private int limit = 0;
	
	public Display(int limit)
	{
		this.limit = limit;
	}
	
	public void increase()
	{
		value++;
		if(value == limit)
		{
			value = 0;
		}
	}
	
	public int getValue()
	{
		return value;
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Display d = new Display(24);
		for( ; ; )
		{
			d.increase();
			System.out.println(d.getValue());
		}
	}

}

对象的交互

一个对象里面有别的对象

对象之间尽量相互独立

在这个例子中对象Clock中有hour和minute

hour和minute是一个类的两个对象 相互独立

Clock把他们联系在一起

package clock;

public class Clock {
	private Display hour = new Display(24);
	private Display minute = new Display(60);
	
	public void start()
	{
		while(true)
		{
			minute.increase();
			if(minute.getValue() == 0)
			{
				hour.increase();
			}
			System.out.printf("%02d:%02d\n",hour.getValue(),minute.getValue());
		
		}
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Clock clock = new Clock();
		clock.start();
	}

}

封闭的访问属性

private

• private只能用于成员变量或成员函数

• 只有这个类内部可以访问

  • 类内部指的成员函数和定义初始化
  • 这个限制是对类的而不是对象的（以下代码解释）
  • 一个类的不同对象之间可以访问别人的对象的私有成员

r中的b是私有变量 但是在以下函数中可以调用成功

public Fraction plus(Fraction r)
{
	int fenzi = a*r.b+r.a*b;
}

开放的访问属性

不加修饰的成员跟它位于同一个包内的对象可以访问

叫做friendly

• 一个java文件为一个编译单元

• 一次对一个编译单元的东西做操作

• 一个编译单元只能有一个public类

• public类 与java文件名必须一致

• 类前面不加修饰符只能在包里面使用

包

用到的类不在包里 需要

import display.Display;

如果不import 用到的时候写全名也可以

private display.Display hour = new display.Display(24);
private display.Display minute = new display.Display(60);

文件夹体系display/led/Display

import display.led.Display;

类变量

类变量

• 类里面的变量
• 一个类的所有对象共用一份
• 类变量由static修饰成员变量定义
• 可以通过类的名字去访问

private static int step = 1;

package display.led;

public class Display {
	private int value = 0;
	private int limit = 0;
	private static int step = 1;
	
	public Display(int limit)
	{
		this.limit = limit;
	}
	
	public void increase()
	{
		value++;
		if(value == limit)
		{
			value = 0;
		}
	}
	
	public int getValue()
	{
		return value;
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Display d1 = new Display(10);
		Display d2 = new Display(20);
		d1.increase();
		System.out.println(d1.getValue());
		System.out.println(d2.getValue());
		System.out.println(d1.step);
		System.out.println(d2.step);
		d1.step = 2;
		System.out.println(d1.step);
		System.out.println(d2.step);
		Display.step = 3;
		System.out.println(d1.step);
		System.out.println(d2.step);
	}

}

运行结果

1
0
1
1
2
2
3
3

类函数

• 函数前面加类表示函数不属于任何对象 属于这个类

• static的函数只能访问static的成员变量

• 可以通过类的名字去访问也可以通过对象的名字去访问

• static的初始化根对象的创建没有关系 在类被装载进程序里就初始化了

public static void f1()

顺序容器

记事本的例子

需求

• 能存储记录
• 不限制能储存的记录的数量
• 能知道已经存储的记录的数量
• 能查看存进去的每一条记录
• 能删除一条记录
• 能列出所有的记录

接口设计

add(String note);
getSize();
getNote(int index);
removeNote(int index);
list();

• UI和业务逻辑分离

泛型容器类

带尖括号的叫泛型类

ArrayList<String>

• 容器类有两个类型
  • 容器的类型 ArrayList
  • 元素的类型 String

import java.util.ArrayList;

private ArrayList<String> notes = new ArrayList<String>();

package notebook;

import java.util.ArrayList;

public class NoteBook {
	private ArrayList<String> notes = new ArrayList<String>();
	
	public void add(String s)
	{
		notes.add(s);
	}
	
	public int getSize()
	{
		return notes.size();
	}
	
	public String getNote(int index)
	{
		return "";
	}
	
	public boolean removeNote(int index)
	{
		return true;
	}
	
	public String[] list()
	{
		return new String[10];
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String[] a = new String[2];
		a[0] = "first";
		a[1] = "second";
		NoteBook nb = new NoteBook();
		nb.add("first");
		nb.add("second");
		System.out.println(nb.getSize());
	}

}

ArrayList的操作

相关操作见代码

package notebook;

import java.util.ArrayList;

public class NoteBook {
	private ArrayList<String> notes = new ArrayList<String>();
	
	public void add(String s)
	{
		notes.add(s);
	}
	//插入相应位置
	public void add(String s, int location)
	{
		notes.add(location,s);
	}
	
	public int getSize()
	{
		return notes.size();
	}
	
	public String getNote(int index)
	{
		return notes.get(index);
	}
	
	public void removeNote(int index)
	{
		notes.remove(index);
	}
	
	public String[] list()
	{
		String[] a = new String[notes.size()];
//		for(int i=0; i<notes.size(); i++)
//		{
//			a[i] = notes.get(i);
//		}
        //知道系统类库的函数很重要 省心省事效率高
		notes.toArray(a);
		return a;
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		NoteBook nb = new NoteBook();
		nb.add("first");
		nb.add("second");
		nb.add("third",1);
		System.out.println(nb.getSize());
		System.out.println(nb.getNote(0));
		System.out.println(nb.getNote(1));
		String[] a = nb.list();
		for(String s : a)
		{
			System.out.println(s);
		}
	}

}

对象数组

String[] a = new String[10];

• 十个管理者 类似于指针

• 初始是null

• 对象数组中的每个元素都是对象的管理者而非对象本身

• 对于容器类来说for-each也能用

对象数组的for-each循环

详细见代码

package notebook;

import java.util.ArrayList;

class Value
{
	private int i;
	public void set(int i) {this.i = i;}
	public int get() {return i;}
}

public class NoteBook {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Value[] a = new Value[10];
		for(int i=0; i<a.length;i++)
		{
			a[i] = new Value();
			a[i].set(i);
		}
		
		for(Value v : a)
		{
			System.out.println(v.get());
		}

	}

}

集合容器

• 集合就是数学的集合 没有重复元素

注意

System.out.println(a);输出类的时候类里面应定义toString()

否则会出现乱码

class Value
{
	private int i;
	public void set(int i) {this.i = i;}
	public int get() {return i;}
	public String toString() {return ""+i;}
}

public static void main(String[] args) {
		// TODO Auto-generated method stub
		Value v = new Value();
		v.set(5);
		System.out.println(v);
		ArrayList<String> a = new ArrayList<String>();
		a.add("first");
		a.add("second");
		a.add("first");
//		for(String s : a)
//		{
//			System.out.println(s);
//		}
		//或者也可以这样
		System.out.println(a);
		System.out.println("---------------");
		HashSet<String> s = new HashSet<String>();
		s.add("first");
		s.add("second");
		s.add("first");
//		for(String k : s)
//		{
//			System.out.println(k);
//		}
		System.out.println(s);
	}

}

输出结果

5
[first, second, first]
---------------
[first, second]

散列表Hash

• Hash表由键值对构成 一个键对应一个值

• 对于Hash表来说 键一定是唯一的 如果放了多次 只会留下最后放的一次

package coins;

import java.util.HashMap;
import java.util.Scanner;

public class Coins {
	private HashMap<Integer,String> coinnames = new HashMap<Integer,String>();
	
	public Coins()
	{
		coinnames.put(1, "penny");
		coinnames.put(10, "dime");
		coinnames.put(25, "quarter");
		coinnames.put(50, "half-dolar");
		coinnames.put(50, "五毛");
		//调试用
		System.out.println(coinnames.keySet().size());
		System.out.println(coinnames);
		//遍历
		for(Integer k : coinnames.keySet())
		{
			String s = coinnames.get(k);
			System.out.println(s);
		}
	}
	
	public String getName(int amount)
	{
		if(coinnames.containsKey(amount))
			return coinnames.get(amount);
		else
			return "NOT FOUND";
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in = new Scanner(System.in);
		int amount = in.nextInt();
		Coins coin = new Coins();
		String name = coin.getName(amount);
		System.out.println(name);
	}

}

继承

• 引入
  • 例子 类中同时储存CD和DVD
  • 实现过程中大量代码复制
  • 不好维护
  • 不具备扩展性

CD

package dome;

public class CD {
	private String title;
	private String artist;
	private int numofTracks;
	private int playingTime;
	private boolean gotIt = false;
	private String comment;
	
	
	public CD(String title, String artist, int numofTracks, int playingTime, String comment) {
		super();
		this.title = title;
		this.artist = artist;
		this.numofTracks = numofTracks;
		this.playingTime = playingTime;
		this.comment = comment;
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}
	public void print() {
		// TODO Auto-generated method stub
		System.out.println("CD:"+title+":"+artist);
	}

}

DVD

package dome;

public class DVD {
	private String title;
	private String director;
	private int playingTime;
	private boolean gotIt = false;
	private String comment;
	
	
	
	


	public DVD(String title, String director, int playingTime, String comment) {
		super();
		this.title = title;
		this.director = director;
		this.playingTime = playingTime;
		this.comment = comment;
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}
	public void print() {
		// TODO Auto-generated method stub
		System.out.println("DVD:"+title+":"+director);
	}
	

}

Database

package dome;

import java.util.ArrayList;

public class Database {
	private ArrayList<CD> listCD = new ArrayList<CD>();
	private ArrayList<DVD> listDVD = new ArrayList<DVD>();
	public void add(CD cd)
	{
		listCD.add(cd);
	}
	
	public void add(DVD dvd)
	{
		listDVD.add(dvd);
	}
	
	public void list()
	{
		for(CD cd : listCD)
		{
			cd.print();
		}
		
		for(DVD dvd : listDVD)
		{
			dvd.print();
		}
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Database db = new Database();
		db.add(new CD("abc", "abc", 4, 60, "..."));
		db.add(new CD("def", "def", 4, 60, "..."));
		db.add(new DVD("xxx", "aaa", 60, "..."));
		db.list();
	}

}

怎么来改进这件事情？

继承

• 改进后的例子中 CD继承自Item DVD继承自Item
• CD和DVD称为Item的子类 继承了父类所以的东西
• 在改进后的例子中 Database与Item联系
• Item与CD和DVD联系

子类继承了什么？

• 子类继承了所有 但是父类的私有成员变量子类仍然不能访问

• 修饰符protected修饰的变量

  • 自己可以访问
  • 同一个包内的类可以访问
  • 子类可以访问

• 执行顺序

  • 类里面定义初始化先做 构造器后做

  • 父类的定义初始化构造器先做 子类的定义初始化和构造器后做

  • 子类在构造器初始化的时候会先调用父类的构造器 用super()可带参数

  • super()

    • 调用父类的构造器 可以重载
    • 不写 默认会调用调用无参数的super()

子类与父类的关系

• 子类继承了所有东西 如果有同名 在子类自己的函数中访问的是自己的那个变量 在父类函数中访问的是父类的变量

• 调用父类的函数super.print()

• 父类不到不能用protected的时候不要用protected

完整代码如下

以下代码在一个包内

CD

package dome;

public class CD extends Item{
	private String artist;
	private int numofTracks;
	
	public CD(String title, String artist, int numofTracks, int playingTime, String comment) {
		super(title,playingTime,false,comment);
		this.artist = artist;
		this.numofTracks = numofTracks;
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}
	public void print() {
		// TODO Auto-generated method stub
		System.out.print("CD:");
		super.print();
		System.out.println(":"+artist);
	}

}

DVD

package dome;

public class DVD extends Item{
	private String director;
	

	public DVD(String title, String director, int playingTime, String comment) {
		super(title,playingTime,false,comment);
		this.director = director;
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}
	public void print() {
		// TODO Auto-generated method stub
		System.out.print("DVD:");
		super.print();
		System.out.println(":"+director);
	}
	

}

Item

package dome;

public class Item {
	private String title;
	private int playingTime;
	private boolean gotIt = false;
	private String comment;
	
	public Item() {
		super();
	}
	
	public Item(String title) {
		super();
		this.title = title;
	}

	
	public Item(String title, int playingTime, boolean gotIt, String comment) {
		super();
		this.title = title;
		this.playingTime = playingTime;
		this.gotIt = gotIt;
		this.comment = comment;
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
	}

	public void print() {
		// TODO Auto-generated method stub
		System.out.print(title);
	}

}

Database

package dome;

import java.util.ArrayList;

public class Database {
//	private ArrayList<CD> listCD = new ArrayList<CD>();
//	private ArrayList<DVD> listDVD = new ArrayList<DVD>();
	private ArrayList<Item> listItem = new ArrayList<Item>();
	
//	public void add(CD cd)
//	{
//		listCD.add(cd);
//	}
//	
//	public void add(DVD dvd)
//	{
//		listDVD.add(dvd);
//	}
	
	public void add(Item item)
	{
		listItem.add(item);
	}
	
	public void list()
	{
//		for(CD cd : listCD)
//		{
//			cd.print();
//		}
//		
//		for(DVD dvd : listDVD)
//		{
//			dvd.print();
//		}
		
		for(Item item : listItem)
		{
			item.print();
		}
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Database db = new Database();
		db.add(new CD("abc", "abc", 4, 60, "..."));
		db.add(new CD("def", "def", 4, 60, "..."));
		db.add(new DVD("xxx", "aaa", 60, "..."));
		db.list();
	}

}

运行结果

CD:abc:abc
CD:def:def
DVD:xxx:aaa

多态

子类和类型

• 类定义了类型
• 子类定义了子类型
• 子类的对象可以被当作父类的对象来使用
  • 赋值给父类的变量
  • 传递给需要父类对象的函数
  • 放进存放父类对象的容器里

多态变量

• java的对象变量是多态的，它们能保存不止一种类型的对象

• 它们可以保存的是声明类型的对象，或声明类型的子类的对象

• 当把子类的对象赋给父类的变量的时候，就发生了向上造型

• 就像上一节例子中把CD和DVD类型的变量给了需要Item类型的容器or函数

• 多态是多种形态 Item有两种形态

  • 声明时的形态 也叫静态类型
  • 在程序运行中的形态 也叫动态类型

造型cast

• 子类的对象可以赋值给父类的变量

  • 注意

    java中不存在对象对对象的赋值

    只是管理者管理的东西发生改变 类似于指针

• 父类的对象不能直接赋值给子类的变量

  • Vechicle v;
    Car c = new Car();
    v = c; //可以
    c = v; //编译错误
    

• 可以用造型

  • c = (Car) v; 
    

    只有当v这个变量实际管理者是Car才行

  • 造型 括号围起来放在值的前面

  • 对象本身没有变化 所以不是类型转换

  • 运行时有机制来检查这样的转化是否合理

    • ClassCastException

向上造型

• 拿一个子类的对象，当作父类的对象来用
• 向上造型是默认的，不需要运算符
• 向上造型总是安全的

函数调用的绑定

• 当通过对象变量调用函数的时候，调用哪个函数这事件叫做绑定
  • 静态绑定：根据变量的声明类型来决定
  • 动态绑定：根据变量的动态类型来决定
  • java里默认动态绑定
• 在成员函数中调用其他成员函数也是通过this这个对象变量来调用的

覆盖override

• 子类和父类中存在名称和参数表完全相同的函数，这一对函数构成覆盖关系
• 通过父类的变量调用存在覆盖关系的函数时，会调用变量当时所管理的对象所属的类的函数

类型系统

Object类

• 在Java中所有的类都是继承自Object类
• Object类的函数
  • toString()
    • 程序需要对象的字符串的时候调用这个函数
  • equals()

添加新的媒体类型

• 修改代码可以扩展叫做可维护性
• 不修改代码就可以扩展叫做可扩展性
• VideoGame下面可以有子类 更深的继承

新增VideoGame只需要创建VideoGame 就可以在Database上添加

VideoGame

package dome;

public class VideoGame extends Item {
	private int numberOfPlayers;
	
	public VideoGame(String title, int playingTime, boolean gotIt, String comment,int number) {
		super(title, playingTime, gotIt, comment);
		// TODO Auto-generated constructor stub
		numberOfPlayers = number;
	}

	@Override
	public void print() {
		// TODO Auto-generated method stub
		System.out.print("VideoGame");
		super.print();
	}

	
	
}

Database

package dome;

import java.util.ArrayList;

public class Database {
	private ArrayList<Item> listItem = new ArrayList<Item>();
    
	public void add(Item item)
	{
		listItem.add(item);
	}
	
	public void list()
	{	
		for(Item item : listItem)
		{
			item.print();
		}
	}
	
	public static void main(String[] args) {
		Database db = new Database();
		db.add(new CD("abc", "abc", 4, 60, "..."));
		db.add(new CD("def", "def", 4, 60, "..."));
		db.add(new DVD("xxx", "aaa", 60, "..."));
		db.add(new VideoGame("ddd", 10, true, "...", 4));
		db.list();
	}

}

---

• 消除代码复制

• 增加可拓展性 代码写完需要维护

• 用封装降低耦合

  • Room类和Game类都有大量的代码和出口相关
  • 尤其是Game类中大量使用了Room类的成员变量
  • 类和类之间的关系叫做耦合
  • 耦合越低越好 保持距离是形成良好代码的关键

• 用接口实现聚合

  • 给Room类实现的新方法，把方向的细节彻底隐藏在Room类的内部了
  • 今后方向如何实现就和外部无关了
  • 用容器实现灵活性
    • Room的方向是用成员变量表示的，增加或减少方向就要改变代码
    • 如果用Hash表来表示方向，那么方向就不是“硬编码”的了

JAVA面向对象4.22

框架+数据提高可扩展性

• 命令的解析是否可以脱离if-else
• 定义一个Handler来处理命令
• 用Hash表来保存命令和Handler之间的关系

抽象

• 与具体相对
  • 表示一种概念而非实体
• 与细节相对
  • 表示一定程度上忽略细节而着眼大局

---

抽象

• 不能实例化

package shapes;

import java.awt.Graphics;

public abstract class Shape {

	/*  抽象函数 ————表达概念而无法实现具体代码的函数
	 *  抽象类    ————表达概念而无法构成实体的类
	 *  
	 *   具有抽象函数的类一定是抽象类
	 *   抽象类产生不了对象  但是可以定义变量
	 *   任何继承了抽象类的非抽象类对象都可以付给这个变量
	 *   抽象函数 没有  { }
	 * */
	
	/* 实现  抽象函数
	 * 继承自  抽象类的 子类  必须覆盖 父类的抽象函数  否则自己成为  抽象类
	 * 
	 * 
	 * */
	public abstract void draw(Graphics g);
	
}

细胞自动机

• 死亡：如果活着的邻居的数量<2或>3，则死亡

• 新生：如果正好有3个邻居或者，则新生

• 其他情况则保持原状

具体见代码

• 看代码的两种方式
  • 从main开始看 逐渐到每一个类
  • 从最小的类开始看

数据与表现分离

• 程序的业务逻辑与表现无关

  • 表现可以是图形的也可以是文本的
  • 表现可以是当地的也可以是远程的

• 责任驱动的设计

  • 将程序要实现的功能分配到合适的类/对象中去是设计中非常重要的一环

狐狸和兔子

• 狐狸和兔子都有年龄
• 当年龄到达上限后死亡
• 狐狸可以随机决定在周围得到兔子中吃掉一个
• 狐狸和兔子可以随机决定生一个小的，放在旁边的空的格子里

接口

• 接口是纯抽象类
  • 所有的成员函数都是抽象函数
  • 所有的成员变量都是public static final
• 接口规定了长什么样，但是不管里面有什么

实现接口

• 类可以用extens，接口用implements
• 类可以实现很多接口
• 接口可以继承接口，但不能继承类
• 接口不能实现接口

面向接口的编程方式

• 设计程序时先定义接口，再实现类
• 任何需要在函数间传入的一定是接口而不是具体的类
• 是java成功的关键之一，适合多人同时写一个大程序
• 也是Java被批评的要点之一，因为代码量膨胀起来很快

Cell和Field的关系

• Cell在Field中，但是Cell的很多操作需要Field的数据
• 方法一
  • 让每个Cell有一个Field的管理者（Cell知道Field）
• 方法二
  • 由外部第三方来建立两者之间的关系（Cell不知道Field）

讨论题0

• Cell要不要知道Field

讨论题1

• 用ArrayList来表示所有动物，每一步遍历这个列表而非整个Field，这样做是否更好？
• 这样就需要每个Animal知道自己在Field里的位置

JAVA面向对象5.18

MVC模式

JTable

• 用JTable类可以以表格的形式显示和编辑数据 JTable类的对象并不储存数据，它只是数据的表现 （数据与表现分离）

• JTable有个接口 自己创建的类需要重写接口的函数 JTable从类里面调用

MVC

• 数据、表现、控制三者分离，各负其责
  • M = Model（模型）
  • V = View（表现）
  • C = Control （控制）
• 模型：保存和维护数据，提供接口让外部修改数据，通知表现需要刷新
• 表现：从用户获得数据，根据数据画出表现
• 控制: 从用户得到输入，根据输入调整数据

异常处理

		try {
			// 可能发生异常的代码
		} catch(Type1 id1) {
			// 处理Type1异常的代码
		} catch(Type2 id2) {
			// 处理Type2异常的代码
		} catch(Type3 id3) {
			// 处理Type3异常的代码
		}

捉到了做什么？

• 拿到异常对象之后
  • String getMessage();
  • e.toString();
  • void printStackTrace();
• 捕捉到异常回不去了，具体的处理逻辑则取决于你的业务逻辑需要

再度抛出

catch(Exception e) {
	System.err.println("An exception was thrown");
	throw e;
	}

• 如果在这个层面上需要处理，但是不能做最终决定