第七章继承、多态、抽象类与接口

目录

类的继承

Object类

1、getClass()方法

2、toString()方法

 3、equals()方法

对象类型的转换

向上转型

向下转型 

使用instanceof关键词判断对象类型

方法的重载

final关键词

1、final变量

2、final方法

3、final类

多态

抽象与接口

---

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

class Child extends Parent{}

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

class Child extends  Parent1， Parent2{}

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

public class Parent {//引入类
	public Parent() {
		System.out.println("调用Paren类构造方法");//输出
		
	}
}
public class Child extends Parent {//引入类
	public Child() {
		System.out.print("调用Child类构造方法");//输出
	}
}
public class Demo {//引入类
	public static void main(String[] args) {
		new Child();//调用Child构造方法
 
	}
 
}

 

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

public只能有一个，用public修饰的类就是类名(文件名)。

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

class Telephone{//电话类
	String button = "button:0~9";//成员属性，10个按键
	void call() {	//拨打电话功能
		System.out.println("开始拨打电话");//输出
	}
}
 
class Mobile extends Telephone{//手机类继承电话类
	String screen = "screen:液晶屏";//成员属性，液晶屏幕
	void call() {	//拨打电话功能
		System.out.println("拨打电话");//输出
	}
}
 
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虽然不允许同时继承多个父类，但不代表没有多个继承，可以通过类似“祖父>父>儿子>孙子”的方式实现多代继承。

class Animal{        //父类：动物类

        Eye eye;

        Mouth mouth;

        nose nose;

}

class Dog extends Animal{}        //子类：犬类

class Husky extends Dog{}        //孙子类：哈士奇类

Object类

在Java中所有的类都直接或间接继承了Java.lang.Object类。Object类是比较特殊的类，它是所有类的父类。

由于所有的类都是Object类的子类，所以任何类都可以重写Object类中的方法。下面是Object类中几种重要用法：

1、getClass()方法

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

getClass().getname();

2、toString()方法

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

年龄。

public class Student { //创建类
    String name; //定义name变量
    int age; //定义age变量
    
    public Student( String name,int age) { //定义构造方法
        this.name = name; //传入参数
        this.age = age; 
    }
    
    public String toString() { //重写toString()
        return"我叫" +name +",今年"+age+"岁。"; //返回值
    }
 
    public static void main(String[] args) {
        Student s1 =new Student("张三",16); //新建对象s1
        System.out.println(s1); //输出s1
        Student s2 =new Student("李四",17); //新建对象s2
        System.out.println(s2); //输出s2
 
    }
 
}

 

 3、equals()方法

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

public class People1{
    int id;//身份证
 String name;//名字
 public People1(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;
  People1 other=(People1) obj;//将参数强转成本类对象
  if(id!=other.id)//如果两者的身份证号不相等
   return false;
  return true;
 }
 public String toString() {//重写Object类的toString()方法
  return name;//只输出名字
 }
 public static void main(String[] args) {
  People1 p1=new People1(220,"tom");
  People1 p2=new People1(220,"汤姆");
  People1 p3=new People1(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));
 }
 }

 

对象类型的转换

向上转型

子类转父类 ，子类对象赋值给父类引用。子类类型的对象直接赋值给父类类型的对象。自动类型转换   语法如下：

Animal a = new dog();

向下转型 

父类转子类，父类对象赋值给子类引用。可以理解为将父类类型的对象转换为子类类型的对象。但是运用向下转换，如果把一个叫抽象的类的对象转换为一个较具体的类的对象，这样的转型通常会出现错误，这时就需要借助强制类型转换。

Dog a =(Dog)new Animal();

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 = (Pigeon) bird;//某只鸟是一只鸽子（要进行强制类型转换）
 
    }
 
}

使用instanceof关键词判断对象类型

对象名  instanceof  类名

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

 

因为四边形类与圆形类没有继承关系，因此两者不能使用instanceof关键词进行比较，否则会发生”不兼容“错误。如果删除或注释掉这一行代码，运行结果如下：

方法的重载

方法名相同，参数不同（返回参数不同，传入参数不同）

  构造方法的名称由类名决定，所以构造方法只有一个名称。如果希望以不同的方式来实例化对象，就需要使用多个构造方法来完成。由于这些构造方法都需要根据类名进行命名，为了方法名相同而形参不同的构造方法同时存在，必须用到方法重载。虽然方法存在起源于构造方法，但它也可以应用到其他方法中。

public class Demo4{
	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 double add(int a,double b) {//先int参数，后double参数
		return a;    //输出int参数值
	}
	public static double 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));
		
	}
}
 

 

final关键词

1、final变量

final关键字用于变量声明，一旦该变量被设定，就不可以在改变该变量的值，final关键字定义的变量必须在声明时对其进行赋值操作

语法：Final double Pi=3.14；

 final修饰变量——不能被改变（变量）

public class Parent{//创建Parent
	static final double Pi=3.1415926;//定义圆周率Pi
	public static void main(String[] args) {
		System.out.print("圆周率的值为："+Pi);//输出圆周率Pi
		System.out.print("半径为3的园的周长为："+(2*3*Pi));//输出周长
		//尝试修改Pi的值
		Pi=3.1415926;
	}
}

 

报错原因是：Pi不允许被修改 （不能对Final字段Parent.Pi赋值）

2、final方法

可以防止子类修改父类的定义与现实方法，执行效率高于非final方法

语法：private final void test（）{

...//省略一些程序代码

}

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

3、final类

使用final类可以使该类不被任何类继承，并且不允许其他人对这个类进行任何改动

语法：final 类名{}

final修饰类——不能被继承

final class FinalClass{//被FinalClass修饰的类


}

public class FinalTest extends FinalClass{//强行继承FinalClass


}

 报错原因：类型 FinalTest 不能对最终类 FinalClass 进行子类化

多态

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

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) {
		// TODO Auto-generated method stub
		draw(new Shape());
		draw(new Square());
		draw(new Circular());

	}

}

 

抽象与接口

 抽象类

 抽象方法
修饰符 abstract 返回参数 方法名（传入参数）；
没有方法体，要用abstract来修饰

public abstract void methodName（）；
抽象类 有抽象方法的类一定是抽象类
修饰符 abstract class 类名{
}

假设父类是抽象类的话，子类是普通类，那么子类继承父类的话就需要被重写。
 承载这个抽象方法的抽象类必须被继承，抽象类除了被继承没有任何意义
如果声明一个抽象方法，就必须将承载这个抽象方法的类定义为抽象类，不能在非抽象类中获取抽象方法。只要类中有一个抽象方法，此类就被标记为抽象类。

接口

所有方法都是抽象方法叫接口。Java语言中每个类可以实现多个接口。可以单继承多实现。接口中的所有方法都没有方法体。

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

}

修饰符    interface  接口名{

}

实现implements

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

pubilc class Parallelogram extends Quadrangle implements Paintable{

……

}

一个接口也可以继承另一个接口

interface intf1{}

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

 

interface Paintable{ //可绘制接口
 public void draw(); //绘制抽象方法
}

class Quadrangle2{  //四边形类
 public void doAnything() {
  System.out.println("四边形提供的方法");
 }
}

//平行四边形，继承四边形类，并实现了可绘制接口
class Parallelogram extends Quadrangle2 implements Paintable{
 public void draw() {
  System.out.println("绘制平行四边形");
 }
}

//正方形类，继承四边形类，并实现了可绘制接口
class Square2 extends Quadrangle2 implements Paintable{
 public void draw() { //由于该类实现了接口，所以需要覆盖draw()方法
  System.out.println("绘制正方形");
 }
}

//圆形类，仅实现了可绘制接口
class Circular2 extends Quadrangle2 implements Paintable{
 public void draw() {
  System.out.println("绘制圆形");
 }
}

public class Dome7 {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Square2 s = new Square2();
  s.draw();
  s.doAnything();
  Parallelogram p = new Parallelogram();
  p.draw();
  p.doAnything();
  Circular2 c = new Circular2();
  c.draw();
 }
}