20145312 《Java程序设计》第四周学习总结
20145312 《Java程序设计》第四周学习总结
学习笔记
Chapter 6
6.1何为继承
1.定义：面向对象中子类继承父类，避免重复的行为定义。
6.1.1 继承共同行为
1.以一款RPG游戏为例。
代码如下：
public class Role {
private String name;
private int level;
private int blood;
public int getBlood(){
return blood;
}
public void setBlood(int blood){
this.blood=blood;
}
public int getLevel(){
return level;
}
public void setLevel(int level){
this.level =level ;
}
public String getName(){
return name ;
}
public void setName(String name){
this.name=name;
}
}
public class Magician extends Role {
public void fight(){
System.out.println("魔法攻击");
}
public void cure(){
System.out.println("魔法治疗");
}
public class SwordsMan extends Role {
public void fight(){
System.out.println("挥剑攻击");
}
}
public class RPG {
public static void main(String[] args){
demoSwordsMan();
demoMagician();
}
static void demoSwordsMan(){
SwordsMan swordsMan=new SwordsMan();
swordsMan.setName("Justin");
swordsMan.setLevel(1);
swordsMan.setBlood(200);
System.out.printf("剑士：(%s,%d,%d)%n",swordsMan.getName(),swordsMan.getLevel(),swordsMan.getBlood());
}
static void demoMagician(){
Magician magician =new Magician() ;
magician .setName("Monica");
magician .setLevel(1);
magician .setBlood(100);
System.out.printf("魔法师：(%s,%d,%d)%n",magician .getName(),magician .getLevel(),magician .getBlood());
}
}
结果如下：
剑士：(Justin,1,200)
魔法师：(Monica,1,100)
2.关键字extends表示Swordsman会扩充Role的行为，也就是继承Role的行为。
3.Magician继承Role的行为，并扩充了Role原本没有的fight()与cure()行为。
6.1.2 多态与is-a
1.继承还有一个重要的关系，子类与父类之间会有is-a关系。
代码如下：
public class RPG {
public static void main(String[] args){
Game2. SwordsMan swordsMan=new SwordsMan();
swordsMan.setName("Justin");
swordsMan.setLevel(1);
swordsMan.setBlood(200);
Magician magician =new Magician() ;
magician .setName("Monica");
magician .setLevel(1);
magician .setBlood(100);
showBlood(swordsMan);
showBlood(magician );
}
static void showBlood(Role role ){
System.out.printf("%s血量%d%n",role.getName(),role.getBlood());
}
}
结果如下：
Justin血量200
Monica血量100
2.编译程序会检查父子类间“是一种“关系。
3.使用is-a关系，就可以判断何时编译失败，何时编译成功。
4.还可以使用重载方法的运用。
6.1.3 重新定义行为
- 代码如下：
public class Role {
private String name;
private int level;
private int blood;
public int getBlood(){
return blood;
}
public void setBlood(int blood){
this.blood=blood;
}
public int getLevel(){
return level;
}
public void setLevel(int level){
this.level =level ;
}
public String getName(){
return name ;
}
public void setName(String name){
this.name=name;
}
public void fight(){
}
}
public class SwordsMan extends Role {
public void fight(){
System.out.println("挥剑攻击");
}
}
public class Magician extends Role {
public void fight(){
System.out.println("魔法攻击");
}
public void cure(){
System.out.println("魔法治疗");
}
}
public class RPG {
public static void main(String[] args){
SwordsMan swordsMan=new SwordsMan();
swordsMan.setName("Justin");
swordsMan.setLevel(1);
swordsMan.setBlood(200);
Magician magician =new Magician() ;
magician .setName("Monica");
magician .setLevel(1);
magician .setBlood(100);
drawFight(swordsMan);
drawFight(magician );
}
static void drawFight(Role role){
System.out.printf(role.getName());
role.fight();
}
}
结果如下：
Justin挥剑攻击
Monica魔法攻击
2.操作接口相同，操作方法内容不同，可以将fight()方法提升至Role。
3.在JDK5之后支持标注，其中一个内建的标准标注是@override。如果在子类中某个方法前标注@override，表示要求编译程序检查。
6.1.4 抽象方法、抽象类
1.定义：如果某方法区块中实际没有程序代码操作，可以使用abstract标示该方法为抽象方法。
2.这类方法不用撰写{ }区块，直接“；“结束即可。
3.代码如下：
public abstract class Role {
private String name;
private int level;
private int blood;
public int getBlood(){
return blood;
}
public void setBlood(int blood){
this.blood=blood;
}
public int getLevel(){
return level;
}
public void setLevel(int level){
this.level =level ;
}
public String getName(){
return name ;
}
public void setName(String name){
this.name=name;
}
public abstract void fight();
}
结果如下：
Justin挥剑攻击
Monica魔法攻击
4.Java规定内含抽象方法的类一定要在class前标示abstract。
6.2 继承语法细节
6.2.1 protected成员
1.显示角色细节，并只想子类可以直接存取类的话，可以定义它们为protected。
2.代码如下：
public abstract class Role {
protected String name;
protected int level;
protected int blood;
public int getBlood(){
return blood;
}
public void setBlood(int blood){
this.blood=blood;
}
public int getLevel(){
return level;
}
public void setLevel(int level){
this.level =level ;
}
public String getName(){
return name ;
}
public void setName(String name){
this.name=name;
}
public abstract void fight();
}
public class SwordsMan extends Role {
public void fight(){
System.out.println("挥剑攻击");
}
public String toString(){
return String.format("剑士（%s,%d,%d）",this.name,this.level,this.blood);
}
}
public class Magician extends Role {
public void fight(){
System.out.println("魔法攻击");
}
public void cure(){
System.out.println("魔法治疗");
}
public String toString() {
return String.format("魔法师（%s,%d,%d）", this.name, this.level, this.blood);
}
}
结果如下：
Justin挥剑攻击
Monica魔法攻击
6.2.2 重新定义的细节
- 代码如下：
public abstract class Role {
protected String name;
protected int level;
protected int blood;
public int getBlood(){
return blood;
}
public void setBlood(int blood){
this.blood=blood;
}
public int getLevel(){
return level;
}
public void setLevel(int level){
this.level =level ;
}
public String getName(){
return name ;
}
public void setName(String name){
this.name=name;
}
public abstract void fight();
public String toString() {
return String.format("（%s,%d,%d）", this.name, this.level, this.blood);
}
}
public class SwordsMan extends Role {
public void fight(){
System.out.println("挥剑攻击");
}
@Override
public String toString(){
return "剑士"+super.toString() ;
}
}
public class Magician extends Role {
public void fight(){
System.out.println("魔法攻击");
}
public void cure(){
System.out.println("魔法治疗");
}
@Override
public String toString() {
return "魔法师"+super.toString();
}
}
结果如下：
Justin挥剑攻击
Monica魔法攻击
2.如果Role中本身定义toString()方法，可以在执行父类中的方法的前后做点加工。
6.2.3 final关键字
1.如果在class前使用final关键字定义，那么表示这个类是最后一个，不能被继承。
6.2.4 Java.lang.Object
1.在Java中，子类只能继承一个父类，如果定义类时没有使用extends关键字指定继承任何类。
2.代码如下：
import java.util.Arrays;
public class ArrayList {
private Object[] List;
private int next;
public ArrayList(int capacity){
List=new Object[capacity];
}
public ArrayList(){
this(16);
}
public void add(Object o){
if(next==List.length){
List=Arrays.copyOf(List,List.length*2);
}
List[next++]=o;
}
public Object get(int index){
return List[index];
}
public int size(){
return next;
}
}
import java.util.Scanner;
import static java.lang.System.out;
public class Guest {
public static void main(String[] args){
ArrayList names=new ArrayList();
collectNameTo(names);
out.println("访客名单:");
printUpperCase(names);
}
static void collectNameTo(ArrayList names){
Scanner console=new Scanner(System.in);
while(true){
out.print("访客名单：");
String name=console.nextLine();
if(name.equals("quit")){
break;
}
names.add(name);
}
}
static void printUpperCase(ArrayList names){
for(int i=0;i<names.size();i++){
String name=(String)names.get(i);
out.println(name.toUpperCase() );
}
}
}
结果如下：
访客名单：张三
访客名单：李四
访客名单：王二麻子
访客名单：quit
访客名单:
张三
李四
王二麻子
3.自定义的ArrayList类，内部使用Object数组来收集对象。
4.如果使用无参数构造函数，则默认容量为16。
5.重新定义toString()
6.重新定义equals()
6.2.5 再看抽象类
1.代码如下：
import java.util.Scanner;
public class ConsoleGame extends GuessGame {
private Scanner scanner=new Scanner(System.in);
@Override
public void print(String text){
System.out.print(text);
}
@Override
public void println(String text){
System.out.print(text);
}
@Override
public int nextInt(){
return scanner.nextInt();
}
}
public class Guess {
public static void main(String[] args){
GuessGame game=new ConsoleGame();
game.go();
}
}
public abstract class GuessGame {
public void go(){
int number=(int)(Math.random()*10);
int guess;
do{
print("输入数字：");
guess=nextInt();
}while(guess!=number);
println("猜中了");
}
public void println(String text){
print(text+"\n");
}
public abstract void print(String text);
public abstract int nextInt();
}
结果如下：
输入数字：2
猜中了
Chapter 7 接口与多态
7.1 何谓接口
7.1.1接口定义行为
1.接口的出现将“多继承”通过另一种形式体现出来，即 “多实现”。
2.接口是程序的功能扩展。
3.接口可以用来多实现。
4.类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。
5.接口与接口之间可以有继承关系。
6.代码如下：
public class Anemonefish extends Fish{
public Anemonefish(String name){
super(name);
}
@Override
public void swim();{
System.out.printf("小丑鱼 %s 游泳%n",name);
}
}
public class Shark extends Fish{
public Shark(String name){
super(name);
}
@Override
public void swim();{
System.out.printf("鲨鱼 %s 游泳%n",name);
}
}
public interface Swimmer
{
public abstract void swim();
}
public abstract class Fish implements Swimmer{
protected String name;
public Fish(String name){
this.name=name;
}
public String getName()
{
return name;
}
@Override
public abstract void swim();
}
public class Human implements Swimmer {
private String name;
public Human(String name){
this.name=name;
}
public String getName()
{
return name;
}
@Override
public void swim();{
System.out.printf("人类 %s 游泳%n",name);
}
}
public class Submarine implements Swimmer{
private String name;
public Submarine(String name){
this.name=name;
}
public String getName()
{
return name;
}
@Override
public void swim();{
System.out.printf("潜水艇 %s 潜行%n",name);
}
}
7.1.2 行为的多态
1.代码如下：
public class Ocean{
public static void main(String[] args)
{
doSwim(new Anemonsfish("尼莫"));
doSwim(new Shark("兰尼"));
doSwim(new Human("贾斯汀"));
doSwim(new Submarine("黄色一号"));
}
static void doSwim(Swimmer swimmer){
swimmer.swim();
}
}
结果如下：
小丑鱼 尼莫 游泳
鲨鱼 兰尼 游泳
人类 贾斯汀 游泳
潜水艇 黄色一号 潜行
7.1.3解决需求变化
1.写程序时，如果增加新的需求，可使原有的程序无需修改，只针对新需求撰写程序。
2.代码如下：
public interface Flyer{
public abstract void fly();
}
public class FlyingFish extends Fish implements Flyer{
public FlyingFish(String name){
super(name);
}
@Override
public void swim(){
Systen.out.println("飞鱼游泳");
}
@Override
public void fly(){
Systen.out.println("飞鱼会飞");
}
}
public class Airplane implements Flyer{
protected String name;
public Airplane(String name){
this.name=name;
}
@Override
public void fly();{
Systen.out.printf("飞机 %s 在飞%n",name);
}
}
public class Ocean2{
public static void main(String[] args)
{
doSwim(new Seaplane("空军零号"));
doSwim(new FlyingFish("甚平"));
}
static void doSwim(Swimmer swimmer){
swimmer.swim();
}
}
结果如下：
小丑鱼 尼莫 游泳
鲨鱼 兰尼 游泳
人类 贾斯汀 游泳
潜水艇 黄色一号 潜行
海上飞机 空军零号
飞鱼游泳
7.2 接口语法细节
7.2.1.接口的默认
1.在java中，可使用interface来定义抽象的行为与外观，如接口中的方法可声明为public abstract。
2.代码如下：
public interface Action{
public static final int STOP=0;
public static final int RIGHT=1;
public static final int LEFT=2;
public static final int UP=3;
public static final int DOWN=4;
}
import static java.lang.System.out;
public class Game{
public static void main(String[] args){
play(Action.RIGHT);
play(Action.UP);
}
public static void play(int action){
switch(action){
case Action.STOP:
out.println("播放停止动画");
break;
case Action.RIGHT:
out.println("播放向右动画");
break;
case Action.LEFT:
out.println("播放向左动画");
break;
case Action.UP:
out.println("播放向上动画");
break;
case Action.DOWN:
out.println("播放向下动画");
break;
default:
out.println("不支持此动作");
}
}
}
结果如下：
播放向右动画
播放向上动画
7.2.2 匿名内部类：就是内部类的简化写法。
1.前提：内部类可以继承或实现一个外部类或者接口。
2格式为：new 外部类名或者接口名(){覆盖类或者接口中的代码， ( 也可以自定义内容。)
3代码如下：
public class Client{
public final String ip;
public final String name;
public Client(String ip,String name){
this.ip=ip;
this.name=name;
}
}
public class ClientEvent{
private Client client;
public ClientEvent(Client client){
this.client=client;
}
public String getName(){
return client.name;
}
public String getIp(){
return client.ip;
}
}
public interface ClientListener{
void clientAdded(ClientEvent event);
void clientRemoved(ClientEvent event);
}
import java.util.ArrayList;
public class ClientQueue{
private ArrayList clients=new ArrayList();
private ArrayList listeners=new ArrayList();
public void addClientListener(ClientListener listener){
listeners.add(listener);
}
public void add(Client client){
clients.add(client);
ClientEvent event=new ClientEvent(client);
for(int i=0;i<listeners.size();i++){
ClientListener listener=(ClientListener) listener.get(i);
listener.client.Added(event);
}
}
public void remove(Client client){
client.remove(client);
ClientEvent event=new ClientEvent(client);
for(int i=0;i<listeners.size();i++){
ClientListener listener=(ClientListener) listener.get(i);
listener.client.Removed(event);
}
}
}
public class Multichat{
public static void main(String[] args){
Client c1=new Client("127.0.0.1","Caterpillar");
Client c1=new Client("192.168.0.2","Justin");
ClientQueue queue=new ClientQueue();
queue.addClientListener(new ClientListener(){
@Override
public void clientAdded(ClientEvent event){
System.out.printf("%s cong %s lianji%n",
event.getGame(),event.getIp());
}
@Override
public void clientRemoved(ClientEvent event){
System.out.printf("%s cong %s tuoji%n",
event.getGame(),event.getIp());
}
});
queue.add(c1);
queue.add(c2);
queue.remove(c1);
queue.remove(c1);
}
}
结果如下：
Caterpilllar 从 127.0.0.1 联机
Justin 从 192.168.0.2 联机
Caterpilllar 从 127.0.0.1 脱机
Justin 从 192.168.0.2 脱机
7.2.3 使用enum枚举常数
1.代码如下：
public enum Action2{
STOP,RIGHT,LEFT,UP,DOWN
}
import static java.lang.System.out;
public class Game2{
public static void main(String[] args){
play(Action.RIGHT);
play(Action.UP);
}
public static void play(Action action){
switch(action){
case STOP:
out.println("播放停止动画");
break;
case RIGHT:
out.println("播放向右动画");
break;
case LEFT:
out.println("播放向左动画");
break;
case UP:
out.println("播放向上动画");
break;
case DOWN:
out.println("播放向下动画");
break;
}
}
}
结果如下：
播放向右动画
播放向上动画
代码调试中的问题和解决过程
问题：在打第六章代码Game2~Game6时有相同的class就直接复制到package里，结果运行出错。
解决过程：在仔细查看代码后，我发现在主程序前有import Role等字样，于是我就改为import Role1等，在运行就编译通过了。
其他（感悟、思考等，可选）
这周的Java学习，我们开始自己编写简单的小游戏了，这引起了我极大的兴趣，所以在这周6、7章的学习中，我不再觉得打代码是件枯燥的事情，反而积极主动敲代码，看到自己编写的小游戏可以运行，油然而生了一种自豪感。由此我想到，兴趣是最好的老师，有了兴趣使然，我就会主动学习，从中获取更多的知识得到进步。
学习进度条
代码托管截图
