《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程序设计》第4周学习总结的更多相关文章
- 20145213《Java程序设计》第九周学习总结
20145213<Java程序设计>第九周学习总结 教材学习总结 "五一"假期过得太快,就像龙卷风.没有一点点防备,就与Java博客撞个满怀.在这个普天同庆的节日里,根 ...
- 20145213《Java程序设计》第二周学习总结
20145213<Java程序设计>第二周学习总结 教材学习内容总结 本周娄老师给的任务是学习教材的第三章--基础语法.其实我觉得还蛮轻松的,因为在翻开厚重的书本,一股熟悉的气息扑面而来, ...
- 20145213《Java程序设计》第一周学习总结
20145213<Java程序设计>第一周学习总结 教材学习内容总结 期待了一个寒假,终于见识到了神秘的娄老师和他的Java课.虽说算不上金风玉露一相逢,没有胜却人间无数也是情理之中,但娄 ...
- 21045308刘昊阳 《Java程序设计》第九周学习总结
21045308刘昊阳 <Java程序设计>第九周学习总结 教材学习内容总结 第16章 整合数据库 16.1 JDBC入门 16.1.1 JDBC简介 数据库本身是个独立运行的应用程序 撰 ...
- 20145330孙文馨 《Java程序设计》第一周学习总结
20145330孙文馨 <Java程序设计>第一周学习总结 教材学习内容总结 刚开始拿到这么厚一本书说没有压力是不可能的,开始从头看觉得很陌生进入不了状态,就稍微会有一点焦虑的感觉.于是就 ...
- 20145337 《Java程序设计》第九周学习总结
20145337 <Java程序设计>第九周学习总结 教材学习内容总结 数据库本身是个独立运行的应用程序 撰写应用程序是利用通信协议对数据库进行指令交换,以进行数据的增删查找 JDBC可以 ...
- 20145337 《Java程序设计》第二周学习总结
20145337 <Java程序设计>第二周学习总结 教材学习内容总结 Java可分基本类型与类类型: 基本类型分整数(short.int.long).字节(byte).浮点数(float ...
- 20145218《Java程序设计》第一周学习总结
20145218 <Java程序设计>第一周学习总结 教材学习内容总结 今天下午看了Java学习的视频,感觉很是新奇,之前觉得Java学起来是艰难枯燥的,但通过第一章的学习觉得如果自己可以 ...
- 《Java程序设计》第九周学习总结
20145224 <Java程序设计>第九周学习总结 第十六章 整合数据库 JDBC入门 ·数据库本身是个独立运行的应用程序 ·撰写应用程序是利用通信协议对数据库进行指令交换,以进行数据的 ...
- 《Java程序设计》第二周学习总结
20145224陈颢文<Java程序设计>第二周学习总结 教材学习内容总结 一.类型.变量与运算符 1.类型 整数: 可细分为为short整数(占2字节),int整数(占4字节),long ...
随机推荐
- JSChart
转自:http://www.cnblogs.com/riverback-moon/archive/2010/10/11/1848071.html JSChart是一个轻量级的在线图表生成工具,本身十 ...
- 通过代码自定义cell 新浪微博页面显示
通过代码自定义cell(cell的高度不一致)(如果高度一致的cell 用xib实现) 1.新建一个集成自UItableVIewCell的类 2.重写initWithStle :方法 - (insta ...
- 继承自NSObject的类不能用CGRect
我用的是Xcode6.2. 系统默认没有pch文件. 所以没有自动导入UIKit包. 我在继承NSObject类里也不能用CGRect或者UI开头的控件,原因也是Xcode6.2以后版本 缺少UIKi ...
- C/C++遍历Windows文件夹下的所有文件
因为文件夹中往往包含文件和文件夹.想要遍历所有的文件,必须遍历文件夹中所有的文件夹.很显然,这个描述满足递归的两个要素:(1)问题的规模在不断的缩小,且新问题的模式与旧问题相同.很显然文件夹中含有子文 ...
- 转:Java面试题集(1-50)
Java程序员面试题集(1-50) http://blog.csdn.net/jackfrued/article/details/17403101 一.Java基础部分 1.面向对象的特征有哪些方面? ...
- hdu 1069
//Accepted 264 KB 0 ms //每种block只有三种方法,且每种放法至多放一次 //规定三条边的顺序后 //把所有的block按x递增排序,x相同则按y递增排序 //然后dp // ...
- unity3d基础01
Unity3d 五大视图: 1 Scene:存放hierarchy中创建的游戏对象,但实际只能看到一部分 *Scene浏览: ①右键进入“飞行模式”,方便查看整个场景 ②选中摄像机,按ALT进入浏览的 ...
- C语言数据类型在IA32中的大小
这个主要是一些常识问题,以及在使用AT&T语法汇编时会使用的编码后缀: C声明 Intel数据类型 汇编后缀 大小(byte) char 字节 b 1 short 字 w 2 int ...
- Makefile总结和反序字符数组,整体右移数组,杨辉三角!
2015.1.23今天我值日 继续接着昨天Makefile的目标开始记录:第一种:有 .PHNOY声明,但是冒号后面没有依赖文件.PHNOY:clean clean://没有依赖文件 rm *.0 t ...
- I - Tri Tiling
Time Limit:1000MS Memory Limit:65536KB 64bit IO Format:%I64d & %I64u Submit Status #in ...