第七章继承多态抽象类与接口-CSDN博客

本文链接：https://blog.csdn.net/2301_76552332/article/details/129963496

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：

package seven;

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) {
       return a;
   }
   public static int add(double a,int b) {
       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 seven;

public class OverLoadTest2 {
   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.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 类名{}

7.7 多态

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

public void draw (Square s){ //绘制正方形的方法
}
Public void draw (Circular){ //绘制圆形的方法
}
例题：7.12：

package seven;

class Shape{}
class Square1 extends Shape{}
class Circular1 extends Shape{}

public class Demo6 {
   public static void draw(Shape s) {
       if(s instanceof Square1) {
           System.out.println("绘制正方形");
       }else if(s instanceof Circular1){
           System.out.println("绘制圆形");
       }else{
           System.out.println("绘制父类图形");
       }
   }

   public static void main(String[] args) {
       // TODO Auto-generated method stub8
       draw(new Shape());
       draw(new Square1());
       draw(new Circular1());
   }
}

7.8 抽象类与对象

7.8.1 抽象类

抽象方法

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

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

修饰符 abstract class 类目{

}

使用 abatract 关键字定义的类称为抽象类，而使用这个关键字定义的方法为抽象方法。抽象方法没有方法体。定义抽象的语法如下：

public abstract class Parent{
abstract void testAbstract(); //定义抽象方法
}
反过来讲，如果声明一个抽象方法，就必须将承载这个抽象方法的类定义为抽象类。

7.8.2 接口

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

修饰符 interface接口名{

}

实现 implements

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

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

}

例题 7.13

package seven;

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