20145224-陈颢文 《Java程序设计》第四周学习总结
教材学习内容总结
第六章 继承与多态
·继承就是面向对象中，子类继承父类，避免重复的行为定义。重复再程序设计上是非常不好的信号，因为其大大增加了修改维护程序的成本。要避免重复，就可以把相同的代码程序提升为父类：
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 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("魔法治疗");
}
}
·以下程序，虽然没有定义getName（）、getLevel（）、getBlood（）但从Role中继承就可以直接使用。
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());
}
}
·若是希望使用单一接口操作多种类型的对象，那么就可以运用多态来完成：
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);
showBlood(swordsMan);
showBlood(swordsMan);
}
static void showBlood(Role role) {
System.out.printf("%s 血量 %d%n", role.getName(), role.getBlood());
}
}
·重新定义是指在继承父类之后，定义与父类中相同的方法部署，但执行内容不同。
首先要在Role中重新定义fight（）的实际意义
public class Role {
private String name;
private int level;
private int blood;
public void fight(){}
···
其次在主程序中调用fight
···
drawFight(swordsMan);
drawFight(magician);
}
static void drawFight(Role role) {
System.out.print(role.getName());
role.fight();
···
·如果某方法区块中真的没有任何程序代码操作，可以使用abstract表示该方法为抽象方法，不用撰写{ }区块，直接“；”结束即可。
·含有抽象方法的类，一定要在class前标示abstract；子类如果继承抽象类，意识继续标示abstract，另一种就是操作方法。
·protect成员：在Role中name。level.blood被定义为private，无法直接在子类中存取，因此可让子类直接定义为protected类型。被声明protected成员之后，相同包中的类可以直接存取，不同包的类可以在继承后的子类直接存取。
定义如下：
public class Role {
protected String name;
protected int level;
protected int blood;
···
·如果想取得父类中的方法定义，可以在调用方法前，加上super关键字；
·重新定义方法要注意，对于父类中的方法权限，只能扩大不能缩小。若原来成员public，子类中重新定义时不可为private或protected。
·如果累有继承关系，在创建子类实例后，会先进行父类定义的初始流程，再进行子类中定义的初始流程。
·构造函数可以重载，父类中可重载多个构造函数，如果子类构造函数中没有制定执行父类中那个构造函数，会默认调用父类中无参数构造函数。
·final：在指定变量值后，如果不想再改变变量值，可以在声明变量时加上final。
·如果对象数据成员被声明为final，一定要有对该数据成员指定值的动作！
·class前也可以加上final关键字，表明这个类是最后一个类，不会有子类，不能继承。
·子类只能继承一个父类，如果定义类时没有使用extends关键字指定继承任何类，那一定是继承java.lang.Object。
·定义ArrayList类，可以不限长度地收集对象。
以下实例时将收集访客名称转为大写后显示：
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.print(role.getName());
role.fight();
}
}
·toString的定义代码为：
public String toString（）{
return getClass（）.getName（）+ “@”+Integer.toHexString（hashCode（））；
}
·equals（）的定义代码为：
public boolen equal（Object obj）{
return （this==obj）；
}
·创建对象会占据内存，如果程序执行流程中已无法再使用某个对象，该对象就会被当作垃圾，由GC认定垃圾对象然后垃圾收集释放。
在用户输入、显示结果等环节未定，也可以编写代码片段，运用抽象方法：
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();
}
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.println(text);
}
@Override
public int nextlnt() {
return scanner.nextlnt();
}
}
public static void main(String[] args) {
GuessGame game = new ConsoleGame();
game.go();
}
}
·区别于继承，接口定义的是行为，可以使用interface关键字定义。
·以下程序代码定义了接口，可以用于定义行为但不定义操作
public interface Swimmer {
public abstract void swim();
}
·对接口中定义的方法有两种：
1.操作接口中定义；
2.再度将该方法标示为abstract；
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);
}
}
·Submarine操作了Swimmer，但没有继承Fish。
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);
}
}
·多态语法的判断：判断“右边是不是拥有左边的行为”或者“右边对象是不是操作了左边接口”
·只要操作接口对象一直，都可以使用doSwim的方法，提高了系统的可维护性。
程序范例如下：
public class Ocean {
public static void main(String[] args) {
doSwim(new Ugly("尼莫"));
doSwim(new Shark("兰尼"));
doSwim(new Human("贾斯汀"));
doSwim(new Submarine("黄色一号"));
}
static void doSwim(Swimmer swimmer){
swimmer.swim();
}
}
·为了满足用户多需求，例如满足有的东西即会飞又会游泳，可以使用interface定义Flyer接口
public interface Flyer {
public abstract void fly();
}
·定义Seaplane操作Swimmer与Flyer接口；类可以继承，并能操作某些接口，因此它即能飞又能又能游；
public class Seaplane implements Swimmer,Flyer {
private String name;
public Seaplane(String name){
this.name = name;
}
@Override
public void fly(){
System.out.printf("海上飞机 %s 在飞 %n",name);
}
@Override
public void swim(){
System.out.printf("海上飞机%s 航行海绵%n",name);
}
}
·定义游泳选手是一种人，同时拥有Swimmer的行为
public class Human {
protected String name;
public Human(String name){
this.name = name;
}
public String getName(){
return name;
}
}
public class SwimPlayer extends Human implements Swimmer {
public SwimPlayer(String name){
super(name);
}
@Override
public void swim(){
System.out.printf("游泳选手 %s 游泳 %n",name );
}
}
·接口可以继承自另一个接口，也就是继承父接口行为，再在子接口中额外定义行为。
public interface Diver extends Swimmer {
public abstract void dive();
}
public class Boat implements Swimmer {
protected String name;
public Boat(String name){
this.name = name;
}
@Override
public void swim(){
System.out.printf("船在水面 %s 航行 %n", name);
}
}
·定义潜水艇即在浅海游泳，也可以在深海潜行
public class Submarine extends Boat implements Diver {
public Submarine(String name){
super(name);
}
@Override
public void dive(){
System.out.printf("潜水艇 %s 潜行%n",name);
}
}
·在java中可使用interface来定义抽象的行为与外观，接口中的方法可声明为public abstract；
例如：
public interface Swimmer {
public abstract void swim();
}
·接口中的方法没有操作时，必须是公开且抽象的。
·枚举常数范例：
public interface Action {
public static final int STOP = 0;
public static final int RIGHT = 1;
public static final int LIFT = 2;
public static final int UP = 3;
public static final int DOWN = 4;
}
·在枚举常数时要使用“=”指定值，否则会编译出错。
·Some与Other定义的execute（）
1.表示不同行为，Service有两个不同的操作方法，Some与Other在名称上有所不同。
2.表示相同行为，可以定义一个父接口，当定义execute（）方法，而some与other继承该接口，各自定义自己的doSome（）与doOther（）方法。
·撰写java时有临时某个类或操作某个接口并建立实例，因为只用一次所以不需要为这些类定义名称，此时可以运用匿名类
语法：
new 父类（）|接口（）{
//类本体操作
}；
·操作接口范例；
Some some = new Some（） { //操作Some接口并直接产生实例
public void doService（）{
System.out.println（“do something”）;
}
};
接口应用举例
·建立Client对象封装信息
public class Client {
public final String ip;
public final String name;
public Client(String ip,String name){
this.ip = ip;
this.name = name;
}
}
·若程序其他部分希望在Client加入或移除时可以收到通知，可以将Client加入或移除的信息包装为ClientEvent；
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 ClientQuene {
private ArrayList clients = new ArrayList();
private ArrayList listeners = new ArrayList();
public void addClientListener(ClientListener listener){
listeners.add(listener);
}
public void aVoid(Client client){
clients.add(client);
ClientEvent event = new ClientEvent(client);
for(int i=0;i<listeners.size();i++){
ClientListener listener = (ClientListener)listeners.get(i);
listener.clientAdded( event);
}
}
public void remove(Client client){
clients.remove(client);
ClientEvent event = new ClientEvent(client);
for (int i=0;i< listeners.size();i++){
ClientListener listener = (ClientListener) listeners.get(i);
listener.clientRemoved(event);
}
}
}
教材学习中的问题和解决过程
一开始我还是照着课本上的代码不停地码上去，结果发现到了第七章，有的代码就编译不通过，后来就只能把课本看了一遍再修改代码了。这个周末本来打算把每个章节课后题都编一下，但由于要备考计算机二级，就只编写了一下两个：
public class gongyingzi1000495 {
public static void main(String[] args) {
int m = 1000;
int n = 495;
while (true){
m = m % n;
if (m == 0){
System.out.println(n);
break;
}
n = n % m;
if (n == 0){
System.out.println(m);
break;
}
}
}
}
public class Armstrong {
public static void main(String[] args) {
for (int i = 1;i <= 9;i++){
for (int j = 1;j <= 9;j++){
for(int k = 1;k <= 9;k++){
if (i*i*i + j*j*j + k*k*k == i*100 + j*10 + k){
System.out.println(i*100 + j*10 + k);
}
}
}
}
}
}
本周代码托管截图
学习进度条
| 代码行数（新增/累积） | 博客量（新增/累积） | 学习时间（新增/累积） | 重要成长 | |
|---|---|---|---|---|
| 目标 | 4500行 | 30篇 | 350小时 | |
| 第一周 | 150/150 | 1/1 | 15/15 | |
| 第二周 | 200/350 | 1/2 | 20/35 | |
| 第三周 | 300/650 | 1/3 | 25/60 | |
| 第四周 | 350/1000 | 1/4 | 30/90 |