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

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

教材学习内容总结

第六章 继承与多态

6.1 何谓继承

1、继承共同行为

  • 多个类中存在相同属性和行为时,将这些内容抽取到单独一个类中,那么多个类无需再定义这些属性和行为,只要继承单独的那个类即可。
  • 多个类可以称为子类,单独这个类称为父类或者超类。
  • 子类可以直接访问父类中的非私有的属性和行为。
  • 通过extends 关键字让类与类之间产生继承关系。
  • 以实际例子来说明继承。代码如下:
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("Moinca");
		magician.setLevel(1);
		magician.setBlood(100);
		System.out.printf("魔法师:(%s,%d,%d)%n",magician.getName(),
				magician.getLevel(),magician.getBlood());
		
	}
}

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("魔法治疗");
	}	
} 

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

}

  • 结果截图:

2、多态与is-a

  • Java只支持单继承,不支持多继承。一个类只能有一个父类,不可以有多个父类。
  • Java支持多层继承(继承体系) 。
  • 定义继承需要注意:类与类之间要有所属( " is a " )关系,以前面范例来说,SwordsMan继承了Role,所以SwordsMan is a Role。
  • 以实际例子来说明多态。代码如下:
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());
	}
}
  • 结果截图:

3、重新定义行为

  • 在继承父类之后,定义与父类中相同的方法部署,但执行内容不同,这称为重新定义。
public class RPG3
{
	public static void main(String[] args)
	{
		SwordsMan3 swordsMan = new SwordsMan3();
		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(Role3 role)
	{
		System.out.print(role.getName());
		role.fight();
	}
}

public class Magician extends Role3
{
    public void fight()
    {
        System.out.println("魔法攻击");
    }

}
public class SwordsMan3 extends Role3
{
    public void fight()
    {
        System.out.println("挥剑攻击");
    }

}
public class Role3
{

		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 void fight()
	{
		
	}
}
  • 结果截图

4、抽象方法、抽象类

  • 抽象类:Java中可以定义没有方法体的方法,该方法的具体实现由子类完成,该方法称为抽象方法,包含抽象方法的类就是抽象类。 
  • 抽象方法的由来:多个对象都具备相同的功能,但是功能具体内容有所不同,那么在抽取过程中,只抽取了功能定义,并未抽取功能主体,那么只有功能声明,没有功能主体的方法称为抽象方法。
  • 抽象类和抽象方法必须用abstract关键字来修饰。

6.2 继承语法细节

1、protected成员

  • 代码如下:
public abstract class Role5
{
	protected String name;
	protected int level;
	protected 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 Magician5 extends Role5
{

	public void fight()
	{
		System.out.println("魔法攻击");
	}
	
	public String toString()
	{
		return String.format("魔法师 (%s, %d, %d)", this.name, this.level, this.blood);
	}
	
}
public class SwordsMan5 extends Role5
{

	public void fight()
	{
		System.out.println("挥剑攻击");
	}
	public String toString()
	{
		return String.format("剑士 (%s, %d %d)", this.name, this.level, this.blood);
	}
	
}

2、重新定义的细节

  • 对于父类中的方法权限,只能扩大但不能缩小。若原来成员public,子类中重新定义时不可为private或protected。
  • 代码如下:
public abstract class Role6
{
	public String toString()
	{
		return String.format("(%s, %d, %d)", this.name, this.level, this.blood);
	}
}

3、final关键字

  • final可以修饰类,方法,变量。 
  • final修饰的类不可以被继承。final修饰的方法不可以被覆盖。 
  • final修饰的变量是一个常量,只能被赋值一次。 
  • 内部类只能访问被final修饰的局部变量。

4、java.lang.Object

  • 在Java中,子类只能继承一个父类,如果定义类时没有使用extends关键字指定继承任何类,那一定是继承java.lang.Object。
  • 代码如下:
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;
}
}
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.println("访客名单:");
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")) {
break;
}
names.add(name);
}
}

static void printUpperCase(ArrayList names) {
for(int i=0;i<names.size();i++) {
String name=(String) names.get(i);
out.println(name.toUpperCase());
}
}
}
  • 结果截图:

5、抽象类

  • 代码如下:
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 nextInt() {
return scanner.nextInt();
}
}
public class Guess {
public static void main(String[] args){
GuessGame game=new ConsoleGame();
game.go();
}
}
  • 结果截图:

第七章 接口与多态

7.1 何谓接口

1.接口定义行为

  • 接口的出现将“多继承”通过另一种形式体现出来,即 “多实现”。
  • 接口是程序的功能扩展。 
  • 接口可以用来多实现。 
  • 类与接口之间是实现关系,而且类可以继承一个类的同时实现多个接口。 
  • 接口与接口之间可以有继承关系。
  • 代码如下:
public class Anemonefish extends Fish{
public Anemonefish(String name){
super(name);
}


@Override
public void swim();{
System.out.printf("小丑鱼 %s 游泳%n",name);
}
}

public class Shark extends Fish{
public Shark(String name){
super(name);
}


@Override
public void swim();{
System.out.printf("鲨鱼 %s 游泳%n",name);
}
}
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;
}


@Override
public 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;
}


@Override
public void swim();{
System.out.printf("潜水艇 %s 潜行%n",name);
}
}

2.行为的多态

  • 代码如下:
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();
}
}
  • 结果截图:

3.解决需求变化

  • 写程序时,如果增加新的需求,可使原有的程序无需修改,只针对新需求撰写程序。
  • 代码如下:
public interface Flyer{
public abstract void fly();
}
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("飞鱼会飞");
}
}
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);
}
}
public class Ocean2{
public static void main(String[] args)
{
doSwim(new Seaplane("空军零号"));
doSwim(new FlyingFish("甚平"));
}

static void doSwim(Swimmer swimmer){
swimmer.swim();
}
}
  • 结果截图

7.2 接口语法细节

1.接口的默认

  • 在java中,可使用interface来定义抽象的行为与外观,如接口中的方法可声明为public abstract。
  • 代码如下:
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 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("不支持此动作");
		}
	}
}
  • 结果截图

2.匿名内部类:就是内部类的简化写法。

  • 前提:内部类可以继承或实现一个外部类或者接口。 
  • 格式为:new 外部类名或者接口名(){覆盖类或者接口中的代码, ( 也可以自定义内容。)} 
  • 代码如下:
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 ClientListener{
	void clientAdded(ClientEvent event);
	void clientRemoved(ClientEvent event);
}
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) listener.get(i);
			listener.client.Added(event);
		}
	}
	public void remove(Client client){
		client.remove(client);
		ClientEvent event=new ClientEvent(client);
		for(int i=0;i<listeners.size();i++){
			ClientListener listener=(ClientListener) listener.get(i);
			listener.client.Removed(event);
		}
	}
}
public class Multichat{
	public static void main(String[] args){
	Client c1=new Client("127.0.0.1","Caterpillar");
	Client c1=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 cong %s lianji%n",
			event.getGame(),event.getIp());
		}
		@Override
		public void clientRemoved(ClientEvent event){
			System.out.printf("%s cong %s tuoji%n",
			event.getGame(),event.getIp());
		}
	});
	queue.add(c1);
	queue.add(c2);
	queue.remove(c1);
	queue.remove(c1);
}
}
  • 结果截图

3.使用enum枚举常数

  • 代码如下:
public enum Action2{
	STOP,RIGHT,LEFT,UP,DOWN
}
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中每一个项目是相对独立的,这周通过对继承和接口的学习才明白,有很多项目彼此之间是有着千丝万缕的联系的,比如设计一个海洋乐园游戏,就需要很多个小代码相互配合才能出现预期的效果。

其他(感悟、思考等,可选)

学习java已经四个星期了,这周学习了java第六章第七章的内容。这周敲了很多书上的代码,有些取得了预期的效果,有些却始终不行,后面通过看视频以及查阅资料慢慢的解决了一些问题。有一部分依然不能解决。同时,这周我有试着自己脱离课本敲了一些代码,虽然是很简单的,但是看到运行结果出来的那一刻还是很开心。

学习进度条

代码行数(新增/累积) 博客量(新增/累积) 学习时间(新增/累积) 重要成长
目标 5000行 30篇 400小时
第一周 200/200 2/2 20/20
第二周 200/400 1/3 20/40
第三周 500/900 1/4 30/70
第四周 1072/1972 1/5 30/100

参考资料

posted @ 2016-03-26 19:31  20145227鄢曼君  阅读(196)  评论(3编辑  收藏  举报