20145231 《Java程序设计》第4周学习总结

教材学习内容总结

基本概念：

•何谓继承

继承：面向对象中，子类继承父类，避免重复定义的共同行为；

extends关键字：在继承父类的程序代码基础上，补充定义新的程序代码，扩充其原本没有的行为；

继承的好处：避免重复的同时，若是要对相应的数据成员名称做修改，只需要在父类中修改即可；

•多态与is-a

is-a关系：子类只能继承一个父类，即子类“是一种”父类，可用来判断如下代码片段：

Role role1 = new Swordsman();

Swordsman swordsman = new Role();

用is-a关系判断是否能编译通过即右边类是不是左边类的子类；

多态：使用单一接口操作多种类型对象，不需要用重载的方式写很多个方法，具有更高的维护性；

•重新定义行为

重新定义：在继承父类之后，定义与父类中相同的方法部署，但执行内容不同；在重新定义父类中某个方法时，子类必须撰写与父类方法中相同的签署；

•抽象方法抽象类

abstract关键字：在某方法区块中没有任何程序代码操作时，使用abstract标示该方法为抽象方法（该方法不用撰写{}区块，直接；结束即可）；

带有abstract关键字的类为定义不完整的抽象类，不能创建实例；

继承抽象类：1、继续标示该方法为abstract；2、操作抽象方法；否则编译报错；

•继承语法细节

protected成员：被声明为protected的成员，相同包中的类可以直接存取，不同包中的类可以在继承后的子类直接存取；

重新定义的细节：重新定义方法时，若只是希望在父类中方法前后做点加工，可在父类中直接添加，想取得父类中的方法定义，只需在调用前加上super关键字；（使用super关键字调用的父类方法不能定义为private，同时，重新定义方法时，对于父类中的方法权限只能扩大不能缩小）

JDK5之后，如果返回类型是父类中方法返回类型的子类，可通过编译；

构造函数：如果子类构造函数中没有指定调用父类中那个构造函数，默认会调用父类中无参数构造函数；

final关键字:class前使用final，表示这是最后一个类不会再有子类；定义方法为final表示最后一次定义方法；

java.lang.Object:定义类时若没有extends关键字，那一定是继承java.lang.Object；（顶层父类，Object上定义的方法所有对象都继承下来了，只要没有定义为final，都可以重新定义）

tostring()、equals()都是Object类定义的方法，返回值类型分别为字符串型和布尔型；

instanceof运算符:判断对象是否由某个类创建，左操作数是对象，右操作数是类，只要左操作数是右操作数的子类型，返回结果就为true；

垃圾收集：程序执行流程中无法再使用某个对象，该对象就是徒耗内存的垃圾，就会被回收；

•何谓接口

接口：可用于定义行为但不操作（表示拥有行为，是多重继承的一种方式），类要操作接口，就必须有implements关键字(为了生成与特定接口相符合的类)；

接口中定义的方法的处理方式：操作接口中定义的方法、再度将其标示为abstract；

•接口的语法细节

接口的默认：接口中的方法没有操作时，一定得是公开且抽象（interface关键字：定义抽象行为与外观）；

枚举常数：为了在维护程序时使程序清晰；

匿名内部类：对于只使用一次的继承某个类的子类或接口操作类，不需为这些类定义名称；

教材学习中的问题和解决过程

问题一：private成员不能被继承？

解决过程：private成员会被继承，只不过子类无法直接存取，必须通过父类提出的访问方法来存取；

问题二：如何判断一段程序是否是合法的多态语法？

Swimmer swimmer = new Shark();
Swimmer swimmer = new Human();
Swimmer swimmer = new Submarine();\\编译通过

解决过程：判断右边是否拥有左边的行为，即右边对象是否操作了左边接口；

Shark shark = swimmer;\\编译失败

因为有Swimmer行为的不一定是shark实例，此时需要加上扮演语法：

Shark shark = (Shark) swimmer;

即执行时参考shark实例，让其扮演shark（实际参考对象与扮演对象要一致，否则报错）；

问题三：类可以操作两个以上的接口，如果有两个接口。都定义了某方法，操作两个接口的类会怎样？

interface Action{void execute();
}
interface Some extends Action{void doSome();
}
interface Other extends Action{void doOther();
}
public class Service implements Some,Other{@Overridepublic void execute(){System.out.println("execute()");}@Overridepublic void doSome(){System.out.println("doSome()");}@Overridepublic void doOther(){System.out.println("doOther()");}
}

解决过程：以上代码在编译时可以通过，但是应该思考不同接口定义的方法是否表示不同行为，若表示不同行为，那么类在操作时，应该有不同的方法操作，，相对应的方法名称就要不同，这样类在操作时才可以有两个不同的方法操作；如果表示相同的行为，可以通过定义一个父接口，在当中定义该方法，而其他两个接口继承该接口，各自定义自己的doSome(),doOther()方法；

问题四：enum定义枚举常数到底是怎么回事？

public final class Action extends Enum{
...private Action(String s,int i){super(s,i);}public static final Action STOP;public static final Action RIGHT;public static final Action LEFT;public static final Action UP;public static final Action DOWN;...static{STOP = new Action("STOP",0);RIGHT = new Action("RIGHT",1);LEFT = new Action("LEFT",2);UP = new Action("UP"3);DOWN = new Action("DOWN",4);...}}\\Enum枚举常数的部分细节

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(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;}}
}\\使用Action类的例子

解决过程：enum定义了特殊的类，继承自java.lang.Enum，由编译程序自己处理，enum中列举的常数，实际上是public static final，且为枚举类型实例，无法撰写程序直接实例化枚举类型，因为构造函数权限设定为private，只有类中才可以实例化。

代码调试中的问题和解决过程

接口定义行为：

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;}@Overridepublic 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;}@Overridepublic void swim(){System.out.printf("潜水艇 %s 潜行%n",name);}
}

行为的多态：

public class Ocean {public static void main(String[] args) {doSwim(new Anemonfish("尼莫"));doSwim(new Shark("兰尼"));doSwim(new Human("贾斯丁"));}static void doSwim(Swimmer swimmer){swimmer.swim();}}

public class Seaplane implements Swimmer,Flyer {private String name;public Seaplane(String name){this.name = name;}@Overridepublic void fly(){System.out.printf("海上飞机 %s 在飞%n",name);}@Overridepublic void swim(){System.out.printf("海上飞机 %s 航行海面%n");}
}

public class FlyingFish extends Fish implements Flyer {public FlyingFish(String name){super(name);}@Overridepublic void swim(){System.out.printf("飞鱼游泳");}@Overridepublic void fly(){System.out.println("飞鱼会飞");}
}

public class Swimplayer extends Human implements Swimmer {public Swimplayer(String name){super(name);}@Overridepublic void swim() {System.out.printf("游泳选手 %s 游泳%n", name);}
}\\其中要修改之前定义的Human类的字符串变量name的权限为protected

public class Airplane implements Flyer {protected String name;public Airplane(String name){this.name = name;}@Overridepublic void fly(){System.out.printf("飞机 %s 在飞%n",name);}
}

public class Seaplane extends Airplane implements Swimmer {private String name;{super(name);}@Overridepublic void fly(){System.out.print("海上");super.fly();}@Overridepublic void swim(){System.out.printf("海上飞机 %s 航行海面%n",name);}
}

public class Helicopter extends Airplane { public Helicopter(String name){ super(name); } @Override public void fly(){ System.out.printf("飞机 %s 在飞%n",name); } }

public class Boat implements Swimmer {protected String name;public Boat(String name){this.name = name;}@Overridepublic void swim(){System.out.printf("船在水面 %s 航行%n",name);}
}\\继承父接口行为

接口的默认：

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 Game2 {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("不支持此动作");}}
}

关于使用匿名内部类的实例：

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 ClientListner{void clientAdd(ClientEvent event);void clientAdd(ClientEvent event);
}

public class MultiChat {public static void main(String[] args) {Client c1= new Client("127.0.0.1","Caterpillar");Client c2= new Client("192.168.0.2","Justin");ClientQueue queue = new ClientQueue();queue.addClientListener(new ClientListener(){@Overridepublic void clientAdded(clientEvent event){System.out.printf("%s 从 %s 联机%n",event.getName(),event.getIp());}@Overridepublic void clientRemoved(clientEvent event){System.out.printf("%s 从 %s 脱机%n",event.getName(),event.getIp());}});queue.add(c1);queue.add(c2);queue.remove(c1);queue.remove(c2);}
}

import java.util.ArrayListpublic class ClientQueue {private ArrayList clients = new ArrayList();private ArrayList listeners = new ArrayList();public void addClientListener(ClientListner 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++){ClientListner listner = (ClientListner) listeners.get(i);listner.clientAdded(event);}}public void remove(Client client){clients.remove(client);ClientEvent event = new ClientEvent(client);for(int i = 0;i<listeners.size();i++){ClientListner listner = (ClientListner)listeners.get(i);listner.clientremoved(event);}}
}

以上均为可运行代码，不作运行结果赘述。

本周代码托管截图

其他（感悟、思考等，可选）

在本周的学习过程中，产生了很多的疑问，通过不断翻看已经学习过的章节复习回顾以加强对新知识的理解，同时我觉得本书最大的一个优点是，在提出每一个新的概念之前都会举一个较为具体的例子，附有代码，列出其不足之处，基于改进的基础上提出新内容，继承、多态、接口的提出都如此，通过敲代码，就能感受到区别以及后者的优势，但是遇到最大的问题也出现在这些代码上，片段式的代码，在一些语法细节上不便于理解，调试时也出现很多问题，不知道完整的代码形式，只能凭着对前面几章的理解自己尝试，在此过程中发现了之前自己理解上的一些偏差，加深了对概念的认识，也算是本周的一个收获吧。继续加油，路漫漫其修远兮，吾将上下而求索。

学习进度条

参考资料

• Java学习笔记(第8版)
• 《Java学习笔记(第8版)》学习指导
• ...