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

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

6.1.1 继承共同行为

•定义：继承基本上就是避免多个类间重复定义共同行为。

•优点：1.提高了代码的复用性。2.让类与类之间产生了关系，才有了多态的特性。

•注意：千万不要为了获取其他类的功能，简化代码而继承。必须是类与类之间有所属关系才可以继承。所属关系：is-a（就可以判断何时编译成功，何时编译失败，以及将扮演看做叫编译程序住嘴语法）。

eg:把相同的程序代码提升为父类。

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;

}

}

eg： SwordsMan和Magician 定义继承Role类后（代码已上传），如何看出确实有继承。

public class PRG

{

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("Moinca");

magician.setLevel(1);

magician.setBlood(100);

System.out.printf("魔法师:(%s,%d,%d)%n",magician.getName(),

magician.getLevel(),magician.getBlood());

}

}

6.1.2 多态与is-a

•多态定义：使用单一接口操作多种类型的对象。

•is-a关系定义：子类只能继承一个父类，“是一种”关系。

•java语言中只支持单继承，不支持多继承。（由于多继承易带来安全隐患：当多个父类中定义了相同功 能，但功能内容不同时，子类对象不确定要运行哪一个。但是java保留这种机制，并用另一种体现形式来完成表示。多实现。)

•如何使用一个继承体系中的功能？查阅父类功能，创建子类对象使用功能。

•为什么在具体调用时要创建最子类对象？1.因为有可能父类不能创建对象。2.创建子类对象可以使用更多的功能，包括基本的和特有的。

eg：若有100个角色，如何从Roel中调用角色

public class RPG2

{

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(magician);

}
static void showBlood(Role role)
{
System.out.printf("%s 血量 %d%n",role.getName(),role.getBlood());
}

}

6.1.3 重新定义行为

•定义：在继承父类之后，定义与父类中相同的方法部署，但执行内容不同。

•注意：在重新定义父类中某个方法时，子类必须撰写与父类方法中相同的签署。

•JDK5之后支持标注，如果要重新定义某方法，加上@override，就不用担心错字问题。

eg：SwordsMan和Magician继承Role之后，再对fight（）的行为进行重新定义，由于Role现在定义了fight（）方法，所以编译程序不会找不到Role的fight（）的方法。

public class RPG3

{

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

}

•运行结果


6.1.4 抽象方法、抽象类

•内含抽象方法的类，一定要在class前标示abstract，该方法不用撰写{}区块，直接以；结束。

•子类继承抽象类，对于抽象方法有哪些做法？1.继续标示该方法为abstract。2.操作抽象方法。

eg：使用abstract方法。

public abstract class Role4

{

...

public abstract void fight();

}

6.2 继承语法细节

6.2.1 protected成员

•被声明为protected的成员，想通报中的类可以直接存取，不同包中的类可以在继承后的子类直接存取。

•依权限小至大来区分，就是private、无关键字、protected与public，若不知使用哪个，就先使用private。

eg：SwordsMan和Magician如何定义toString（）的代码已上传。若只想让子类可以直接存取name、level、public，可以定义其为protect。

public abstract class Role5

{

protected String name;

protected int level;

protected int blood;

...

}

6.2.2 重新定义的细节

•如果想取得父类中的方法定义，可以在调用方法前，加上super关键字，但不能定义为private（因为这就限定只能在类内使用）。

•注意：对于父类中的方法权限，只能扩大但不能缩小。若原来成员public，子类中重新定义时不可为private或protected.

•JDK5之后重新定义方法时，如果返回值类型是父类中方法返回值类型的子类，也是可以通过编译的。

•static方法属于类拥有，如果子类中定义了相同签署的static成员，该成员属于子类所有，而非重新定义，static方法没有多热爱，因为对象不会个别拥有static成员。

eg：Role类中原本就定义了toString（）方法。

public abstract class Role6

{

public String toString()

{

...

return String.format("(%s, %d, %d)", this.name, this.level, this.blood);

}

}

eg：SwordsMan加上super关键字，在重新定义toString（）时。

public class SwordsMan6 extends Role

{

{

System.out.println("挥剑攻击");

}

@Override

public String toString()

{

return "剑士 "　+　super.toString();

}

}

eg：Magician加上super关键字，在重新定义toString（）时。

public class Magician6 extends Role

{

{

System.out.println("魔法攻击");

}

@Override

public String toString()

{

return "魔法师" "　+　super.toString();

}

}

6.2.3 构造函数

•类中成员：1.变量 2.函数 3.构造函数

•变量：如果子类中出现非自由的同名成员变量时，子类要访问本类中的变量用this，子类要访问父类中的同名变量，用super。（super的使用和this几乎一致，this代表的是本类对象的引用，super代表的是父类对象的引用。）

•特性：重写（覆盖）。当子类出现和父类一模一样的函数时，子类对象调用该函数，会运行子类函数的内容，如同父类的函数被覆盖一样。

•覆盖：1.子类覆盖父类，必须保证子类权限大于等于父类权限才可以覆盖，否则编译失败，2.静态只能覆盖静态。

•子父类中的构造函数：子类的所有的构造函数，默认都会访问父类中空参数的构造函数。因为子类每一个构造函数内的第一行都有一句隐式super（）。(当父类没有空参数的构造函数时，子类必须手动通过super或this语形式来指定要访问的构造函数)

•注意：1.重载只看同名函数的参数列表。2.重写中子类父类方法要一模一样。3.super语句一定定义在子类构造函数的第一行。

6.2.4 final关键字

•定义：最终。class前如果使用了final关键字定义满么表示这个类是最后一个，不会再有子类，就是不能被继承。

•特点：1.可以修饰类、函数、变量。 2.被final修饰的类不可以被继承。3.被final修饰的方法不可以被复写。4.被final修饰的变量是一个常量，只能赋值一次。5.内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量。

6.2.5 java.lang.Object

•如果定义类时没有使用extends关键字指定继承任何类，那一定是继承java.lang.Object。

•任何类追溯至最上层父类，一定就是java.lang.Object。

eg：定义ArrayList类，不限长度地收集对象。

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

}

eg：使用ArrayList类，收集访客名称，并将名单转为大写后显示。

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.ptintln("访客名单：");

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"))

{

breaks;

}

names.add(name);

}

}

static void printUpperCase(ArrayList names)

{

for(int i=0;i<names.size();i++)

{

String name=(String) name.get(i);

out.println(name.toUpperCase());

}

}

}

6.2.5 垃圾收集

•创建对象会占据内存，如果程序执行流程中已无法再使用某个对象，该对象就只是耗内存的垃圾。

•JVM有垃圾收集机制，收集到的垃圾对象所占据的内存空间，会被垃圾收集器释放。

•垃圾对象：执行流程中，无法通过变量参考的对象。

6.2.6 再看抽象类

•特点：1.抽象方法一定在抽象类中。2.抽象方法和抽象类都必须被abstract关键字修饰。3.抽象类不可以用new创建对象（因为调用抽象方法没意义）。4.抽象类中的方法要被使用，必须由子类复写其所有的抽象方法后，建立子类对象调用，如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。

eg：撰写ConsoleGame类，继承抽象类GuessGame。

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 nextInt()
{
return scanner.nextInt();
}

}

eg：完整版猜数字。

public class Guess

{

public static void main(String[] args)

{

GuessGame game=new ConsoleGame();

game.go();

}

}

import java.util.Scanner;

public class Guess

{

public static void main(String[] args)

{

Scanner scanner = new Scanner (System.in);

int number = (int) (Math.random() * 10);

int guess;

do
{
System.out.printf("猜数字（0~9）:");
guess = scanner.nextInt();
}
while(guess != number);

System.out.println("猜中了!");

}

}

7.1接口

7.1.1接口定义行为

•格式：interface{}

•特点：1.接口是对外暴露的规则。2.接口是程序的功能扩展。3.接口可以用来多实现。4.类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。5.接口与接口之间可以有继承关系。

•接口中的成员修饰符是固定的，都是public的。1.成员常量：public static fianal{} 2.成员函数：public abstract

•接口中将出现“多继承”通过两一种形式体现出来，即“多实现”。

•class用于定义类。interface用于定义接口。

•接口是不可以创建对象的，因为有抽象方法。

•接口可以被类多实现，也是对多继承不支持的转换形式。java支持多实现。

eg:在java中可以使用interface关键字。

public interface Swimmer

{

public abstract void swim();

}

eg：Humman、Fish、Submarine也有Swimmer行为，以Submarine为例。

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行为的多态

•定义：某一类事物的多种存在形态。

•体现：父类的引用指向了自己的子类的对象，也可以接收自己的子类对象。

•前提：必须是类与类之间有关系，要么继承，要么实现。通常还有一个前提：存在覆盖。

•优势：大大的提高了程序的扩展性。

•弊端：只能使用父类的引用访问父类中的成员。

•在多态中成员函数的特点？编译看左边，运行看右边。

•在多态中成员变量的特点？无论编译和运行，都参考左边（引用型变量所属的类）。

•在多态中静态成员函数的特点？无论编译和运行，都参考左边。

eg： Anemonsfish、Shark、Human、Submarine，都拥有Swimmer的行为，都操作了Swimmer接口。

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解决需求变化

•在java中，类可以操作量一以上的类，也就是拥有两种以上的行为。

•在java中，类可以同时继承某个类，并操作某些接口。

•在java中，接口以及集成自另一个接口，也就是继承父接口行为，再在子接口中额外定义行为。

eg：使用interface定义Flyer接口。

public interface Flyer

{

public abstract void fly();

}

eg：定义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);

}

}

eg：继承Fish类，操作Flyer接口。

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("飞鱼会飞");

}

}

eg：Seaplane拥有Swimmer的行为，而FlyingFish也拥有Swimmer的行为。

public class Ocean2{

public static void main(String[] args)

{

doSwim(new Seaplane("空军零号"));

doSwim(new FlyingFish("甚平"));

}

static void doSwim(Swimmer swimmer)

{

swimmer.swim();

}

}

eg：设计一个Airplane类作为Seaplane的父类，Airplane操作Flyer接口。

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

}

eg：假设一般的船可以再浅海航行。

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

}

}

eg：潜水艇是一种船，可以再浅海游泳，也可以在深海潜行。

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.2接口语法细节

7.2.1接口的默认

•在java中，用interface来定义抽象的行为外观，方法声明为public abstract，也可以省略，编译程序会自动协助补齐。

•类可以操作两个以上的接口，如果有两个接口都定义了某方法，操作两个接口并不会有错误。

•接口可以继承别的接口，也可以同时继承两个以上的接口，同样也是使用extends，代表了继承父接口的行为。

eg：在interface中，可以定义常数。

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;

}

eg：枚举常数。

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匿名内部类

•定义：在写java程序时，如果有临时继承某个类或操作某个借口并建立实例的需求，而这类子类或接口操作类只使用一次，不需要为这些类定义名称时。

eg：假设打算开发多人联机程序，对每个联机客户端，都会建立Client对象封装相关信息。

public class Client{

public final String ip;

public final String name;

public Client(String ip,String name){

this.ip=ip;

this.name=name;

}

}

eg：将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;

}

}

eg：定义ClientListener接口，如果有对象对ClientQuene有兴趣，可以，可以操作这个接口。

public interface ClientListener

{

void clientAdded(ClientEvent event);

void clientRemoved(ClientEvent event);

}

eg：在ClientQuene新增或移除Client时予以通知。

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

}

}

}

eg：可以使用以下代码，其中使用匿名内部类，直接建立操作ClientListener的对象。

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(){
@Override
public void clientAdded(ClientEvent event){
System.out.printf("%s 从 %s 联机%n",
event.getName(),event.getIp());
}
@Override
public 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);
}

}

7.2.3使用enum枚举常数

•enum可以用于定义枚举常数。enum定义了特殊的类，继承自java.lang.Enum。

•enum实际上定义了类，而enum中列举的常数实际上是public static final，且为枚举类型实例，无法撰写程序直接实例化枚举类型，因为构造函数全线设定为private，只有类中才可以实例化。

eg：定义枚举常数。

public enum Action2

{

STOP,RIGHT,LEFT,UP,DOWN

}

eg：可以用这个Action来声明类型。

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;

}

}

}

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

Java的学习是一个长时间的过程，我还需要好好努力去学习。

学习进度条

	代码行数（新增/累积）	博客量（新增/累积）	学习时间（新增/累积）	重要成长
目标	5000行	30篇	400小时
第一周	200/200	2/2	20/20
第二周	300/500	2/4	18/38
第三周	500/1000	3/7	22/60
第四周	300/1300	2/9	30/90

参考资料

Java学习笔记(第8版)

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

...