0基础学java_接口和instanceof关键字

抽象类

包含一个抽象方法的类就叫作抽象类。只声明而未实现的方法叫做抽象方法，抽象方法必须使用abstract关键字声明。

定义规则

1. 包含一个抽象方法的类必须是抽象类
2. 抽象类和抽象方法都要使用abstract关键字声明
3. 抽象方法只需要声明而不需要实现
4. 抽象类必须被子类继承，子类（不是抽象类）必须覆写抽象类中的全部抽象方法

格式

abstract class 抽象类名称{

      属性;

       访问权限 返回值类型 方法名称（参数）{

          return 返回值;

}

      访问权限 abstract返回值类型 方法名称（参数）{

         //在抽象方法中没有方法体

}

举例：

package com.xiaotaotao.code;

abstract class A{
    public static final String FLAG = "CHINA";//全局常量
    private String name = "肥猫";//定义一个普通的属性
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return this.name;
    }
    public abstract void print();//定义抽象方法
}
class B extends  A{//继承抽象类，因为B是普通类，所以必须覆写全部的抽象方法
    public void print(){
        System.out.println("FLAG = " + FLAG);
        System.out.println("姓名 = " + super.getName());
    }
}
public class AbstractDemo01 {
    public static void main(String args[]){
        B b = new B();
        b.print();
    }
}

举例：

package com.xiaotaotao.code;



abstract class A{

    public A(){

    System.out.println("抽象类A中的构造方法");

    }

}

class B extends  A{//继承抽象类，因为B是普通类，所以必须覆写全部的抽象方法

    public B(){

        super();//也可以通过super明确指定构造方法

        System.out.println("子类B中的构造方法" );

    }

}

public class AbstractDemo01 {

    public static void main(String args[]){

        B b = new B();

    }

}

 

举例:

package com.xiaotaotao.code;



abstract class Person01{

    private String name;

    private int age;

    public Person01(String name , int age){//构造方法

        this.name = name;

        this.age = age;

    }

    public  void setName(String name){//void 方法有返回值

        this.name = name;

    }

    public void setAge(int age){

        this.age = age;

    }

    public String getName(){

        return name;

    }

    public int getAge(){

        return age;

    }

    public abstract String getInfo();//定义抽象方法

}

class Student01 extends Person01{

    private String school;

    public Student01(String name , int age , String school){

        super(name , age);//指定要定义两个参数内的构造方法

        this.school = school;

    }

    public void setSchool(String school){

        this.school = school;

    }

    public String getSchool(){

        return school;

    }

    public String getInfo(){

        return "姓名 ：" + super.getName() + " 年龄 ：" + super.getAge() + " 学校 : " + this.getSchool();

    }



}

public class AbstractDemo02 {

    public static void main(String args[]){

        Student01 s = new Student01("肥猫" , 28 , "浙江大学");

        System.out.println(s.getInfo());

    }

}
 

接口

接口可以理解为一种特殊的类，里面全部是由全局变量和公共的抽象方法所组成。

接口中的抽象方法可以不加abstract，但是抽象方法中必须加abstract关键字

格式

interface 类名称{

全局变量

 抽象方法

}

接口的实现

与抽象类一样，接口要想使用必须通过子类，通过implements关键实现接口

class A implements 接口A，接口B{

}

接口的使用中必须有子类，子类必须覆写全部的抽象方法。一个子类可以同时实现多个接口，如果子类不是抽象类的话，那就得覆写接口中的全部抽象方法。

举例：

p

ackage company.feimao.package1;



interface A{

    public static final String AUTHOR = "肥猫";//全局变量

    public abstract void print();//抽象方法

    public abstract String getInfo();//抽象方法

}

interface B {

    public void say();//抽象方法

}

class C implements A , B{

    public void say(){//覆写抽象方法

        System.out.println("Hello World!");

    }

    public String getInfo(){

        return "Hello";

    }

    public void print(){

        System.out.println("作者 ：" + AUTHOR);

    }

}

public class InterfaceDemo01 {

    public static void main(String args[]){

        C c = new C();

        c.say();

        c.print();

    }



}

举例：继承类实现接口

package company.feimao.package1;

interface H{

    public String AUTHOR = "肥猫";

    abstract void print();

    abstract String getInfo();

}

abstract class I implements H{

    abstract void say();

}

class J extends I {

    public void say(){

        System.out.println("Hello 肥猫");

    }

    public String getInfo(){

        return "Hello";

    }

    public void print(){

        System.out.println("作者 "+ AUTHOR);

    }

}

public class InterfaceDemo02 {

    public static void main(String args[]){

        J j = new J();

        j.getInfo();

        j.print();

        j.say();

    }

}

一个接口不能继承抽象类，但是可以继续多个接口，实现接口的多继承

格式

Interface A extends B ， C{

}

package company.feimao.package1;

interface H{

    public String AUTHOR = "肥猫";

    abstract void printA();

}

interface I{

    public void printB();

}

interface J extends H , I{

    public void printC();

}

class K implements J {

    public void printA(){

        System.out.println("Hello 肥猫");

    }

    public void printB(){

        System.out.println("Hello 猪宝宝");

    }

    public void printC(){

        System.out.println("Hello 淘淘");

    }

}

public class InterfaceDemo02 {

    public static void main(String args[]){

        K k = new K();

        k.printA();

        k.printB();

        k.printC();

    }

}
 

Instanceof关键字

在java中可以使用instanceof关键字判断一个对象到底是哪个类的实例

对象 instanceof 类—>返回boolean类型

package company.feimao.package1;

class W{
    public void fun1(){
        System.out.println("W------>public void fun1(){}");
    }
    public void fun2(){
        this.fun1();
    }
}
class E extends W{
    public void fun1(){
        System.out.println("E----->public void fun1(){}");
    }
    public void fun3(){
        System.out.println("E------->public void fun3(){}");
    }

}
public class InstanceofDemo01 {
    public static void main(String args[]) {
        W w = new E();//向上转型
        System.out.println("W w = new E() :" + (w instanceof W));
        System.out.println("W w = new E() :" + (w instanceof E));
        W w2 = new W();
        System.out.println("W w = new E() :" + (w2 instanceof W));
        System.out.println("W w = new E() :" + (w2 instanceof E));
    }
}

在实际开发中，对于向下转型操作最好增加验证，以保证转型时不会发生classCastException.一个类永远不要去继承一个已经实现好的类，而只能继承抽象类和实现接口。