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

缺乏、安全感 2024-04-09 02:02 130阅读 0赞

## 深入继承+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 + "睡觉觉");
    	}
    
    }

### 三、方法的重写/复写 ###

#### 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.含义：规定使用范围权限 ####

<table> 
 <thead> 
  <tr> 
   <th align="center">访问修饰符</th> 
   <th align="center">本类中</th> 
   <th align="center">本包中</th> 
   <th align="center">其他包子类中</th> 
   <th align="center">其他包</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">private</td> 
   <td align="center">✔</td> 
   <td align="center"></td> 
   <td align="center"></td> 
   <td align="center"></td> 
  </tr> 
  <tr> 
   <td align="center">默认的</td> 
   <td align="center">✔</td> 
   <td align="center">✔</td> 
   <td align="center"></td> 
   <td align="center"></td> 
  </tr> 
  <tr> 
   <td align="center">protected</td> 
   <td align="center">✔</td> 
   <td align="center">✔</td> 
   <td align="center">✔</td> 
   <td align="center"></td> 
  </tr> 
  <tr> 
   <td align="center">public</td> 
   <td align="center">✔</td> 
   <td align="center">✔</td> 
   <td align="center">✔</td> 
   <td align="center">✔</td> 
  </tr> 
 </tbody> 
</table>

#### 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;
    	}
    }