第七章总结

继承（extends），多态，抽象类与接口

一，继承

1，Java语言每个类只能继承一个父类

2，父类 和普通类写法相同

public class 父类类名{

}

3，子类

public  class  子类类型 extends  父类类名{

}

例题7.1：

 例题7.2：

public class telephone {//电话类
	String button = "button:0~9";//成员属性，10个按键
	void call() {//拨打电话功能
		System.out.println("开始拨打电话");
	}
}

public class mobile extends telephone {//手机类继承电话类
	String screen = "screen:液晶屏";//成员属性，液晶屏幕
	
}

public class demo2 {
 
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		mobile motto = new mobile();
		System.out.println(motto.button);//子类调用父类属性
		System.out.print(motto.screen);//子类调用父类没有的属性
		motto.call();//子类调用父类方法
	}
 
}

4，所有类的构造方法第一行都有一个隐藏的" super()；"

作用是在执行该构造方法之前调用其父类的构造方法。

二，ob ject 类
1，getClass()的方法：是Object类定义的方法，它会返回对象执行时的Class实例

getClass().getname();

2,toString()方法：将一个对象返回为字符串形式，它会返回一个String实例。

3，方法的重写：

返回参数相同  方法名相同  传入参数相同  方法体

例题7.3：

 4，equals方法：有两种比较对象的方式，分别为“==”运算符与equals（）方法。

例题7.4代码与结果：

public class people {
	int id;//身份证号
	String name;//名字
	
	public people(int id,String name) {
		this.id = id;
		this.name = name;
		
	}
	public boolean equals(Object obj) {//重写object类的equals（）方法
		if(this==obj)//如果参数与本类是同一个对象
			return true;
		if(obj==null)//如果参数是null
			return false;
		if(getClass()!=obj.getClass())//如果参数与本类类型不同
			return false;
		people other = (people)obj;//将参数强转成本类对象
		if(id!=other.id)//如果两者的身份证号不相等
			return false;
		return true;
	}
		
	public String toString() {//重写object类的toString（）方法
		return name;//只输出名字
	}
	public static void main(String[]age) {
		people p1 = new people(220,"tom");
		people p2 = new people(220,"汤姆");
		people p3 = new people(330,"张三");
		Object o = new Object();
		
		System.out.println(p1+"与"+p2+"是否为同一个人？");
		System.out.println("equals()方法的结果："+p1.equals(p2));
		System.out.println("==运算符的结果："+(p1==p2));
		
		System.out.println();
		System.out.println(p1+"与"+p3+"是否为同一个人？");
		System.out.println(p1.equals(p3));
		
		System.out.println(p1+"与"+o+"是否为同一个人？");
		System.out.println(p1.equals(o));
	}
}

三，对象类型的转换

1，向上转型：子类对象赋值给父类引用 （自动转换）

animal a = new dog();

2，向下转型：父类对象赋值给子类引用（需要进行强制转换）

dog a = (dog) new animal();

例题7.6：

 五，方法的重载

重写:（子类—父类） 参数相同  方法名相同  传入参数相同  只有方法体不同

重载：方法名相同，参数不同

例题7.8：

public static int add(int a,int b) {//定义一个方法
		return a+b;
	}
	public static double add(double a,double b) {//与第一个方法名相同，参数类型不同
		return a+b;
	}
	public static int add(int a) {//与第一个方法参数个数不同
	return a;
	}
	public static int add(int a,double b) {//先int参数，后double参数
		return a;//输出int参数值
	}
	public static int add(double a,int b) {//先double参数，后int参数
		return b;//输出int参数值
	}
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		System.out.println("调用add(int,int)方法："+add(1,2));
		System.out.println("调用add(double,double)方法："+add(2.1,3.3));
		System.out.println("调用add(int)方法："+add(1));
		System.out.println("调用add(int,double)方法："+add(5,8.0));
		System.out.println("调用add(double,int)方法："+add(5.0,8));
	}
 
}

 例题7.9：

 

六，final关键字

1，final修饰变量----不可以被修改（常量）

例题7.10

public class FinalData {
	static final double PI=3.1415926;
 
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		System.out.println("圆周率的值为："+PI);
		System.out.println("半径为3的圆的周长："+(2*3*PI));
		PI=3.1415927;
	}
 
}

2，final修饰方法-----不可以被重写

例题7.11

public class Dad {
	public final void turnOnTheTV() {
		System.out.println("爸爸打开了电视");
	}
}
class Baby extends Dad{
	public final void turnOnTheTV() {
		System.out.print("宝宝也要打开电视");
	}
}

3，final修饰类-----不可以被继承

七，使用instanceof关键字判断对象类型

语法格式：

myobject instanceof ExampleClass
myobject:某类的对象引用
ExampleClass:某个类

1，对象名  instanceof  类名

判断对象是否属于该类或子类

例题7.7

class Quadrangle{}//创建一个四边形类
class Square extends Quadrangle{}//正方形继承四边形
class Circilar{}//创建圆形类
 
public class Demo5 {
 
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Quadrangle q = new Quadrangle();//四边形对象
		Square s = new Square();//正方形对象
		System.out.println(q instanceof Square);//判断四边形是否为正方形的子类
		System.out.println(s instanceof Quadrangle);//判断正方形是否为四边形的子类
		System.out.println(q instanceof Circular);//判断正方形是否为圆形的子类
	}
 
}

八，多态

public void draw(Square){//绘制正方形的方法
}
public void draw(Circlar c){//绘制圆形的方法
}

例题7.12

class Shape{}//图形类
class S extends Shape{}//正方形类继承图形类
class Circular extends Shape{}//圆形类继承图形类
 
public class Demo6 {
	public static void draw(Shape s) {//绘制方法
		if(s instanceof S) {//如果是正方形
			System.out.println("绘制正方形");
		}else if (s instanceof Circular) {//如果是圆形
			System.out.println("绘制圆形");
		}else {//如果是其他类型
			System.out.println("绘制父类图形");
		}
	}
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		draw(new Shape());
		draw(new S());
		draw(new Circular());
 
	}
 
}

九，抽象类与接口

一，抽象类

1，抽象方法

修饰符  abstract  返回参数  方法名（传入参数）；

2，抽象类 ：有抽象方法的类一定是抽象类

修饰符  abstarct  class 类名{

}

如果代码中有抽象方法：1，把普通方法改成抽象方法  2，把抽象方法改成普通方法

 使用场景：由于继承中，父类制定规则，子类继承（如继承普通方法一定要重写）

二，接口

1，所有方法都是抽象方法

修饰符  interface 接口名{

}

2，Java语言每个类可以实现多个接口

3，实现：implements

修饰符  class  类名  implements  接口1，接口2，....，{

}

4，如果代码中有三个抽象代码，但只实现两个，解决方法为：

a，重写那个没有实现的抽象代码

b，把类改成抽象类 

例题7.13
 

interface Paint{//可绘制接口
 public void draw();//绘制抽象方法
}
class Qu{//四边形类
 public void doAnytihing() {
  System.out.println("四边形提供的方法");
 }
}
//平行四边形类，继承四边形类，并实现可绘制接口
class Par extends Qu implements Paint{
 public void draw() {
  //由于该类
  System.out.println("绘制平行四边形");
 }
}
//正方形类，继承四边形类，并实现可绘制接口
class Sq extends Qu implements Paint{
 public void draw() {
  System.out.println("绘制正方形");
 }
}
//圆形类，仅实现可绘制接口
class Cir implements Paint{
 public void draw() {
  System.out.println("绘制圆形");
 }
}
public class Pa {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Sq s=new Sq();
  s.draw();
  s.doAnytihing();
  Par p=new Par();
  p.draw();
  p.doAnytihing();
  Cir c = new Cir();
  c.draw();
 }
 
}