学号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

参考资料

发表于 2016-03-27 23:49 20145220韩旭飞阅读(109) 评论(1) 编辑收藏举报

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

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

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

学习进度条

参考资料

公告