第七章总结

7.1类的继承

一个类继承另一个类需要使用关键字extends，关键字extends的使用方法如下：

class Child extends Parent{}

Java只支持单继承，即一个类只能有一个类，所以类似下面的代码是错误的的：

 class Child extends Parent1，Parent2{}

子类在继承父类之后，创建子类对象的同时也会调用父类的构造方法。

例题7.1 

public class Parent {
 public Parent() {
  System.out.println("调用Parent类构造方法");
 }
}

public class Child extends Parent{//继承父类
 public Child () {
  super();
  System.out.println("调用Child 类构造方法");
 }
}

public class Demo {

 public static void main(String[] args) {
  new Child ();  //调用child类

 }

}

 运行结果如下：

 

例题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) {
  Mobile motto=new Mobile();
  System.out.println(motto.button);   //子类调用父类属性
  System.out.println(motto.screen);   //子类调用父类没有的属性
  motto.call();                       //子类调用父类方法

 }

}

运行结果如下：

Java虽然不允许同时继承两个父类，但不代表没有多继承的关系，可以通过类似“祖父>父>儿子>孙子”的方式实现多继承。

7.2 Object类

所有的类都是Object类的子类，所以在定义类时可以省略extends Object.

在Object类中，主要包括clone()、finalize()、equals()、toString()等方法，其中equals()、toString()最常用。由于所有的类都是Object类的子类，所以任何类都可以重写Object类中的方法。

注意：Object类中的getClass()、notify()、notifyAll()、wait()等方法不能被重写，因为这些方法被定义为final类型。

下面详细讲述Object类中的几个重要方法

1.getClass()方法

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

getClass().getname();

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

2.toString()方法

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

例题7.3

class student{
    String name;
    int age;

    public student() {
    }

    public student(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
 //重写了父类中的toString()方法
    @Override
    public String toString(){
        return "姓名："+this.name+"，年龄："+this.age;
    }
}

public class Demo_3 {
    public static void main(String[] args) {
        student s1=new student("小明",18);
        System.out.println(s1.toString());
    }
}

 运行结果如下：

吗， 

3.equals()方法

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

例题7.4

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

运行结果如下：

注意，在使用equals() 方法比较自行编写的类对象时，那么需要先重写equals方法，因为每个类判相等的规则都是不一样的。而且如果没有重写的话，那么系统会自动调用Object中的equals方法。

7.3对象类型的转换

需要注意的是，只有具备继承关系得类与类之间才能进行对象类型转换，非继承关系之间不能进行类型转换。

对象之间的类型转换在Java编程中还是很常见的。类型转换分为向上转型与向下转型。

1.向上转型
而向上转型就是将子类对象赋值给父类对象。可以理解为将子类类型的对象转换为父类类型的对象，即把子类类型对象直接赋值给父类类型的对象。
格式为： 父类 对象名 = (父类) 子类对象;

例题7.5

package qidanyuan;
class People{}
class Teacher extends People{}
public class jicheng7_5 {
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		People tom = new Teacher();
	}
 
}

需要注意得是，在进行向上类型转换后，父类对象依旧无法调用子类独有的属性与方法。
只能调用从父类中继承下来的属性与方法。
2.向下转型

 向下类型转换可以理解为将父类类型的对象转换为子类类型的对象。 但是运用向下转型，因为父类大多是较为抽象的类，而子类大多是具体的类， 而将一个较为抽象的类转换为一个较为具体的类，这样的转换通常会出现错误，所以向下转型是不安全的。

举例7.6

package qidanyuan;
class Pigeon extends jicheng7_6{}
public class jicheng7_6 {
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		jicheng7_6 bird = new Pigeon();//某只鸽子是一只鸟
		Pigeon pigeon = bird;//某只鸟是一只鸽子
	}
 
}

将会出现报错：

 需要借助强制类型转换

语法如下：

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

 将例题7.4中第八行的代码修改为：

Pigeon pigeon =(Pigeon)birl;    //通过强制类型转换，告诉编译器“某只鸟就是一只鸽子”

7.4使用instsnceof关键字判断对象类型

instsnceof的语法格式如下：

myobject instanceof ExampleClass

 myobject:某类的对象引用。

ExampleClass:某个类。

误区警示：instanceof是Java语言的关键字，Java语言中的关键字都为小写。

例题7.7

package qidanyuan;
class Quadrangle{}
class Square extends Quadrangle{}
class Circular{}
public class jicheng7_7 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		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 来比较

当我们删除或者注释掉那行代码

运行结果如下：

7.5方法的重载

重载与重写不同但又十分相似

重写是：返回参数相同 方法名相同 传入参数相同 只有方法体不同

重载则是：方法名相同 参数不同

重载和重写的区别在于：重写必须要有继承关系才能使用，而重写只要在同一个类里就能使用

例题7.8

package qidanyuan;
 
public class jicheng7_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;
		}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		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

package qidanyuan;
 
public class jicheng7_9 {
	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) {
		return a;
	}
	public static int add(double a,int b) {
		return b;
	}
	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) {
		// TODO Auto-generated method stub
		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));
	}
 
}

运行结果如下：

 7.6final关键字

7.6.1final变量

用final修饰的变量就不可以在改变该变量的值

final修饰变量——不可改变的量（常量）

例题7.10

package qidanyuan;
 
public class jicheng7_10 {
	static final double PI = 3.1415926;
	 public static void main(String[] args) {
	  // TODO Auto-generated method stub
	  System.out.print("圆周率为："+PI);
	  System.out.print("半径3的原的周长为："+ (2*3*PI));
	  //尝试修改PI的值
	  PI = 3.1415927;
	 }
}

final修饰的变量报错

7.6.2final方法

final修饰方法——不能被重写 

例题7.11

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

如果用 final修饰则子类不可以重写父类的方法 ，代码报错，如图：

翻译： 

7.6.3final类

final修饰类——不能被继承

如果不希望一个类被任何类继承，只需要在类的前面加上final就行。

7.7多态

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

假如现在要编写一个绘制图形的方法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抽象类与接口

 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{
  ...
}

 例题7.13

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{}   //接口继承接口