深入继承+super关键字+方法重写+访问修饰符及五子棋

雨霖先森 2022-10-08 01:46:51

深入继承+super关键字+方法重写+访问修饰符及五子棋

一、深入继承

1.创建子类对象,会不会调用父类的构造方法?

2.创建子类对象,调用父类构造方法的目的是什么?

目的是将父类的成员变量添加到子类对象中

3.创建子类对象,会不会创建父类对象?

不会

4.创建子类对象,先调用父类构造方法还是子类构造方法?

先调用子类构造方法

5.创建子类对象,先完成父类构造方法还是子类构造方法?

先完成父类构造方法

6.子类可以继承父类私有化的属性吗?

可以,但是不能直接调用,可以间接调用

注意:一个类只能继承一个类(单继承关系)

public class Test01 {
​
        public static void main(String[] args) {
            
                  Son son = new Son();
        }
}
public class Son extends Father {
    
    public Son(){
        //调用父类的无参构造(默认实现)
        //super();
        System.out.println("子类的构造方法");
    }
}
public class Father {
​
    public Father(){
        System.out.println("父类的构造方法");
    }
}

二、super关键字 - 父类的

1.super.属性:在子类中调用父类公有的成员变量

2.super.方法:在子类中调用父类公有的成员方法

3.super():在子类构造方法中调用父类公有的构造方法

需求:编写中国人和日本人的类

public class Test01 {
​
     public static void main(String[] args) {
        
        Chinese c = new Chinese("张三丰",'男',120,"123456789");
        
        c.eat();
        c.sleep();
        c.playTaiji();
        
        System.out.println("-----------------");
        
        Japanese j = new Japanese("波多",'女',18,"昭和");
        
        j.eat();
        j.sleep();
        j.playVideo();
    }
}
public class Person {
    
    private String name ;
    private char sex;
    private int age;
    public Person() {
        
    }
    public Person(String name, char sex, int age) {
        super();
        this.name = name;
        this.sex = sex;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public char getSex() {
        return sex;
    }
    public void setSex(char sex) {
        this.sex = sex;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
    public void eat(){
        System.out.println(this.name + "吃饭饭");
    }
    
    public void sleep(){
        System.out.println(this.name + "睡觉觉");
    }
​
}
public class Chinese extends Person {
​
        private String id;
        public Chinese() {
            
        }
        public Chinese( String name,char sex,int age,String id) {
            super(name,sex,age);
            this.id = id;
        }
        public String getId() {
            return id;
        }
        public void setId(String id) {
            this.id = id;
        }
        
        public void playTaiji(){
            System.out.println(super.getName() + "打太极");
        }
}
​
public class Japanese extends Person {
    
    private String yearNum;
    
    public Japanese() {
    }
​
    public Japanese(String name, char sex, int age, String yearNum) {
        super(name, sex, age);
        this.yearNum = yearNum;
    }
​
    public String getYearNum() {
        return yearNum;
    }
​
    public void setYearNum(String yearNum) {
        this.yearNum = yearNum;
    }
    
    public void playVideo(){
        System.out.println(this.getName() + "拍视频");
    }
}

三、方法的重写/复写

1.含义:将父类中的方法在子类中重新写一遍

2.条件:

1.在子类中重写

2.返回值、方法名、参数列表必须和父类的方法一致

3.访问修饰符不能比父类更严格

3.应用场景:父类方法不满足子类需求时,使用重写

public class Test01 {
​
    public static void main(String[] args) {
        
        Chinese c = new Chinese("张三丰", '男', 120, "123456789");
        
        c.eat();
        c.sleep();
        c.playTaiji();
        
        System.out.println("--------------------");
        
        Japanese j = new Japanese("波多", '女', 18, "昭和");
        
        j.eat();
        j.sleep();
        j.playVideo();
        
        
    }
}
public class Person {
​
    private String name;
    private char sex;
    private int age;
    
    public Person() {
        
    }
​
    public Person(String name, char sex, int age) {
        super();
        this.name = name;
        this.sex = sex;
        this.age = age;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public char getSex() {
        return sex;
    }
​
    public void setSex(char sex) {
        this.sex = sex;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
    
    public void eat() {
        System.out.println(this.name + "吃饭饭");
    }
​
    public void sleep() {
        System.out.println(this.name + "睡觉觉");
    }
}
public class Chinese extends Person {
​
        private String id;
        
        public Chinese() {
            
        }
​
        public Chinese(String name, char sex, int age, String id) {
            super(name, sex, age);
            this.id = id;
        }
​
        public String getId() {
            return id;
        }
​
        public void setId(String id) {
            this.id = id;
        }
        
        public void playTaiji(){
            System.out.println(this.getName() + "打太极");
        }
        
        //@Override --重写的注解(表示该方法是重写父类的方法)
        @Override
        public void eat(){
            System.out.println(super.getName() + "吃山珍海味");
        }
}
public class Japanese extends Person{
​
    private String yearNum;
    
    public Japanese() {
    }
    
    public Japanese(String name, char sex, int age, String yearNum) {
        super(name, sex, age);
        this.yearNum = yearNum;
    }
​
    public String getYearNum() {
        return yearNum;
    }
​
    public void setYearNum(String yearNum) {
        this.yearNum = yearNum;
    }
​
    public void playVideo(){
        System.out.println(this.getName() + "拍视频");
    }
    
    //@Override --重写的注解(表示该方法是重写父类的方法)
    @Override
    public void eat() {
        System.out.println(super.getName() + "吃马赛克");
    }
}

四、访问修饰符

1.含义:规定使用范围权限

访问修饰符本类中本包中其他包子类中其他包
private   
默认的  
protected 
public

2.注意:

1.做实验学习

2.访问修饰符可以修饰属性和方法

3.public和默认的访问修饰符可以修饰类

3.经验:

1.属性一般使用private,配合着封装(get/set)

2.子类中才能使用的属性就用protected修饰

public class Test01 {
    public static void main(String[] args) {
        
        A a = new A();
        
        System.out.println(a.str);
    }       
}
public class A {
​
        protected String str = "用真心待人";
        
        public void method(){
            System.out.println(str);
        }
}

五、面向对象版的五子棋

import java.util.Scanner;
​
public class Test01 {
    
    public static void main(String[] args) {
        
        //定义长度
        int len = 20;
        //棋盘容器
        String[][] goBang = new String[len][len];
        //定义棋盘符号
        String add = "╋";
        String black = "■";
        String white = "○";
        //坐标的容器
        String[] indexs = {"⒈","⒉","⒊","⒋","⒌","⒍","⒎","⒏","⒐","⒑","⒒","⒓","⒔","⒕","⒖","⒗","⒘","⒙","⒚","⒛"};
        
        //初始化棋盘容器中的符号----------------------------------------------------------------
        
        //解决方案1:
//      //循环取出二维数组中的一维数组
//      for (int i = 0; i < goBang.length; i++) {
//          //把当前一维数组的每个元素都替换成加号
//          Arrays.fill(goBang[i], add);
//          
//          //设置每个一维数组最后一个元素为坐标
//          goBang[i][len-1] = indexs[i];
//      }
//      //循环遍历二维数组中最后一个一维数组的元素,并设置坐标
//      for(int i = 0;i<goBang[len-1].length;i++){
//          goBang[len-1][i] = indexs[i];
//      }
        
        //解决方案2:
        for (int i = 0; i < goBang.length; i++) {
            for (int j = 0; j < goBang[i].length; j++) {
                if(j == len-1){//每行的最后一列
                    goBang[i][j] = indexs[i];
                }else if(i == len-1){//最后一行
                    goBang[i][j] = indexs[j];
                }else{
                    goBang[i][j] = add;
                }
            }
        }
        
        //----------------------------------------------------------------
        
        //打印棋盘
        for (String[] ss : goBang) {
            for (String element : ss) {
                System.out.print(element);
            }
            System.out.println();
        }
        
        //循环输入坐标
        Scanner scan = new Scanner(System.in);
        boolean flag = true;//true-黑子 false-白子
        while(true){
            
            System.out.println("请" + ((flag)?"黑":"白") + "子输入坐标(x,y):");
            int x = scan.nextInt() - 1;//坐标从1开始,下标从0开始,所以要减1
            int y = scan.nextInt() - 1;//坐标从1开始,下标从0开始,所以要减1
            
            //判断坐标是否超出棋盘范围
            if(x < 0 || x > len-2 || y < 0 || y > len-2){
                System.out.println("输入错误 - 坐标超出棋盘范围,请重新输入...");
                continue;
            }
            
            //判断坐标上是否有棋子
            if(!goBang[x][y].equals(add)){
                System.out.println("输入错误 - 坐标有棋子,请重新输入...");
                continue;
            }
            
            //落子
            goBang[x][y] = (flag)?black:white;
            
            //置反
            flag = !flag;
            
            //打印棋盘
            for (String[] ss : goBang) {
                for (String element : ss) {
                    System.out.print(element);
                }
                System.out.println();
            }
        }
        
    }
}
​
public class GoBang {
        
    //定义长度
    private int len = 20;
    //棋盘容器
    private String[][] goBang = new String[len][len];
    //定义棋盘符号
    private String add = "╋";
    private String black = "■";
    private String white = "○";
    
    //坐标的容器
    private String[] indexs = {"1","2","3","4","5","6","7","8","9","10","11","12","13","14","15","16","17","18","19","20"};
    
    public GoBang(){
        
        //初始化棋盘
        init();
        //打印棋盘
        printGoBang();
    }
    
    //初始化棋盘
    private void init(){
        for (int i = 0; i < goBang.length; i++) {
            for (int j = 0; j < goBang[i].length; j++) {
                if (j == len-1) {//每行的最后一列
                    goBang[i][j] = indexs[i];
                }else if (i == len-1) {//最后一行
                    
                    goBang[i][j] = indexs[i];
                }else{
                    goBang[i][j] = add;
                }
            }
        }
    }
    
    //打印棋盘
    public void printGoBang(){
        for (String[] ss : goBang) {
            for (String element : ss) {
                System.out.print(element);
            }
            System.out.println();
        }
    }
    
    //判断坐标是否超出棋盘范围
    private boolean isIndexOutOfGoBang(int x,int y){
        if(x < 0 || x > len-2 || y < 0 || y > len-2){
            return true;
        }
        return false;
    }
    
    //判断坐标上是否有棋子
    private boolean isGoBang(int x,int y){
        if(!goBang[x][y].equals(add)){
            return true;
            
        }
        return false;
    }
    
    /**
     * 落子
     * @param x
     * @param y
     * @param flag
     * @return 返回状态码
     *      -1 落子失败-坐标超出棋盘范围
     *      -2 落子失败-坐标上有棋子
     *       1 落子成功
     */
    public int play(int x,int y,boolean flag){
        
        if (isIndexOutOfGoBang(x,y)) {
            return -1;
        }
        if(isGoBang(x,y)){
            return -2;
        }
        
        goBang[x][y] = (flag)?black:white;
        return 1;
    }
}
...全文
47 回复 打赏 收藏 转发到动态 举报
写回复
用AI写文章
回复
切换为时间正序
请发表友善的回复…
发表回复
1.1 Java语言发展简史2 1.2 认识Java语言3 1.2.1 Java语言特性3 1.2.2 JavaApplet4 1.2.3 丰富的类库4 1.2.4 Java的竞争对手5 1.2.5 Java在应用领域的优势7 1.3 Java平台的体系结构7 1.3.1 JavaSE标准版8 1.3.2 JavaEE企业版10 1.3.3 JavaME微型版11 1.4 JavaSE环境安装和配置12 1.4.1 什么是JDK12 1.4.2 JDK安装目录和实用命令工具介绍12 1.4.3 设置环境变量13 1.4.4 验证配置的正确性14 1.5 MyEcilpse工具介绍JavaSE环境安装和配置15 1.6 本章练习16 第2章 2.1 什么是程序18 2.2 计算机中的程序18 2.3 Java程序19 2.3.1 Java程序中的类型19 2.3.2 Java程序开发三步曲21 2.3.3 开发Java第一个程序21 2.3.4 Java代码中的注释23 2.3.5 常见错误解析24 2.4 Java类库组织结构和文档27 2.5 Java虚拟机简介28 2.6 Java技术两种核心运行机制29 2.7 上机练习30 第3章 3.1 变量32 3.1.1 什么是变量32 3.1.2 为什么需要变量32 3.1.3 变量的声明和赋值33 3.1.4 变量应用实例33 3.2 数据的分类34 3.2.1 Java中的八种基本数据类型34 3.2.2 普及二进制36 3.2.3 进制间转换37 3.2.4 基本数据类型间转换38 3.2.5 数据类型应用实例38 3.2.6 引用数据类型39 3.3 关键字.标识符.常量39 3.3.1 变量命名规范39 3.3.2 经验之谈-常见错误的分析与处理40 3.3.3 Java标识符命名规则41 3.3.4 关键字42 3.3.5 常量42 3.4 运算符43 3.4.1 算术运算符43 3.4.2 赋值操作符45 3.4.3 关系操作符47 3.4.4 逻辑操作符48 3.4.5 位操作符49 3.4.6 移位运算符49 3.4.7 其他操作符50 3.5 表达式52 3.5.1 表达式简介52 3.5.2 表达式的类型和值52 3.5.3 表达式的运算顺序52 3.5.4 优先级和结合性问题52 3.6 选择结构54 3.6.1 顺序语句54 3.6.2 选择条件语句54 3.6.3 switch结构59 3.6.4 经验之谈-常见错误的分析与处理65 3.6.5 Switch和多重if结构比较66 3.7 循环语句66 3.7.1 While循环67 3.7.2 经验之谈-常见while错误70 3.7.3 do-while循环72 3.7.4 for循环74 3.7.5 经验之谈-for常见错误76 3.7.6 循环语句小结78 3.7.7 break语句79 3.7.8 continue语句82 3.8 JavaDebug技术84 3.9 本章练习85 第4章 4.1 一维数组90 4.1.1 为什么要使用数组90 4.1.2 什么是数组91 4.1.3 如何使用数组92 4.1.4 经验之谈-数组常见错误97 4.2 常用算法98 4.2.1 平均值,最大值,最小值98 4.2.3 数组排序102 4.2.3 数组复制103 4.3 多维数组105 4.3.1 二重循环105 4.3.2 控制流程进阶107 4.3.3 二维数组111 4.4 经典算法113 4.4.1 算法-冒泡排序113 4.4.2 插入排序115 4.5 增强for循环116 4.6 本章练习117 第5章 5.1 面向过程的设计思想120 5.2 面向对象的设计思想120 5.3 抽象121 5.3.1 对象的理解121 5.3.2 Java抽象思想的实现122 5.4 封装124 5.4.1 对象封装的概念理解124 5.4.2 类的理解125 5.4.3 Java类模板创建125 5.4.4 Java中对象的创建和使用127 5.5 属性130 5.5.1 属性的定义130 5.5.2 变量131 5.6 方法132 5.6.1 方法的定义132 5.6.2 构造方法135 5.6.4 方法重载138 5.6.5 自定义方法138 5.6.6 系统提供方法139 5.6.7 方法调用140 5.6.8 方法参数及其传递问题144 5.6.9 理解main方法语法及命令行参数147 5.6.1 0递归算法147 5.7 this关键字148 5.8 JavaBean149 5.9 包150 5.9.1 为什么需要包?150 5.9.2 如何创建包151 5.9.3 编译并生成包:151

51,411

社区成员

发帖
与我相关
我的任务
社区描述
Java相关技术讨论
javaspring bootspring cloud 技术论坛(原bbs)
社区管理员
  • Java相关社区
  • 小虚竹
  • 谙忆
加入社区
  • 近7日
  • 近30日
  • 至今
社区公告
暂无公告

试试用AI创作助手写篇文章吧