第七章总结

7.1 类的继承

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

class Child extends Parent{}

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

class Chile entends Parent1,Panent2{} 

例题7.1 ：

package seven;
 
public class Parent {
	public Parent() {
		System.out.println("调用parent类构造方法");
	}
}
 
package seven;
 
public class Child extends Parent {
	public Child() {
		System.out.println("调用child类构造方法");
	}
}
 
package seven;
//所有类的构造方法第一行都有一个隐藏的"super"作用是在执行该结构方法之前调用其父类构造方法
public class Demo {
	public static void main(String[] args) {
		new Child();
	}
}

例题7.2 ：

package seven;
 
public class Telephone {     //电话类
	String button = "button:0~9"; //成员属性
	void call() {     //拨打电话功能
		System.out.println("开始打电话");
	}
}
 
public class Mobile extends Telephone{    //手机继承电话类
	String screen ="screen:液晶屏";    //成员属性液晶屏幕
}
 
public class Demo2 {
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Mobile motto = new Mobile();
		System.out.println(motto.button);    //子类调用父类属性
		System.out.println(motto.screen);    //子类调用父类属性
		motto.call();    //子类调用父类的方法
	}
 
}

  

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

class Animal{                             //父类：动物类
    Eye eye;
    Mouth mouth;
    Nose nose;
}
class Dog extends Animal{}                //子类：犬类
class Husky ectends Dog{}                 //孙子类：哈士奇类

7.2 Object

在 Object 类中，主要包括 clone() 、finslize()、equals()、toString()等方法。

1.getClass()方法

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

 getClass().getname();

2.toString()方法

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

例题7.3

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

3.equals()方法

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

package seven;
 
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() {
		return name;
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		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 + "与" + 3 + "是否为同一人？");
		System.out.println(p1.equals(p3));
		System.out.println(p1 + "与" + o + "是否为同一人？");
		System.out.println(p1.equals(o));
	}
 
}

 7.3 对象类型转换

 7.3.1 向上转换

向上转型

子类对象赋值给父类引用

Animal a = new Dog();

自动类型转换

例题 7.5

class People{}
class Teacher extends People{}
public class Demo3{
    public static void main(String[] args){
        People tom = new Teachar();
    }
}

7.3.2 向下转型

向下转型

父类对象赋值给子类引用

Dog a = (Dog)new Animal ();

强制类型转换

例题：7.6

package seven;
 
class Bird {}
 
class Pigeon extends Bird{}
	
public class Demo4{
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Bird bird = new Pigeon();
		Pigeon pigeon = bird;
	}
}

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

instanceof

对象名instanceof类名

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

例题 7.7

package seven;
 
class Quadrangle{}
class Square extends Quadrangle{}
class Circular{}
 
public class Demo5 {
	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);
	}
}

7.5 方法的重载

重载

方法名不同 参数不同

例题7.8：

 
public class OverLoadTest {
	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参数*/
		                           //输出int参数值
		return a;
		
	}
	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));
	
	
	
	
	}
	
}

 

例题7.9：

 
public class OverLoadTest {
	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参数*/
		                           //输出int参数值
		return a;
		
	}
	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));
	
	
	
	}
	
}

7.6 final 关键字

7.6.1 final变量 

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

final double PI = 3.14

 例题7.10：

public class FinalData{
    static fina 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;
    }
}

7.6.2 final 方法

public final void test(){
    ...//省略一些程序代码
}

例题7.11：

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

7.6.3 final类

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

final double PI=3.14;

修饰方法——不能被重写

一个定义为private的方法隐式被指定为final类型，因此无需将一个定义为private的方法再定义为final类型（private的意思是私有）

private final voidtest（）{

........//省略代码

}

 7.7多态

同一方法或同一个地方出现不同的形态就叫多态

例题7.11

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

结果： 

例题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());
 }
}

结果：

 

我们会发现报错，意思是无法覆盖 最终方法

修饰类——不能被继承

final 类名{}

package c;
final class FinalClass{//被final修饰的类
	
}
 
public class A4 extends FinalClass {//强行继承
	
}

 

意思是不能成为最终态类的子类

instanceof关键字

对象名        instanceof        类名

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

属于是输出真，不属于就输出假

例题7.7

package c;
class Quadrangle{}//创建四边形类
class Square extends Quadrangle{}//创建正方形类
class Circular{}//创建圆形类
 
public class A3 {//
	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        接口名

判断对象是否属于该接口的实现类

多态

子类继承父类，所形成的多种形态。就叫多态

继承父类所形成的多种结果，使用多个方法、变量、类，只要结果不同就是多态

使用多态节省了开发和维护时间，避免编写大量重复的代码

例题

package zy;
 
class SH{}//图形类
class sq extends SH{}//正方形类继承图形类
class q extends SH{}//圆形类继承图形类
public class Q{
	public static void dr(SH s) {//绘制方法dr
		if(s instanceof sq) {//如果是正方形
			System.out.println("绘制正方形");
		}else if(s instanceof q) {//如果是圆形
			System.out.println("绘制圆形");
		}else {//如果是其他类型
			System.out.println("绘制父类图形");
		}
	}
public static void main(String []args) {
		
		dr(new SH());//调用方法dr
		dr(new sq());
		dr(new q());
}
	
}

 

抽象方法 

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

public   abstract    void      st();

用abstract修饰，没有方法体，；结尾

抽象方法只能用抽象类定义

抽象类    有抽象方法的类一定是抽象类

修饰符    abstract    class   类名{
}

public abstract class    类名{

}

子类继承父类，如果父类是抽象类，有抽象方法，子类是普通类，不能有抽象方法，子类要继承父

类，但是子类不能有抽象方法，那么重写就可以继承抽象类父类，同时子类维持是普通类。

因为子类继承父类，所以父类的抽象方法已经在子类里，但是子类不能有抽象方法，不然要不报错

要不变成抽象类，只有重写才能够达到普通类子类继承抽象类父类的结果（这样就会形成一个规则，遇到抽象方法就重写）

 接口

所有方法都是抽象方法                就是接口（不能有普通方法）

修饰符        interface        接口名{

}

Java是单继承，它的缺点就是无法多继承，但是我们有解决办法，就是接口

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

实现接口               implements

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

}

接口的目的是为了实现多个结果

一个子类要继承父类还要实现接口，要先继承后实现

接口的实现类必须重写接口的抽象方法（这是接口制定的规则），不然会报错，或者变成抽象类

如果接口的实现类是抽象类，那么可以不重写一些抽象方法

例题7.13

package b;
 
interface p{//绘制图形接口
	public void dr();//方法
}
class Q{//平行四边形类
	public void doA(){//重写方法
		System.out.println("四边形提供的方法");
		
	}
}
class Pare extends Q implements p{//平行四边形类继承正方形类，实现接口
	public void dr() {
		System.out.println("绘制平行四边形");
	}
}
class s extends Q implements p{//正方形类继承平行四边形类，实现接口
	public void dr() {
		System.out.println("绘制正方形");
		
	}
}
class C implements p{//圆形类实现接口
	public void dr() {
		System.out.println("绘制圆形");
	}
}
 
 
public class demo{
	public static void main(String[]args) {
		s s1=new s();//创建对象，s1
		s1.dr();//调用方法dr
		s1.doA();//调用方法doA
		Pare p1=new Pare();
		p1.dr();
		p1.doA();
		C c1=new C();
		c1.dr();
	}
	}