面向对象第三天

继承

继承：

1.extends

2.重写(两同两小一大）

3.super关键字(this)

super:

• -调用父类的成员变量
• -调用父类的实例方法
• -调用父类的构造方法

4.（重点）一个类中如果没有手动添加构造方法，则会提供一个默认的无参构造

一个类中如果手动添加了构造方法，则不会提供默认的无参构造

子类的构造方法中的第一句话一定隐藏了一个super()在调用父类的无参构造

​ 在子类的构造方法中手动调用了父类的构造方法（无参或者有参），那么在第一句话不会默认调 用父类的无参构造了

​ 注意：同this一样，我们调用父类的构造方法的时候，一定只能在代码的第一行调用

this()调用构造方法的时候必须在第一行

super()调用的时候也必须在第一行

注意：在子类的同一个方法中不能同时出现this和super

5.继承的特点

• 继承具有传递性

例如：Boo extends Aoo Coo extends Boo 那么Coo就具有Aoo里面公共的属性和行为

• 继承之后，子类就具备了父类当中所有的共有的属性和行为

• 类只能单一继承（一个类只能继承一个类）

Aoo

/**
 * Object:是所有引用类型的父类
 * 
 *
 */
public class Aoo {
     public int a;
     public int b;
     
     public Aoo() {
    	 System.out.println("Aoo的无参构造");
     }
     public Aoo(int a,int b) {
    	 this.a=a;
    	 this.b=b;
    	 System.out.println("Aoo的有参构造");
     }
	@Override
	public String toString() {
		return "Aoo [a=" + a + ", b=" + b + "]";
	}
     
}

Boo

public class Boo extends Aoo{
	public int c;
       public Boo() {
    	   super(10,20);
    	   System.out.println("Boo的无参构造");
       }
       public Boo(int c) {
    	   this();
    	   this.c=c;
    	   System.out.println("Boo的有参构造");
       }
}

Coo

public class Coo extends Boo{

}

Demo1

public class Demo1 {
    public static void main(String[] args) {
		/*Aoo aoo=new Boo(10);
		Aoo app=new Boo();*/
    	//默认调用toString方法
    	Aoo aoo=new Boo();
    	Aoo aoo2=new Coo();
    	/**
    	 * 因为我们要将aoo2变量强制转换成Boo类型，所以要判断
    	 * 判断aoo2变量所指的对象是否是Boo类的子类对象或者本类对象
    	 */
    	if(aoo2 instanceof Boo) {//A instanceof B
    		System.out.println("true");
    		Boo boo=(Boo)aoo2;//Boo boo=new Coo();
    	}
    	
    	Boo boo=(Boo)aoo2;
    }
}

6.向下造型：（转换类型）

instanceof:会返回一个boolean类型的值

例如：A instanceof B

如果要将A变量强制转换为B类型，那么就需要上面的条件来判断

ClassCastException//类型转换异常
NullPointerException//空指针异常
ArrayIndexOutOfBoundsException//下标越界

判断A变量所指的对象是否是B的子类或者本类对象

如果是，则返回true，如果不是，则返回false

注意：一般在进行向下造型的时候，必须进行instanceof判断，才能进行强制转换，否则会抛出异

常

TuxXing

/**
 * 创建一个图形类
 * 
 *
 */
public class TuxXing {
     public int c;
	/*public double area(){
		return 0.0;
	}*/
}

YuanXing

/**
 * 圆形类
 * 假设圆形的面积计算公式：
 * 周长*周长*周长*0.0258
 *
 */
public class YuanXing extends TuxXing{
     public int c;//周长

	public YuanXing(int c) {
		super();
		this.c = c;
	}
     
	/**
	 * 圆形的面积计算公式
	 */
	
	public double area2() {
		return c*c*c*0.0258;
	}
}

FangXing

/**
 * 方形类
 * 假设所有的方形面积计算公式是：
 * 周长*周长*周长*0.052
 *
 */
public class FangXing extends TuxXing{
        public int c;//周长
        
        
        public FangXing(int c) {
			this.c = c;
		}


		/**
         * 方形类中计算面积的方法
         * 
         */
        public double area1() {
        	return c*c*c*0.052;
        }
}

Test

public class Test {
	  public static void main(String[] args) {
		/**
		 * 已知三个方形的周长分别是5,6,7
		 * 求出三个方形中最大的面积是多少？
		 * 
		 * 已知几个圆形的周长分别是11,12,13,14,15
		 * 求出圆形最大的面积是多少？
		 */
		/* FangXing [] fx=new FangXing[5];
		 fx[0]=new FangXing(5);
		 fx[1]=new FangXing(6);
		 fx[2]=new FangXing(7);
		 fx[3]=new FangXing(8);
		 fx[4]=new FangXing(9);
		//假设数组中的第一个方形的面积为最大值
		 double max=fx[0].area();
		 for(int i=0;i<fx.length;i++) {
		  double d=fx[i].area();
		  if(max<d) {
			  max=d;
		  }		  
		 }
		 System.out.println(max);
		 
		 
		 YuanXing [] yx = new YuanXing[5];
		 yx[0]=new YuanXing(11);
		 yx[1]=new YuanXing(12);
		 yx[2]=new YuanXing(13);
		 yx[3]=new YuanXing(14);
		 yx[4]=new YuanXing(15);
		 double ymax=yx[0].area();
		 for(int i=0;i<yx.length;i++) {
		  double y=yx[i].area();
		  if(ymax<y) {
			  ymax=y;
		  }
		 }
		 System.out.println(ymax);
		 
		 if(max<ymax) {
		  System.out.println("最大面积是"+ymax);
		 }else {
		  System.out.println("最大面积是"+max);
		 }*/
		  
		  TuxXing [] tx=new TuxXing[10];
		  tx[0]=new FangXing(5);
		  tx[1]=new FangXing(6);
		  tx[2]=new FangXing(7);
		  tx[3]=new FangXing(8);
		  tx[4]=new FangXing(9);
		  tx[5]=new YuanXing(11);
		  tx[6]=new YuanXing(12);
		  tx[7]=new YuanXing(13);
		  tx[8]=new YuanXing(14);
		  tx[9]=new YuanXing(15);
		  
		  //double max=tx[0].area();
		  double max=0;
		  for(int i=0;i<tx.length;i++) {
			  double d=0;
			  if(tx[i] instanceof FangXing) {
				  FangXing fx=(FangXing)tx[i];
				  d=fx.area1();
			  }
			  if(tx[i] instanceof YuanXing) {
				  YuanXing fx=(YuanXing)tx[i];
				  d=fx.area2();
			  }
			  //double d=tx[i].area();
			  if(max<d) {
				  max=d;
			  }
		  }
		  System.out.println("所有图形的最大面积为："+max);
	}
}

俄罗斯方块概念案例

cell

 */
public class Cell {
    public int x;//表示x坐标
    public int y;//表示y坐标
	public Cell(int x, int y) {
		super();
		this.x = x;
		this.y = y;
	}
	
	@Override
	public String toString() {
		return "(" + x + "," + y + ")";
	}
    
    

Test2

package day10;

public class Test2 {
	public static void main(String[] args) {
		/*Cell cell=new Cell(1,2);
		Cell cell2=new Cell(2,2);
		Cell cell3=new Cell(3,2);
		Cell cell4=new Cell(2,3);*/
		Cell[] c=new Cell[4];
		c[0]=new Cell(1,2);
		c[1]=new Cell(2,2);
		c[2]=new Cell(3,2);
		c[3]=new Cell(2,3);
		printCell(c);
		//已知L图形的一个点坐标为(2,2)
		System.out.println("$$$$$$$$$$$$$$$$$$$$$$$$$$$");
		Cell[] c2=new Cell[5];
		c2[0]=new Cell(2,2);
		c2[1]=new Cell(2,3);
		c2[2]=new Cell(2,4);
		c2[3]=new Cell(3,4);
		c2[4]=new Cell(4,4);
		printCell(c2);
		//System.out.println(cell);
		/*
		 * 打印游戏背景墙 10*20
		 * -------
		 * --***--
		 * ---*---
		 * 
		 * 再打印一个L的图形
		 * -------
		 * --*----
		 * --*----
		 * --***--
		 */
		/*for(int i=0;i<10;i++){//表示行(y坐标值)
			for(int j=0;j<20;j++){//表示列(x坐标值)
				if((i==cell.y && j==cell.x) ||
					(i==cell2.y && j==cell2.x)||
					(i==2 && j==3)||
					(i==3 && j==2)){
					System.out.print("*");
				}else{
					System.out.print("-");
				}
			}
			System.out.println();
		}*/
	}
	public static void printCell(Cell[] cell){
		for(int i=0;i<10;i++){//表示行(y坐标值)
			for(int j=0;j<20;j++){//表示列(x坐标值)
				//定义开关,如果不打印*的话,才打印-
				boolean flag=false;
				//遍历cell数组,找里面的点坐标
				for(int k=0;k<cell.length;k++){
					//判断数组中每个点是否有被找到
					if((i==cell[k].y && j==cell[k].x)){
						    //找到了就打印
							System.out.print("*");
							//将开关状态改变
							flag=true;
					}
				}
				//先判断开关是否被改变,如果没被改变过,才打印-
				if(!flag){
					System.out.print("-");
				}
			}
			System.out.println();
		}
		
	}
	
}

​ 2021-07-09 19:34