20155326 2006-2007-2 《Java程序设计》第4周学习总结
2024-08-21 17:56:03
20155326 2006-2007-2 《Java程序设计》第4周学习总结
教材学习内容总结
继承共同行为
（1）继承基本上就是避免多个类间重复定义共同行为，关键词为extends。 （2）继承的三个好处：减少代码冗余；维护变得简单；扩展变得容易。 （3）构造方法不能被继承。
代码及运行结果如下
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;
}
}
class SwordsMan extends Role{
public void fight(){
System.out.println("挥剑攻击");
}
}
class Magician extends Role{
//private String fight;
public void fight(){
System.out.println("魔法攻击");
}
public void cure(){
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.getBlood(),swordsMan.getLevel());
swordsMan.fight();
}
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.getBlood(),magician.getLevel());
magician.fight();
magician.cure();
}
}
多态与is-a：
（1）is-a代表的是类之间的继承关系。中文称为“是一种”关系。 （2）使用是一种原则，就可以判断何时编译成功，何时编译失败。编译程序会检查父子类间的“是一种”关系. （3）子类只能继承一个父类。 （4）检查语法的逻辑是否正确时，方式是从=号右边往左读，判断右边是不是左边的子类，若是，则语法正确，若不是，则不正确。 （5）定义继承需要注意：类与类之间要有是一种（is-a）关系，比如SwordsMan继承了Role，所以SwordsMan is a Role。加上Cast语法，可强制使右边成为左边的子类，但有风险。
代码及运行结果如下
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;
}
}
class SwordsMan extends Role{
public void fight(){
System.out.println("挥剑攻击");
}
}
class Magician extends Role{
//private String fight;
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);
ShowBlood(swordsMan);
ShowBlood(magician);
}
static void ShowBlood(Role role){
System.out.printf("%s的血量为%d%n",rol e.getName(),role.getBlood());
}
}
重新定义行为
（1）重新定义是指在继承父类之后，定义与父类中相同的方法部署，但实行内容不同。 （2）在继承父类之后，定义与父类中相同的方法部署，但执行内容不同，这称为重新定义。 （3）防止因打错字而使程序无法运行，可在重新定义某方法时，加上@Override。 （4）对于父类中的方法权限，只能扩大但不能缩小。若原来成员public，子类中重新定义时不可为private或protected。
代码及运行结果如下
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(){}
}
class SwordsMan extends Role{
public void fight(){
System.out.println("挥剑攻击");
}
}
class Magician extends Role{
//private String fight;
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.println(role.getName());
role.fight();
}
}
抽象方法、抽象类：
（1）如果某方法区块中实际上没有撰写任何程序代码，可以使用abstract标示该方法为抽象方法，该方法不用撰写{}区块，直接“；”结束即可。 （2）类中若有方法没有操作，并且标示为abstract,表示这个类定义不完整，定义不完整的类不能生成实例。Java中规定内含抽象方法的类，一定要在class前标示abstract,表示这是一个不完整的抽象类。 （3）子类如果继承抽象类，对于抽象方法有两种做法：一是做法是继续标示该方法为abstract，该子类也是个抽象类，必须在class前标示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 String toString(){
return
String.format("(%s,%d,%d)%n",this.name,this.blood,this.level);
}
}
class SwordsMan extends Role{
public void fight(){
System.out.println("挥剑攻击");
}
public String toString(){
return "剑士"+super.toString();
}
}
class Magician extends Role{
private String fight;
public void fight(){
System.out.println("魔法攻击");
}
public void cure(){
System.out.println("魔法治疗");
}
public String toString()
{ return "魔法师"+super.toString();
}
}
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);
System.out.println(magician.toString() );
System.out.println(swordsMan.toString( ));
}
}
protected的成员
（1）被声明为protected的成员，相同包中的类可以直接存取，不同包中的类可以在继承后的子类直接存取。 （2）权限关键字与范围 关键字 类内部 相同包类 不同包类 public 可存取 可存取 可存取 protected 可存取 可存取 子类可存取 private 可存取 不可存取 不可存取 （3）依权限小至大来区分，就是private、无关键字、protected与public，设计时要使用哪个权限，是依经验或团队讨论而定，如果一开始不知道使用哪个权限就先使用private，以后视需求再开放权限。
重新定义的细节
（1）在java中，如果想取得父类中的方法定义，可以在调用方法前，加上super关键字。 （2）对于父类中的方法权限，只能扩大但不能缩小。若原来成员public，子类中重新定义时不可为private或protected。
再看构造函数
（1）如果类有继承关系，在创建子类实例后，会先进行父类定义的初始流程，再进行子类中的初始流程，也就是创建子类实例后，会先执行父类构造函数定义的流程，再执行子类构造函数定义的流程。
（2）构造函数可以重载，父类中可重载多个构造函数，如果子类构造函数中没有指定执行父类中哪个构造函数，默认会调用父类中无参数构造函数。
(3) this()与super()只能择一调用，而且一定要在构造函数第一行执行。
再看final关键字
（1）如果在指定变量值之后，就不想再改变变量值，可以在声明变量时加上final限定。
（2）如果对象数据成员被声明为final，但没有明确使用=指定值，那表示延迟对象成员值的指定，在构造函数执行流程中，一定要有对该数据成员指定值的动作，否则编译错误。
（3）如果class前使用了final关键字定义，那么表示这个类是最后一个了，不会再有子类，也就是不能被继承。
（4）定义方法时，也可以限定该方法为final，这表示最后一次定义方法了，也就是子类不可以重新定义final方法。
（5）子类不可以重新定义final方法，会发生编译错误。
- java.lang.Object
（1）在java中，子类只能继承一个父类，如果定义类时没有使用extends关键字指定继承任何类，那就是继承java.lang.Object。相当于public class Some Object{...}
（2）在java中，任何类型的对象，都可以使用Object声明的名称来参考。
（3）java.lang.Object是所有类的顶层父类，这代表了object上定义的方法，所有对象都继承下来了，只要不是被定义成final方法。
- 代码及运行结果如下
import java.util.Arrays;
import java.util.Scanner;
import static java.lang.System.out;
import static java.lang.System.setOut;
class ArrayList{
private Object[] list;
private int next;//下一个对象的索引
public ArrayList(int
capacity){//指定初始容量
list =new Object[capacity];
}
public ArrayList(){//初始容量默认为16
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;
}
}
public class Guest {
public static void main(String[] args) {
ArrayList names=new ArrayList();
collectNameTo(names);
System.out.println("访客名单");
printUpperCase(names);
}
static void collectNameTo(ArrayList names){
Scanner console=new Scanner(System.in);
String name;
while(true){
System.out.print("访客名称：");
name =console.nextLine();
if(name.equals("quit")){
break;
}
else{
names.add(name);
}
}
}
static void printUpperCase(ArrayList names){
for(int i=0;i<names.size();i++){
String name=(String)names.get(i);
System.out.println(name.toUpperCase());
}
}
}
- 关于垃圾收集
（1）如果程序执行流程中无法通过变量参考的某个对象，就是徒耗内存的垃圾。
（2）对于不再有用的对象，JVM有垃圾收集机制（GC），收集到的垃圾对象所占据的内存空间，会被垃圾收集器释放。
再看抽象类
代码及运行结果如下
package week05;
import java.util.Scanner;
abstract class GuessGame{
public void go() {
int number = (int) (Math.random() * 10);
int guess;
do {
print("输入数字");
guess = nextInt();
} while (number != guess);
println("猜中了！");
}
public void println(String text){
print(text+"\n");
}
public abstract void print(String text);
public abstract int nextInt();
}
class ConsoleGame extends GuessGame{
private Scanner scanner=new Scanner(System.in);
@Override
public void println(String text){
System.out.println(text);
}
public void print(String text){
System.out.print(text);
}
public int nextInt(){
return scanner.nextInt();
}
}
public class Guess {
public static void main(String[] args) {
GuessGame game=new ConsoleGame();
game.go();
}
}
- 接口定义行为
（1）接口可以用于定义行为但不定义操作。
（2）类要操作接口，必须使用implements关键字。操作某接口时，对接口中定义的方法有两种处理方式，一是操作接口中定义的方法，二是再度将该方法标示为abstract。
（3）继承会有“是一种”关系，接口操作则表示“拥有行为”，但不会有“是一种”关系。
- 行为的多态
（1）接口多态语法的判断，方式是“右边是不是拥有左边的行为”或者“右边对象是不是操作了左边接口”。
（2）行为的多态使可维护性提高许多。
- 代码及运行结果如下
interface Swimmer {
public abstract void swim();
}
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();
}
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);
}
}
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);
}
}
public class Ocean {
public static void main(String[] args) {
doSwim(new Human("贾斯丁"));
doSwim(new Submarine("黄色一号"));
}
static void doSwim(Swimmer swimmer){
swimmer.swim();
}
}
- 接口语法细节：
（1）在Java中，可使用interface来定义抽象的行为与外观。接口中的方法没有操作时，一定是公开且抽象的，也可省略，编译程序会自动帮你加上public abstract。
（2）在interface中，可以定义常数。
（3）接口中枚举的常数，一定要使用“=”指定值，否则会编译失败。
（4）接口可以继承别的接口，也可以同时继承两个以上的接口，同样也是使用extends关键字，这代表了继承父接口的行为。
- 匿名内部类
（1）临时继承某个类或操作某个接口并建立实例，可使用匿名内部类来解决这个需求。
（2）匿名内部类语法为：new 父类()|接口(){ // 类本体操作 };
- 使用enum枚举常数
（1）enum实际上定义了类，而enum中枚举的常数，实际上是public static final，且为枚举类型实例，无法撰写程序直接实例化枚举类型，因为构造函数权限设定为private，只要类中才可以实例化。如：
import static java.lang.System.out;
public class EnumGame
{
public static void main(String[] args)
{
play(EnumAction.RIGHT);
play(EnumAction.UP);
}
public static void play(EnumAction 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;
}
}
}
（2）enum定义了特殊的类，继承自java.lang.Enum
教材学习中的问题和解决过程
课本上的代码不知道为什么不可以在cmd中运行，但可以在idea中运行。
代码托管
- 代码量截图：
上周考试错题总结
（1）java中成员方法中引用成员变量，要使用（this）关键字。
理解情况：在java中，this()代表了调用另一个构造函数，所以在成员方法中引用成员变量时，需要使用到this关键字。
（2） CH05 判断：Java中方法内可以定义类。（OK）
理解情况：方法中不能直接定义方法，但可以在方法中定义类，类里面再定义方法。
（3）可以使用java.util.Arrays的(fill())方法把数组初始化成相同的值。
理解情况：在java中，fill()方法的作用是将指定的int值赋给数组的每个元素，所以可以用java.util.Arrays的(fill())方法把数组初始化成相同的值。
（4）“30”转化为byte类型的30的语句是（Byte.parseByte(“30”);）
理解情况：在java中，java.lang.Byte.parseByte()方法的作用是将字符串参数转换为带符号的十进制数。
其他（感悟、思考等，可选）
已经写到第四周的java学习总结了，这周学习了继承与多态、接口与多态这些内容，这些比起之前接触的知识可以使用户使用时更加方便，也更便于编程人员维护。但对于书上一些内容，我的理解不够透彻，还需多多看书，多多敲代码。在学习中我发现这两章书上的代码不是独立的，要几组代码组合在一起才能运行。
学习进度条
| 代码行数（新增/累积） | 博客量（新增/累积） | 学习时间（新增/累积） | 重要成长 | |
|---|---|---|---|---|
| 目标 | 5000行 | 15篇 | 400小时 | |
| 第一周 | 20/20 | 1/1 | 20/20 | 安装了各种程序 |
| 第二周 | 126/100 | 1/1 | 25/25 | 掌握了托管代码 |
| 第三周 | 197/200 | 1/1 | 30/30 | 大体了解java的对象和对象封装 |
| 第四周 | 533/500 | 1/1 | 45/40 | 知道了继承接口等 |
计划学习时间:40小时
实际学习时间:45小时
最新文章
- 手机软件Toast无法显示提示信息
- TNS-12518 & Linux Error：32：Broken pipe
- LeetCode —— Invert Binary Tree
- CentOS下vm虚拟机桥接联网
- 关于表格前面checkbox复选框不打勾的问题
- sed命令实战
- 成功完成Moses Manual中BaseLineSystem
- 【wpf WebBrowser 清空网站的Cookie&Session 清空用户登录状态】
- 加密解密(9)Diffie-Hellman密钥交换协议
- SharePoint 2010 列表项事件接收器 ItemAdded 的使用方法
- cocos2d-x实战 C++卷 学习笔记--第6章 场景与层
- [ES6] Export class and variable
- WPF之TabControl控件用法
- MVPHelper更新日志 --- 新增常规分包模式
- Java开源生鲜电商平台-安全设计与架构(源码可下载）
- Cesium3DTileset示例
- July 算法习题 - 字符串4（全排列和全组合）
- Learn how to use git
- 人脸识别准备 -- 基于raspberry pi 3b + movidius
- 原生js轮播图实现