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

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);
}
}
}
}
}
}

本周代码托管截图

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

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

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

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

学习进度条

代码行数(新增/累积) 博客量(新增/累积) 学习时间(新增/累积) 重要成长
目标 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

参考资料

上一篇:python_如何派生内置不可变类型并修改实例化行为


下一篇:20155304 2016-2017-2 《Java程序设计》第四周学习总结