第七章总结

                                类的继承

继承在程序中复用一些已经定义完善的类，不仅可以减少软件开发周期，也可以提高软件的可维护性和可扩展性。

       子类重写父类的方法：返回参数相同，方法名相同，传入参数相同，只有方法体不同，前提是具有父子关系。

        所有类的构造方法 ，第一行都有一个隐藏的“super();" 作用是在执行该构造方法之前调用其父类的构造方法。

在Java语言中，一个类继承另一个类需要使用关键字extrends,关键字extrends的使用方法如下

class Child extrends Parent{}

 创建子类对象，观察构造方法执行顺序，代码如下：
 

class Parent{
	public Parent() {
		System.out.println("调用父类构造方法");
	}
}
 
class Child extends Parent{
	public Child() {
		System.out.println("调用子类构造方法");
	}
}
 
public class Demo {
	public static void main(String[] args) {
		new Child();
	}
 
}

 子类继承父类之后可以调用父类创建好的属性和方法。

在电话基础上衍生出手机类，代码如下：

class Parent{//父类电话
String button="button:0~9";//成员属性，10个按键
void call() {//拨打电话功能
	System.out.println("开始拨打电话");
}
}
 
class Child extends Parent{//子类手机继承电父类电话
	String screen="screen:液晶屏";//成员属性，液晶屏幕
 
}
 
public class Demo2 {
	public static void main(String[] args) {
		Child motto=new Child();
		System.out.println(motto.button);//子类调用父类属性
		System.out.println(motto.screen);//子类调用父类没有的属性
		motto.call();//子类调用父类方法
	}
}

运行结果：

  Object类

 在开始学习使用class关键字定义类时，就应用到了继承原理，因为在Java中所有的类都直接或间接继承了java.lang.Object类是比较特殊的类，它是所有类的父类，是Java类层中的最高层类。

1、getClass()方法

 getClass()方法是Object类定义的方法，它会返回对象执行时的Class实例，然后使用此实例调用getName()方法可以取得类的名称。语法如下：

 getClass().getname();r

可以将getClass()方法与toString()方法联合使用。

2、toString()方法

toString()方法的功能是将一个对象返回为字符串形式，它会返回一String实例。在实际的应用中通常重写toString（）方法，为对象提供一个特定的输出模式。当这个类转换为字符串或与字符串连接时，将自动调用重写的toString()方法。

让学生自我介绍，创建Child类，重写toString()方法，使该类的对象可以自定义输出自己的姓名和年龄，代码如下：
 

public class Child{
	String name;
	int age;
	public Child(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String toString() {
	return"我叫"+name+",今年"+age+"岁。";
	}
	public static void main(String[] args) {
		Child s1=new Child("张三",16);
		System.out.println(s1);
		Child s2=new Child("李四",19);
		System.out.println(s2);
	}
}

运行结果；

 3、equals()方法

      在Java语言中，有两种比较对象的方式，分别为”==“运算符与equals()方法。两者的区别在于：”==“比较的是两个对象引用内存地址是否相等，而equals()方法比较的是两个对象的实际内容。

根据身份证号判断是否为同一人，用equals()方法和”==“运算符来判断是否存在多个对象代表同一个人，代码如下：

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[] args) {
		People p1=new People(220,"tom");
		People p2=new People(220,"汤姆");
		People p3=new People(220,"张三");
		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.print(p1+"与"+p3+"是否为同一人？");
		System.out.println(p1.equals(3));
		System.out.print(p1+"与"+o+"是否为同一人？");
		System.out.println(p1.equals(o));
	}
	}

运行结果：

  对象类型的转换

1、向上转型

子类转父类，即子类赋值给父类，用自动类型转换

Bird bird=new Pigeon();      //用向上转换，借助自动类型转换，将鸽子类转换为鸟类，告诉编译器：“某只鸽子是一只鸟”

在运行向上转换的过程中，父类的对象无法调用子类独有的属性或者方法。

2、向下转型

 父类转子类 ，即父类赋值给子类，用强制类型转换。语法如下：

子类类型  子类对象=（子类类型）父类对象；

class Bird{}
class Pigeon extends Bird{}
public class Demo2{
	public static void main (String[] args) {
		Bird bird=new Pigeon();//用向上转换，借助自动类型转换，将鸽子类转换为鸟类，告诉编译器：“某只鸽子是一只鸟”
		Pigeon pigeon=(Pigeon) bird;//用向下转换，借助强制类型转换，将鸟类转换为鸽子类，告诉编译器：“某只鸟是一只鸽子”
	}
}
                                           

方法的重载 

 方法名相同，参数类型（返回参数、传入参数）不同，参数个数不同，参数顺序不同，都能构成重载。

编写不同形式的加法运算方法。代码如下：

public class Parent{
	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[]) {
	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));
	}
}

运行结果：

在谈到参数个数可以确定两个方法是否具有重载关系时，会想到定义不定义长参数方法。不定长方法的语法如下：

返回值  方法名（参数数据类型...参数名称）

使用不定长参数重载加法运算方法。代码如下：

public class Parent{
	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 int add(int...a) {//定义不定长参数方法
	int s=0;
	for(int i=0;i<a.length;i++) {//根据参数个数做循环操作
		s+=a[i];//将每个参数累加
	}
	return s;//将计算结果返回
}
public static void main(String args[]) {
	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));
	
	//调用不定长参数方法
	System.out.println("调用不定长参数方法："+add(1,2,3,4,5,6,7,8,9));
	System.out.println("调用不定长参数方法："+add(1));
}
}

  运行结果：

                                             final关键字

1、final变量

用final修饰方法的不能被重写

public class Child{
	static final double PI=3.1415926;
	public static void main(String[] args) {
		System.out.println("圆周率的值为："+PI);
		System.out.println("半径为3的圆的周长为："+(2*3*PI));
       //尝试修改PI的值
		PI=3.1415927;
 
	}
}

会报错，错误如下（常量PI不允许被修改

当在程序中使用到PI这个常量时，它的值就是3.1415926。如果在程序中再次对定义为final的常量赋值，编译器将不会接受。

2、final方法

用final修饰变量不能被改变
      将方法定义为final类型，可以防止子类修改父类的定义与现实方式，同时定义为final的方法的执行效果要高于非final方法。

3、final类

用final修饰类不能被继承

final class FinalClass{//被FinalClass修饰的类
 
}
public class FinalTest extends FinalClass{//行继承FinalClass
 
}

错误：

    定义为final的类不能被继承。如果希望一个类不被任何类继承，并且不允许其他人对这个类进行任何改动，可以将这个类设置为final类。final类的语法如下：

final  类名{}

                                   使用instanceof关键字判断对象类型
instanceof的语法格式如下：

  对象名  instanceof  类名

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

       使用instanceof关键字的表达式返回值为布尔类值。如果返回值为true，说明对象为类的实例对象；如果返回值为false，说明对象不是类的实例对象 。

分析几何图形之间的继承关系，代码如下：

public class Child{
	public static void main(String args[]) {
		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);//判断正方行是否为圆形的子类
		
	}
}

报错

  因为四边形类与圆形类没有继承关系，因此两者不能使用instanceof关键字进行比较，否者会发生“不兼容”错误。

 多态

利用多态可以使程序具有良好的扩展性，并可以对所有类对象进行通用的处理。

假如现在要编写一个绘制图形的方法draw（），如果传入正方形对象将绘制正方形，如果传入圆形对象就绘制圆形，这种场景可以使用重载来实现，定义如下：

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

例题7.12 

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

运行结果；

抽象类与接口
 7.8.1抽象类

抽象方选没有方法体，这个方法本身没有任何意义，除非它被重写，而承载这个抽象方法的抽象类必须被继系。实际上抽象类除了被继承没有任何意义。定义抽象类的语法如下：

public abstract class Parent{
    abstract void testAbstract();   //定义抽象方法
}
只要类中有一个抽象方法，此类就被标记为抽象类。

抽象类被继承后需要实现其中所有的抽象方法，也就是保证以相同的方法名称、参数列表和返回值类型创建出非抽象方法，当然也可以是抽象方法。下图说明了抽象类的继承关系。

7.8.2接口
接口所有方法都是抽象方法

修饰符inter face 接口名{}

实现implements

java语言每个类可以实现多个接口

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

接口是抽象类的延伸，可以将它看作是纯粹的抽象类，接口中的所有方法都没有方法体。对于7.8.1节中遗留的问题，可以将draw0方法封装到一个接口中，使需要draw0方法的类实现这个接口，同时也继承图形类，这就是接口存在的必要性。在图7.11中，描述了各个子类继承图形类后使用接口的关系。

接口使用 interface 关键字进行定义，其语法如下: 

public interface Paintable{
    void draw();     //定义接口方法可省略public abstract关键字
}

public:接口可以像类一样被权限修饰符修饰，但public关键字仅限于接口在与其同名的文件中被定义。

interface:定义接口关键字。

Paintable:接口名称。

一个类继承一个父类的同时再实现一个接口，可以写成如下形式：

public class Parallelogram extends Quadrangle implements Paaintable{
  ...
}
 

interface Paintable{     //可绘制接口
	public void draw();    //绘制抽象方法
}
class Quadrangle{
	public void doAnything() {
		System.out.println("四边形提供的方法");
	}
}
//平行四边形类，继承四边形类，并实现了可绘制接口
class Parallelogram extends Quadrangle implements Paintable{
	public void draw() {        //由于该类实现了接口，所以需要覆盖draw()方法
		System.out.println("绘制平行四边形");
	}
}
//正方形类，继承四边形类，并实现了可绘制接口
class Square extends Quadrangle implements Paintable{
	public void draw() {
		System.out.println("绘制正方形");
	}
}
//圆形类，仅实现了可绘制接口
class Circular implements Paintable{
	public void draw() {
		System.out.println("绘制圆形");
	}
}
public class Demo7 {       
	public static void main(String[]args) {
		Square s = new Square();
		s.draw();
		s.doAnything();
		Parallelogram p=new Parallelogram();
		p.draw();
		p.doAnything(); 
		Circular c=new Circular();
		c.draw();
		
	}
}

运行结果如下：

实现多个接口的语法：

 class 类名 implements 接口1，接口2，接口3...

一个接口可以继承另一个接口，语法如下： 

interface intf1{}
interface intf2 extends intf1{}   //接口继承接口