学号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程序设计》第4周学习总结的更多相关文章

  1. 20145213《Java程序设计》第九周学习总结

    20145213<Java程序设计>第九周学习总结 教材学习总结 "五一"假期过得太快,就像龙卷风.没有一点点防备,就与Java博客撞个满怀.在这个普天同庆的节日里,根 ...

  2. 20145213《Java程序设计》第二周学习总结

    20145213<Java程序设计>第二周学习总结 教材学习内容总结 本周娄老师给的任务是学习教材的第三章--基础语法.其实我觉得还蛮轻松的,因为在翻开厚重的书本,一股熟悉的气息扑面而来, ...

  3. 20145213《Java程序设计》第一周学习总结

    20145213<Java程序设计>第一周学习总结 教材学习内容总结 期待了一个寒假,终于见识到了神秘的娄老师和他的Java课.虽说算不上金风玉露一相逢,没有胜却人间无数也是情理之中,但娄 ...

  4. 21045308刘昊阳 《Java程序设计》第九周学习总结

    21045308刘昊阳 <Java程序设计>第九周学习总结 教材学习内容总结 第16章 整合数据库 16.1 JDBC入门 16.1.1 JDBC简介 数据库本身是个独立运行的应用程序 撰 ...

  5. 20145330孙文馨 《Java程序设计》第一周学习总结

    20145330孙文馨 <Java程序设计>第一周学习总结 教材学习内容总结 刚开始拿到这么厚一本书说没有压力是不可能的,开始从头看觉得很陌生进入不了状态,就稍微会有一点焦虑的感觉.于是就 ...

  6. 20145337 《Java程序设计》第九周学习总结

    20145337 <Java程序设计>第九周学习总结 教材学习内容总结 数据库本身是个独立运行的应用程序 撰写应用程序是利用通信协议对数据库进行指令交换,以进行数据的增删查找 JDBC可以 ...

  7. 20145337 《Java程序设计》第二周学习总结

    20145337 <Java程序设计>第二周学习总结 教材学习内容总结 Java可分基本类型与类类型: 基本类型分整数(short.int.long).字节(byte).浮点数(float ...

  8. 20145218《Java程序设计》第一周学习总结

    20145218 <Java程序设计>第一周学习总结 教材学习内容总结 今天下午看了Java学习的视频,感觉很是新奇,之前觉得Java学起来是艰难枯燥的,但通过第一章的学习觉得如果自己可以 ...

  9. 《Java程序设计》第九周学习总结

    20145224 <Java程序设计>第九周学习总结 第十六章 整合数据库 JDBC入门 ·数据库本身是个独立运行的应用程序 ·撰写应用程序是利用通信协议对数据库进行指令交换,以进行数据的 ...

  10. 《Java程序设计》第二周学习总结

    20145224陈颢文<Java程序设计>第二周学习总结 教材学习内容总结 一.类型.变量与运算符 1.类型 整数: 可细分为为short整数(占2字节),int整数(占4字节),long ...

随机推荐

  1. JSChart

     转自:http://www.cnblogs.com/riverback-moon/archive/2010/10/11/1848071.html JSChart是一个轻量级的在线图表生成工具,本身十 ...

  2. 通过代码自定义cell 新浪微博页面显示

    通过代码自定义cell(cell的高度不一致)(如果高度一致的cell 用xib实现) 1.新建一个集成自UItableVIewCell的类 2.重写initWithStle :方法 - (insta ...

  3. 继承自NSObject的类不能用CGRect

    我用的是Xcode6.2. 系统默认没有pch文件. 所以没有自动导入UIKit包. 我在继承NSObject类里也不能用CGRect或者UI开头的控件,原因也是Xcode6.2以后版本 缺少UIKi ...

  4. C/C++遍历Windows文件夹下的所有文件

    因为文件夹中往往包含文件和文件夹.想要遍历所有的文件,必须遍历文件夹中所有的文件夹.很显然,这个描述满足递归的两个要素:(1)问题的规模在不断的缩小,且新问题的模式与旧问题相同.很显然文件夹中含有子文 ...

  5. 转:Java面试题集(1-50)

    Java程序员面试题集(1-50) http://blog.csdn.net/jackfrued/article/details/17403101 一.Java基础部分 1.面向对象的特征有哪些方面? ...

  6. hdu 1069

    //Accepted 264 KB 0 ms //每种block只有三种方法,且每种放法至多放一次 //规定三条边的顺序后 //把所有的block按x递增排序,x相同则按y递增排序 //然后dp // ...

  7. unity3d基础01

    Unity3d 五大视图: 1 Scene:存放hierarchy中创建的游戏对象,但实际只能看到一部分 *Scene浏览: ①右键进入“飞行模式”,方便查看整个场景 ②选中摄像机,按ALT进入浏览的 ...

  8. C语言数据类型在IA32中的大小

    这个主要是一些常识问题,以及在使用AT&T语法汇编时会使用的编码后缀: C声明 Intel数据类型 汇编后缀 大小(byte) char 字节  b  1 short 字  w  2 int ...

  9. Makefile总结和反序字符数组,整体右移数组,杨辉三角!

    2015.1.23今天我值日 继续接着昨天Makefile的目标开始记录:第一种:有 .PHNOY声明,但是冒号后面没有依赖文件.PHNOY:clean clean://没有依赖文件 rm *.0 t ...

  10. I - Tri Tiling

      Time Limit:1000MS     Memory Limit:65536KB     64bit IO Format:%I64d & %I64u Submit Status #in ...