1.什么是接口(B)
接口是一种引用数据类型,用interface声明;当出现interface便可判断为接口。
形式:【修饰符】 interface 接口名称(public interface Pepar{ })
接口可声明属性,且属性都默认为static final
1 public interface Paper{ 2 public static final String value = "0"; 3 4 }
接口也可声明方法,方法都为公共的抽象方法(以下说的接口方法都为抽象方法);接口只定义方法不实现方法所以不存在方法体。
1 public interface Color{ 2 public void red(); 3 }
接口不能构造方法,也不能创建对象。
一个接口可以继承多个接口,并且继承各个接口的定义的方法
1 public interface CInterface extends AInterface, BInterface { 2 //CInterface接口拥有AIterface、BInerface接口定义的方法 3 }
一个类可以实现多个接口,该类称为实现类;实现一定要实现接口定义的方法。
形式:
1 public class ImplClassA implements AInterface,BInterface{ 2 3 @Override 4 public void showInfoA() { 5 System.out.println("实现接口中的showInfoA"); 6 } 7 8 @Override 9 public void showInfoB() { 10 System.out.println("实现接口中的showInfoB"); 11 } 12 }
一个类继承父类的同时,也实现多个接口;形式:先继承,后实现。
形式:
1 public class ImplClass3 extends AbsClass implements AInterface,BInterface{ 2 3 @Override 4 public void showInfoA() { 5 // TODO Auto-generated method stub 6 7 } 8 9 @Override 10 public void showInfoB() { 11 // TODO Auto-generated method stub 12 13 } 14 15 @Override 16 public void showInfoC() { 17 // TODO Auto-generated method stub 18 19 } 20 21 }
特殊情况:
如果一个抽象父类定义了和接口同名的抽象方法,实现类实现的是抽象父类的抽象方法。
1 package cn.interface02; 2 3 public class ImplClass4 extends AbsClass implements CInterface{ 4 5 @Override 6 public void showInfoA() { 7 // TODO Auto-generated method stub 8 9 } 10 11 @Override 12 public void showInfoB() { 13 // TODO Auto-generated method stub 14 15 } 16 17 @Override 18 public void showInfoC() { 19 // TODO Auto-generated method stub 20 21 } 22 23 }
总结:
其实不难发现接口定义的方法与实现类实现接口定义的方法 ,与父类定义的抽象方法和子类重写父类抽象方法类似。
2.接口的应用(B)
接口表示一种功能
接口中定义的一些系列方法表示的是一种种的能力。接口让实现类实现这些能力,实现类的能力得到拓展和升级。
实现类根据自身特性实现接口中定义的方法。
1 package cn.sxt.interface03; 2 3 /** 4 * 驾驶接口 5 */ 6 public interface DriveInterface { 7 /** 8 * 驾驶的方法 9 */ 10 public void drive(); 11 }
package cn.sxt.interface03;public class Student implements DriveInterface{…public void learn(String cName) {System.out.println(this.name+"正在学习"+cName);}@Overridepublic void drive() {System.out.println(this.name+"正在驾驶...");}}
1 package cn.sxt.interface03; 2 3 public class Teacher implements DriveInterface{ 4 /// … 5 6 @Override 7 public void drive() { 8 System.out.println(this.name+"正在学习驾驶技术..."); 9 System.out.println(this.name+"很快学会了飙车..."); 10 } 11 12 }
接口的多态
一个接口只有方法的特征没有方法的实现,因此这些方法可以在不同的地方被不同的类实现,而这些实现可以具有不同的行为(方法)(功能)。
1 package cn.sxt.interface4; 2 3 public class Test01 { 4 public static void main(String[] args) { 5 6 // 同一引用类型 7 USBInterface usbInterface = null; 8 9 // 实例不同 10 usbInterface = new USBFan(); 11 // 对同一方法的执行结果不同 12 usbInterface.connect(); 13 14 usbInterface = new USBMouse(); 15 usbInterface.connect(); 16 17 usbInterface = new USBDisk(); 18 usbInterface.connect(); 19 } 20 }
总结:
接口实现多态:接口类型 引用 实现类对象
继承实现多态: 父类类型 引用 子类对象
接口定义的方法被实现类实现时,是通过引用实现类方法,调用接口方法时,执行的是实现类的方法。
接口:has is
继承: is a
3.面向接口编程(A)
接口是一种约定(协议),约定实现类具备什么功能。
接口规范了实现类具备的行为
程序中:面向接口只定义方法没有方法体,不关心实现类如何实现方法,只关心实现类具不具备接口所定义方法的能力。
1 package cn.sxt.interface06; 2 3 public class Writer { 4 5 // 预留墨盒接口 6 private InkBoxInterface inkBoxInterface; 7 8 // 预留纸张接口 9 private PaperInterface paperInterface; 10 11 public InkBoxInterface getInkBoxInterface() { 12 return inkBoxInterface; 13 } 14 15 public void setInkBoxInterface(InkBoxInterface inkBoxInterface) { 16 this.inkBoxInterface = inkBoxInterface; 17 } 18 19 public PaperInterface getPaperInterface() { 20 return paperInterface; 21 } 22 23 public void setPaperInterface(PaperInterface paperInterface) { 24 this.paperInterface = paperInterface; 25 } 26 27 public Writer(InkBoxInterface inkBoxInterface, PaperInterface paperInterface) { 28 super(); 29 this.inkBoxInterface = inkBoxInterface; 30 this.paperInterface = paperInterface; 31 } 32 33 public Writer() { 34 super(); 35 } 36 37 public void print(String content) { 38 System.out.println("打印机正在使用"+this.inkBoxInterface.getColor()+"颜色打印"+this.paperInterface.getSize()+"打印"+content); 39 } 40 }
抽象类和接口的异同比较 (面试常来题)
- 抽象类和接口都是引用数据类型,他们都不能创建对象。
- 他们都可以定义抽象方法,都可以实现多态。但是抽象类可以定义非抽象方法,而接口中定义的都是抽象方法。
- 抽象类和接口都具有传递性。抽象类是单根性(单继承),而接口是多继承。
- 在概念上,都可以重写抽象方法。子类重写抽象类,实现类实现接口
- 抽象类和子类解决的是模块内的问题(代码重用,重写,多态)而接口解决的是模块间的问题 => 高内聚,低耦合。接口可以用解耦模块。
4.object(B)
Object 类是所有类的根类。
如果一个类没有显示继承另外一个类,那么该类一定继承于Object。
toString() 返回对象的字符串表示形式
1 public class Test01 { 2 public static void main(String[] args) { 3 Object obj = new Object(); 4 // 输出对象时,默认调用toString方法 5 System.out.println(obj); 6 // 类型@内存地址 7 System.out.println(obj.toString()); 8 9 10 Student s1 = new Student("二狗",20); 11 System.out.println(s1); 12 } 13 }
可以通过代码生成器快速生成toString方法。Alt+shift+s->Genrerate toString
equals(Object obj) 用于判断两个对象是否相等。
== 比较两个对象的内存地址或基本数据类型的比较,object默认equals实现比较内存地址。
equals:用于比较两个对象的内容(属性)是否相等。
当自定义对象时,要比较自定义对象是否相等,就必须通过equals方法比较两个对象属性值是否相等,那就必须重写Object的equals方法。
1 @Override 2 public boolean equals(Object obj) { 3 if(this == obj) { 4 return true; 5 } 6 7 Student s = (Student) obj; 8 if(this.sid.equals(s.sid) && this.name.equals(s.name) && this.age == s.age) { 9 return true; 10 }else { 11 return false; 12 } 13 }
5.内部类(B)
在java中,一个文件可以定义多个类,文件名必须和public 类型的类的类名保持一致。这两个类是平行关系。
在java中,一个类也可以定义在一个类的内部,定义在内部的类称为内部类(inner class),定义在外部的类称为外部类(out class).
1 public class Outer { 2 [修饰符] class Inner{ 3 } 4 }
编译后会出现$符outer$inner.class
成员内部
一个内部类作为一个外部类的成员而存在,此时该内部类称为外部类的成员内部类。
内部类都用默认修饰符
1 public class Outer { 2 class Inner{ 3 } 4 }
【1】内部创建对象
1 public class Test01 { 2 public static void main(String[] args) { 3 4 // 【1】创建外部类对象 5 Outer outer = new Outer(); 6 // 【2】创建内部类对象 7 Inner inner = outer.new Inner(); 8 inner.showInfo(); 9 } 10 }
【2】内部可以访问外部私有变量
1 public class Outer { 2 3 private String name = "Outer"; 4 5 class Inner{ 6 7 public void showInfo() { 8 System.out.println(name); 9 } 10 11 } 12 }
特殊情况:外部类和内部类的变量同名
1 public class Outer { 2 3 private String name = "Outer"; 4 5 class Inner{ 6 7 private String name = "Inner"; 8 9 public void showInfo() { 10 // String name = "show info"; 11 12 // 访问外部类的私有成员 13 System.out.println(this.name); 14 15 // 访问外部类的私有成员 16 System.out.println(Outer.this.name); 17 18 } 19 } 20 }