Java多态（继承、实现、抽象）

最新推荐文章于 2024-07-28 19:11:58 发布

原创最新推荐文章于 2024-07-28 19:11:58 发布 · 302 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言 #学习

本文详细介绍了Java中的多态性，包括继承（extends）、instanceof关键字、静态（Static）关键字、抽象（Abstract）概念以及接口（Interface）。通过代码示例解析了抽象类与接口的使用，并强调了多态注意事项，如类型转换异常和方法重写等条件。

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

1、多态（继承、实现、抽象）
总结

1、多态（继承、实现、抽象）

extends（继承）

// Student 继承了 Person

class Person {
    
    void run() {
        System.out.println("Person---->run");
    }
}


class Student extends Person {
    
    
    void run() {
        System.out.println("Student--->run");
    }
}



class Test{
    static void main(String[] args) {
        Student s1 = new Student(); // 一个类的实际类型是确定的，

        // 这叫做 父类的引用指向子类的类型！！！
        Person s2 = new Student();  // 可以指向应用类型 就不确定了： 父类指向子类
        Object s3 = new Student();
        
        // 对象能执行那些放方法组要看左边类型，与右边关系不大！
        s2.run();  // 如果子类没有重写父类的方法： Person---->run  若重写了：Student--->run
        s1.run();  //   Student--->run
    }  
}

Instanceof 关键字

Instanceof（类型转换）：引用类型转换，判断一个对象时什么类型~

代码示例

class Person {
   
}

class Teacher extends Person {
    
}

class Student extends Person {
	 void go() {
         System.out.println("go! Go! go!");
    }
}

class Test{
    static void main(String[] args) {
       Object obj = new Student();
        
        System.out.println(obj instanceof Student); //true
        System.out.println(obj instanceof Person);	//true
        System.out.println(obj instanceof Teacher);//false
        System.out.println(obj instanceof Object);	//true
        System.out.println(obj instanceof String);//false
        
        
        Person person = new Stident();
        
        System.out.println(person instanceof Student); 	//true
        System.out.println(person instanceof Person);	//true
        System.out.println(person instanceof Teacher);	//false
        System.out.println(person instanceof Object);	//true
      //  System.out.println(person instanceof String);		编译报错
        
        
       	Student student = new Stident();
        
        System.out.println(student instanceof Student); 	//true
        System.out.println(student instanceof Person);		//true
        System.out.println(student instanceof Object);		//true
      //  System.out.println(student instanceof Teacher);	//编译报错
      //  System.out.println(person instanceof String);		//编译报错
        
        //System.out.println (X instanceof  Y); 能不能编译通过就看 X 与 Y 有没有父子关系！
        
        // 类型转换
        // 高			  低
        Person per = new Student();
        
        // 将per这个对象转换为Student类型，我们就可以使用Student类中的方法了！
        Student student = (Student) per;
        student.go();
       // ( (Student) per).go(); 上面两句相当于这一句。
  
    }  
}

Static（静态关键字）

静态代码块只执行一次

class Person{
    
    {
        System.out.println("匿名代码块");
    }
    
    // 只执行一次~
    static { 
        System.out.println("静态代码块");
    }
    
    public Person() {
         System.out.println("构造方法");
    }
    
    static void main(String[] args) {
        Person p = new Person();
        /*
        输出：
            静态代码块
            匿名代码块
            构造方法
        */
        Person p2 = new Person();
        /*
        输出:
            匿名代码块
            构造方法
        */
    }
    
}

总结

父类引用指向子类对象。
把子类转为父类，向上转型；如果子类转换为父类，可能会丢失自己本来的放法！
把父类转为子类，向下转型；强制转换！

Abstract(抽象)

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。
抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。
由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。
父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。
在 Java 中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

不能new抽象类，只能靠子类去实现它：约束！
抽象类中可以写普通方法。
抽象方法必须在抽象类中。

代码示例

// abstract: 抽象类
public abstract class Action {

    // 约束~有人帮我们实现。 abstract, 抽象方法；只有方法名字，没有的方法的实现！
    public abstract void doSome();
}

// 抽象类的所有方法，它的子类都必须要重写！！
public class A extends Action{

    @Override
    public void doSome() {
        System.out.println("我时抽象类的子类");
    }
}

Interface(接口)

在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。
接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。
除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。
接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。

代码示例

// interface:接口，都需要有实现类！！！
public interface UserService {

    // 属性都是常量
//    public static final int Age = 99;
    int Age = 99;
    
    // 在接口中所有的方法都是抽象的
    // public abstract void run();
    void add(String name);
    void del(String name);
    void updata(String name);
    void query(String name);
}

public interface TimeService {

    void time();
}

// 类实现接口 implements 必须要重写方法
// 利用接口可以达到多继承
public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void add(String name) {

    }

    @Override
    public void del(String name) {

    }

    @Override
    public void updata(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void time() {

    }
}