0基础学java_接口和instanceof关键字
抽象类
包含一个抽象方法的类就叫作抽象类。只声明而未实现的方法叫做抽象方法，抽象方法必须使用abstract关键字声明。
定义规则
- 包含一个抽象方法的类必须是抽象类
- 抽象类和抽象方法都要使用abstract关键字声明
- 抽象方法只需要声明而不需要实现
- 抽象类必须被子类继承，子类（不是抽象类）必须覆写抽象类中的全部抽象方法
格式
abstract class 抽象类名称{
属性;
访问权限 返回值类型 方法名称（参数）{
return 返回值;
}
访问权限 abstract返回值类型 方法名称（参数）{
//在抽象方法中没有方法体
}
举例：
1 package com.xiaotaotao.code; 2 3 abstract class A{ 4 public static final String FLAG = "CHINA";//全局常量 5 private String name = "肥猫";//定义一个普通的属性 6 public void setName(String name){ 7 this.name = name; 8 } 9 public String getName(){ 10 return this.name; 11 } 12 public abstract void print();//定义抽象方法 13 } 14 class B extends A{//继承抽象类，因为B是普通类，所以必须覆写全部的抽象方法 15 public void print(){ 16 System.out.println("FLAG = " + FLAG); 17 System.out.println("姓名 = " + super.getName()); 18 } 19 } 20 public class AbstractDemo01 { 21 public static void main(String args[]){ 22 B b = new B(); 23 b.print(); 24 } 25 } 26 27 举例： 28 29 package com.xiaotaotao.code; 30 31 32 33 abstract class A{ 34 35 public A(){ 36 37 System.out.println("抽象类A中的构造方法"); 38 39 } 40 41 } 42 43 class B extends A{//继承抽象类，因为B是普通类，所以必须覆写全部的抽象方法 44 45 public B(){ 46 47 super();//也可以通过super明确指定构造方法 48 49 System.out.println("子类B中的构造方法" ); 50 51 } 52 53 } 54 55 public class AbstractDemo01 { 56 57 public static void main(String args[]){ 58 59 B b = new B(); 60 61 } 62 63 }
举例:
1 package com.xiaotaotao.code; 2 3 4 5 abstract class Person01{ 6 7 private String name; 8 9 private int age; 10 11 public Person01(String name , int age){//构造方法 12 13 this.name = name; 14 15 this.age = age; 16 17 } 18 19 public void setName(String name){//void 方法有返回值 20 21 this.name = name; 22 23 } 24 25 public void setAge(int age){ 26 27 this.age = age; 28 29 } 30 31 public String getName(){ 32 33 return name; 34 35 } 36 37 public int getAge(){ 38 39 return age; 40 41 } 42 43 public abstract String getInfo();//定义抽象方法 44 45 } 46 47 class Student01 extends Person01{ 48 49 private String school; 50 51 public Student01(String name , int age , String school){ 52 53 super(name , age);//指定要定义两个参数内的构造方法 54 55 this.school = school; 56 57 } 58 59 public void setSchool(String school){ 60 61 this.school = school; 62 63 } 64 65 public String getSchool(){ 66 67 return school; 68 69 } 70 71 public String getInfo(){ 72 73 return "姓名 ：" + super.getName() + " 年龄 ：" + super.getAge() + " 学校 : " + this.getSchool(); 74 75 } 76 77 78 79 } 80 81 public class AbstractDemo02 { 82 83 public static void main(String args[]){ 84 85 Student01 s = new Student01("肥猫" , 28 , "浙江大学"); 86 87 System.out.println(s.getInfo()); 88 89 } 90 91 } 92
接口
接口可以理解为一种特殊的类，里面全部是由全局变量和公共的抽象方法所组成。
接口中的抽象方法可以不加abstract，但是抽象方法中必须加abstract关键字
格式
interface 类名称{
全局变量
抽象方法
}
接口的实现
与抽象类一样，接口要想使用必须通过子类，通过implements关键实现接口
class A implements 接口A，接口B{
}
接口的使用中必须有子类，子类必须覆写全部的抽象方法。一个子类可以同时实现多个接口，如果子类不是抽象类的话，那就得覆写接口中的全部抽象方法。
举例：
p
1 ackage company.feimao.package1; 2 3 4 5 interface A{ 6 7 public static final String AUTHOR = "肥猫";//全局变量 8 9 public abstract void print();//抽象方法 10 11 public abstract String getInfo();//抽象方法 12 13 } 14 15 interface B { 16 17 public void say();//抽象方法 18 19 } 20 21 class C implements A , B{ 22 23 public void say(){//覆写抽象方法 24 25 System.out.println("Hello World!"); 26 27 } 28 29 public String getInfo(){ 30 31 return "Hello"; 32 33 } 34 35 public void print(){ 36 37 System.out.println("作者 ：" + AUTHOR); 38 39 } 40 41 } 42 43 public class InterfaceDemo01 { 44 45 public static void main(String args[]){ 46 47 C c = new C(); 48 49 c.say(); 50 51 c.print(); 52 53 } 54 55 56 57 }
举例：继承类实现接口
1 package company.feimao.package1; 2 3 interface H{ 4 5 public String AUTHOR = "肥猫"; 6 7 abstract void print(); 8 9 abstract String getInfo(); 10 11 } 12 13 abstract class I implements H{ 14 15 abstract void say(); 16 17 } 18 19 class J extends I { 20 21 public void say(){ 22 23 System.out.println("Hello 肥猫"); 24 25 } 26 27 public String getInfo(){ 28 29 return "Hello"; 30 31 } 32 33 public void print(){ 34 35 System.out.println("作者 "+ AUTHOR); 36 37 } 38 39 } 40 41 public class InterfaceDemo02 { 42 43 public static void main(String args[]){ 44 45 J j = new J(); 46 47 j.getInfo(); 48 49 j.print(); 50 51 j.say(); 52 53 } 54 55 }
一个接口不能继承抽象类，但是可以继续多个接口，实现接口的多继承
格式
Interface A extends B ， C{
}
1 package company.feimao.package1; 2 3 interface H{ 4 5 public String AUTHOR = "肥猫"; 6 7 abstract void printA(); 8 9 } 10 11 interface I{ 12 13 public void printB(); 14 15 } 16 17 interface J extends H , I{ 18 19 public void printC(); 20 21 } 22 23 class K implements J { 24 25 public void printA(){ 26 27 System.out.println("Hello 肥猫"); 28 29 } 30 31 public void printB(){ 32 33 System.out.println("Hello 猪宝宝"); 34 35 } 36 37 public void printC(){ 38 39 System.out.println("Hello 淘淘"); 40 41 } 42 43 } 44 45 public class InterfaceDemo02 { 46 47 public static void main(String args[]){ 48 49 K k = new K(); 50 51 k.printA(); 52 53 k.printB(); 54 55 k.printC(); 56 57 } 58 59 } 60
Instanceof关键字
在java中可以使用instanceof关键字判断一个对象到底是哪个类的实例
对象 instanceof 类—>返回boolean类型
1 package company.feimao.package1; 2 3 class W{ 4 public void fun1(){ 5 System.out.println("W------>public void fun1(){}"); 6 } 7 public void fun2(){ 8 this.fun1(); 9 } 10 } 11 class E extends W{ 12 public void fun1(){ 13 System.out.println("E----->public void fun1(){}"); 14 } 15 public void fun3(){ 16 System.out.println("E------->public void fun3(){}"); 17 } 18 19 } 20 public class InstanceofDemo01 { 21 public static void main(String args[]) { 22 W w = new E();//向上转型 23 System.out.println("W w = new E() :" + (w instanceof W)); 24 System.out.println("W w = new E() :" + (w instanceof E)); 25 W w2 = new W(); 26 System.out.println("W w = new E() :" + (w2 instanceof W)); 27 System.out.println("W w = new E() :" + (w2 instanceof E)); 28 } 29 }
在实际开发中，对于向下转型操作最好增加验证，以保证转型时不会发生classCastException.一个类永远不要去继承一个已经实现好的类，而只能继承抽象类和实现接口。