20145312 《Java程序设计》第四周学习总结
20145312 《Java程序设计》第四周学习总结
学习笔记
Chapter 6
6.1何为继承
1.定义：面向对象中子类继承父类，避免重复的行为定义。
6.1.1 继承共同行为
1.以一款RPG游戏为例。
代码如下：
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;
}
}
public class Magician extends Role {
public void fight(){
System.out.println("魔法攻击");
}
public void cure(){
System.out.println("魔法治疗");
}
public class SwordsMan extends Role {
public void fight(){
System.out.println("挥剑攻击");
}
}
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("Monica");
magician .setLevel(1);
magician .setBlood(100);
System.out.printf("魔法师：(%s,%d,%d)%n",magician .getName(),magician .getLevel(),magician .getBlood());
}
}
结果如下：
剑士：(Justin,1,200)
魔法师：(Monica,1,100)
2.关键字extends表示Swordsman会扩充Role的行为，也就是继承Role的行为。
3.Magician继承Role的行为，并扩充了Role原本没有的fight()与cure()行为。
6.1.2 多态与is-a
1.继承还有一个重要的关系，子类与父类之间会有is-a关系。
代码如下：
public class RPG {
public static void main(String[] args){
Game2. 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());
}
}
结果如下：
Justin血量200
Monica血量100
2.编译程序会检查父子类间“是一种“关系。
3.使用is-a关系，就可以判断何时编译失败，何时编译成功。
4.还可以使用重载方法的运用。
6.1.3 重新定义行为
- 代码如下：
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;
}
public void fight(){
}
}
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 RPG {
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.printf(role.getName());
role.fight();
}
}
结果如下：
Justin挥剑攻击
Monica魔法攻击
2.操作接口相同，操作方法内容不同，可以将fight()方法提升至Role。
3.在JDK5之后支持标注，其中一个内建的标准标注是@override。如果在子类中某个方法前标注@override，表示要求编译程序检查。
6.1.4 抽象方法、抽象类
1.定义：如果某方法区块中实际没有程序代码操作，可以使用abstract标示该方法为抽象方法。
2.这类方法不用撰写{ }区块，直接“；“结束即可。
3.代码如下：
public abstract 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;
}
public abstract void fight();
}
结果如下：
Justin挥剑攻击
Monica魔法攻击
4.Java规定内含抽象方法的类一定要在class前标示abstract。
6.2 继承语法细节
6.2.1 protected成员
1.显示角色细节，并只想子类可以直接存取类的话，可以定义它们为protected。
2.代码如下：
public abstract class Role {
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 abstract void fight();
}
public class SwordsMan extends Role {
public void fight(){
System.out.println("挥剑攻击");
}
public String toString(){
return String.format("剑士（%s,%d,%d）",this.name,this.level,this.blood);
}
}
public class Magician extends Role {
public void fight(){
System.out.println("魔法攻击");
}
public void cure(){
System.out.println("魔法治疗");
}
public String toString() {
return String.format("魔法师（%s,%d,%d）", this.name, this.level, this.blood);
}
}
结果如下：
Justin挥剑攻击
Monica魔法攻击
6.2.2 重新定义的细节
- 代码如下：
public abstract class Role {
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 abstract void fight();
public String toString() {
return String.format("（%s,%d,%d）", this.name, this.level, this.blood);
}
}
public class SwordsMan extends Role {
public void fight(){
System.out.println("挥剑攻击");
}
@Override
public String toString(){
return "剑士"+super.toString() ;
}
}
public class Magician extends Role {
public void fight(){
System.out.println("魔法攻击");
}
public void cure(){
System.out.println("魔法治疗");
}
@Override
public String toString() {
return "魔法师"+super.toString();
}
}
结果如下：
Justin挥剑攻击
Monica魔法攻击
2.如果Role中本身定义toString()方法，可以在执行父类中的方法的前后做点加工。
6.2.3 final关键字
1.如果在class前使用final关键字定义，那么表示这个类是最后一个，不能被继承。
6.2.4 Java.lang.Object
1.在Java中，子类只能继承一个父类，如果定义类时没有使用extends关键字指定继承任何类。
2.代码如下：
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() );
}
}
}
结果如下：
访客名单：张三
访客名单：李四
访客名单：王二麻子
访客名单：quit
访客名单:
张三
李四
王二麻子
3.自定义的ArrayList类，内部使用Object数组来收集对象。
4.如果使用无参数构造函数，则默认容量为16。
5.重新定义toString()
6.重新定义equals()
6.2.5 再看抽象类
1.代码如下：
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.print(text);
}
@Override
public int nextInt(){
return scanner.nextInt();
}
}
public class Guess {
public static void main(String[] args){
GuessGame game=new ConsoleGame();
game.go();
}
}
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();
}
结果如下：
输入数字：2
猜中了
Chapter 7 接口与多态
7.1 何谓接口
7.1.1接口定义行为
1.接口的出现将“多继承”通过另一种形式体现出来，即 “多实现”。
2.接口是程序的功能扩展。
3.接口可以用来多实现。
4.类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。
5.接口与接口之间可以有继承关系。
6.代码如下：
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);
}
}
7.1.2 行为的多态
1.代码如下：
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解决需求变化
1.写程序时，如果增加新的需求，可使原有的程序无需修改，只针对新需求撰写程序。
2.代码如下：
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 接口语法细节
7.2.1.接口的默认
1.在java中，可使用interface来定义抽象的行为与外观，如接口中的方法可声明为public abstract。
2.代码如下：
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("不支持此动作");
}
}
}
结果如下：
播放向右动画
播放向上动画
7.2.2 匿名内部类：就是内部类的简化写法。
1.前提：内部类可以继承或实现一个外部类或者接口。
2格式为：new 外部类名或者接口名(){覆盖类或者接口中的代码， ( 也可以自定义内容。)
3代码如下：
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);
}
}
结果如下：
Caterpilllar 从 127.0.0.1 联机
Justin 从 192.168.0.2 联机
Caterpilllar 从 127.0.0.1 脱机
Justin 从 192.168.0.2 脱机
7.2.3 使用enum枚举常数
1.代码如下：
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;
}
}
}
结果如下：
播放向右动画
播放向上动画
代码调试中的问题和解决过程
问题：在打第六章代码Game2~Game6时有相同的class就直接复制到package里，结果运行出错。
解决过程：在仔细查看代码后，我发现在主程序前有import Role等字样，于是我就改为import Role1等，在运行就编译通过了。
其他（感悟、思考等，可选）
这周的Java学习，我们开始自己编写简单的小游戏了，这引起了我极大的兴趣，所以在这周6、7章的学习中，我不再觉得打代码是件枯燥的事情，反而积极主动敲代码，看到自己编写的小游戏可以运行，油然而生了一种自豪感。由此我想到，兴趣是最好的老师，有了兴趣使然，我就会主动学习，从中获取更多的知识得到进步。
学习进度条
代码托管截图
参考资料
参考资料
20145312 《Java程序设计》第四周学习总结的更多相关文章
- Java程序设计第四周学习总结
1. 本周学习总结 1.1 尝试使用思维导图总结有关继承的知识点. 1.2 使用常规方法总结其他上课内容. 答:①String类是final类,不能定义String的子类. ② instanceof ...
- 杨其菊201771010134《面向对象程序设计（java)》第四周学习总结
<面向对象程序设计(java)> 第四周学习总结 第一部分:理论知识 1.类与对象 a.类(class)是构造对象的模板或蓝图.由类构造对象的过程称为创建类的实例: java中类声明的格式 ...
- 对于“2017面向对象程序设计（JAVA）第四周学习总结”存在问题的反馈
对于“2017面向对象程序设计(JAVA)第四周学习总结”存在问题的反馈 “这部分同学博文总结没有写,实验作业没有提交.”——1.关于博文作业.实验作业教学功能的正解:学习知识.暴露问题.衔接课上.2 ...
- 201871010106-丁宣元 《面向对象程序设计（java)》第四周学习总结
201871010106-丁宣元 <面向对象程序设计(java)>第四周学习总结 正文开头 项目 内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-da ...
- 20155318 2016-2017-2 《Java程序设计》第九学习总结
20155318 2016-2017-2 <Java程序设计>第九学习总结 教材学习内容总结 学习目标 了解JDBC架构 掌握JDBC架构 掌握反射与ClassLoader 了解自定义泛型 ...
- 《Java程序设计》第二学习总结
<Java程序设计>第二学习总结 教材学习内容总结 类型 byte(字节) shot(短整型) int(整型) long(长整型) float(浮点型) double(双精度) char( ...
- 20145304 刘钦令 Java程序设计第二周学习总结
20145304 <Java程序设计>第2周学习总结 教材学习内容总结 java可区分基本类型和类类型(即参考类型)两大类型系统. 基本类型主要可区分为整数.字节.浮点数.字符与布尔. 整 ...
- 20145304 刘钦令 Java程序设计第一周学习总结
20145304<Java程序设计>第1周学习总结 教材学习内容总结 1995年5月23日,是公认的Java的诞生日,Java正式由Oak改名为Java. Java的三大平台是:Java ...
- 20145120黄玄曦 《java程序设计》 寒假学习总结
1和2.我对未来规划不多,我认为好好学习积累知识能帮助我应对未来的挑战,这是我的学习动力之一,此外,了解新知识满足好奇心也是我的主要的学习动力. 3.我认为专业课学习比公务员考试重要,我认为专业知识是 ...
- 201621123007 Java程序设计第一周 学习总结
第一周-Java基本概念 201621123007 <Java程序设计> 第一周学习总结 1. 本周学习总结 java是面向对象的一类语言,三大特征:封装性,继承性,多态性. jdk jr ...
随机推荐
- linux的/etc/hosts的作用
转自:http://blog.chinaunix.net/uid-28559065-id-4145820.html linux /etc/hosts文件作用 分类: LINUX linux /e ...
- java面向对象、构造方法 之内部类
UML类图 UML Unified Modeling Language (UML)又称统一建模语言或标准建模语言 在一个类中 属性表示这类事物的性质(描述它的数据) 方法表示这类 ...
- Code Force 21B Intersection
B. Intersection time limit per test1 second memory limit per test256 megabytes inputstandard input o ...
- lightoj1132—Summing up Powers （取膜技巧&&组合数应用）
题目链接:https://vjudge.net/problem/LightOJ-1132 题目意思:(1K + 2K + 3K + ... + NK) % 232 矩阵快速幂的题目一般都很短,这道题也 ...
- fastjson的deserializer的主要优化算法
JSON最佳实践 | kimmking's blog http://kimmking.github.io/2017/06/06/json-best-practice/ Fastjson内幕 Java综 ...
- Django系列
1.Django框架 2.Django restframework 其他 django之contenttype
- 【opencv入门篇】 10个程序快速上手opencv【上】
导言:本系列博客目的在于能够在vs快速上手opencv,理论知识涉及较少,大家有兴趣可以查阅其他博客深入了解相关的理论知识,本博客后续也会对图像方向的理论进一步分析,敬请期待:) PS:官方文档永远是 ...
- Purpose of ContextLoaderListener in Spring
The ApplicationContext is where your Spring beans live. The purpose of the ContextLoaderListener is ...
- MongoDB简单CRUD场景
MongoDB简单CRUD命令操作 (1)新建数据库:use 数据库名 (2)显示所有数据库:show dbs; (3)新建集合(两种方式) 隐式创建:在创建集合的同时往集合里面添加数据---db. ...
- tcp五层模型
物理层由来:上面提到,孤立的计算机之间要想一起玩,就必须接入internet,言外之意就是计算机之间必须完成组网 物理层功能:主要是基于电器特性发送高低电压(电信号),高电压对应数字1,低电压对应数字 ...