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

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

教材学习内容总结

6.1继承

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

• 运行结果
  

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

使用了NotePad编辑代码，但复制到IDEA中时汉字全都是乱码，在IDEA中改完了后回到NotePad中还是乱码。
书中有些程序没有运行结果，并不知道作用。

本周代码托管截图

• 中国开源代码托管截图：
  
  
  

• wc统计行数截图：
  

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

    学习Java已经一个月，学习任务也越来越重，希望自己还能继续坚持，本周主要学习了六七章节的内容，主要是继承和接口这两个内容，首先主要是一个RPG、SwordsMan这两个程序，但其不仅仅是一个程序，是多个程序继承在一起才能运行，这就需要我们仔细按照课本加以理解后才能学会，可能刚开始打了很多代码并不能运行，刚开始很疑惑，但仔细往下阅读会发现是为了最后一个大的程序做铺垫，最终能顺利运行。

学习进度条

	代码行数（新增/累积）	博客量（新增/累积）	学习时间（新增/累积）	重要成长
目标	5000行	30篇	400小时
第一周	200/200	1/2	20/20
第二周	300/500	1/3	30/50
第三周	500/1000	1/4	35/85
第四周	1225/2225	1/5	40/125

参考资料

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