//1.接口
//1.1 接口概述
//接口： 特殊的抽象类，使用方式及组成部分都与抽象类类似
//语法： interface implements
//注意： 在接口中只能定义公开的静态常量及公开的抽象方法
//接口与抽象类的异同：
//相同点：
//可以编译成字节码文件
//都不能具体化
//都可以作为引用对象(多态)
//都可以使用Object(祖宗类)的方法（继承）
//不同点:
//接口属性都是公开的静态常量
//接口方法都是公开的抽象方法
//接口没有构造方法，动态代码块，静态代码块
//问题：在接口中能否有非抽象方法？ 在jdk1.8中提供了default修饰的非抽象方法，一般很少使用
//定义一个接口，名字为MyInterface
interface MyInterface{
//public static final: 公开的静态常量
int SEX_MAN=1; //查看反编译工具
//public abstract: 公开的抽象方法
void test();
public default void show() {
}
}
//MyImpl实现类实现了MyInterface接口，提供两种处理方式：
//1.重写接口的抽象方法 2.把自身变为抽象类
/*abstract*/ class MyImpl implements MyInterface{
@Override
public void test() {
System.out.println("重写接口的抽象方法");
}
}
public class Test1 {
public static void main(String[] args) {
//MyInterface interface1 = new MyInterface(); //不能具体化
MyInterface interface1 = new MyImpl();
interface1.getClass(); //根据继承性, 可以调用Object的方法
}
}
//1.2 接口代表一种能力
//=========================接口直接引用实现多态=========================
//什么是接口：
//从微观上讲，接口代表着一种能力或约定
//案例：喷火娃具备喷火能力，飞天娃具备飞天能力
//接口代表某种能力，方法的定义代码具体能力体现
interface Fireable{ //可喷火的接口
void fire(); //可喷火的能力体现
}
interface Flyable{
void fly(); //可飞天的能力体现
}
//接口可以多实现
class Person implements Fireable,Flyable{
String name;
public Person(String name) {
this.name = name;
}
@Override //因为接口的抽象方法是public权限，所以实现类重写方法的权限必须是public
public void fire() {
System.out.println(name+"正在喷火");
}
@Override
public void fly() {
System.out.println(name+"正在飞天");
}
public void eat() {
System.out.println(name+"很能吃..");
}
}
public class Test {
public static void main(String[] args) {
//接口直接赋值方式实现多态： 接口引用指向实现类对象，可调用实现类重写方法
Fireable fireable = new Person("喷火娃");
fireable.fire();
Flyable fiFlyable = new Person("飞天娃");
fiFlyable.fly();
//问题：接口使用能否调用实现类独有方法？ 不能调用，除非强转
Person person = (Person) fireable; //强转后把接口当成Person看待
person.eat();
}
}
//====================接口与抽象类直接引用实现多态====================
//应用： 接口与抽象类的综合应用
//案例：狗是动物，具备叫的行为,动物自身有吃的方法，且狗具备可游泳的能力，它自身有一个打印方法
abstract class Animal{
public abstract void bark();
public void eat() {
System.out.println("动物正在吃..");
}
}
interface Swimable{
void swim(); //具备可游泳的能力体现
}
class Dog extends Animal implements Swimable{
@Override
public void bark() {
System.out.println("小狗正在叫..");
}
@Override
public void swim() {
System.out.println("小狗正在游泳..");
}
public void print() {
System.out.println("狗的自我介绍...独有方法");
}
}
public class Test2 {
public static void main(String[] args) {
//把狗当狗来看待，可以调父类吃的方法，可以调重写父类方法叫的方法，可以调自己独有的打印方法；可以调重写接口的方法
/*Dog dog = new Dog();
dog.bark(); dog.eat();dog.print();dog.swim();*/
//把狗当动物看待，可以调父类方法，可以调子类重写方法(抽象类实现多态)
Animal animal = new Dog(); //抽象类实现多态
animal.eat(); //调父类方法
animal.bark(); //调子类重写方法
//把狗当成可游泳的能力
Swimable swimable = new Dog(); //接口实现多态
swimable.swim(); //调实现类重写方法
}
}
//=========================接口的细节========================
//接口与类的相关关系：
//1.类与类之间-----单继承
//2.类与接口------多实现
//3.接口与接口-----多继承----相当于实现类中，一定要将子接口中继承的所有接口都实现了
class Animal{
}
interface Runable{
}
interface Swimable{
}
//接口与接口，可以多继承； 如果实现类Tiaoable接口，必须把跑和游泳的接口都实现
interface Tiaoable extends Runable,Swimable{
int SEX_MAN=1; //常量接口（其实就是之前写的静态常量--状态值）
int SEX_WOMAN=0;
}
class Dog extends Animal implements Runable,Swimable{
}
public class Test1 {
public static void main(String[] args) {
int sex = Tiaoable.SEX_MAN; //通过接口名调用静态常量
if(sex==Tiaoable.SEX_MAN) {
System.out.println("男性");
}else if(sex==Tiaoable.SEX_WOMAN) {
System.out.println("女性");
}
}
}
//1.3 接口代表一种标准
//==================接口以传参方式实现多态===================
//宏观概念： 接口代表一种标准(接口以传参方式实现多态)
//思考案例： 电脑连接usb标准的鼠标，硬盘等设备，这些设备都可以运转
//分析：
//类： 电脑类 usb接口 鼠标类 硬盘类
//方法： 连接 运转 运转 运转
//接口的好处：
//使程序的耦合度降低,更自然地使用多态
//更容易更换具体实现，及更容易使用框架(后续会学习)
interface USB{ //遵循usb标准
void run();
}
class Mouse implements USB{
@Override
public void run() {
System.out.println("鼠标正在运转...");
}
}
class Disk implements USB{
@Override
public void run() {
System.out.println("硬盘正在运转...");
}
}
class Computer{
public void connect(USB usb) { //USB usb=new Mouse();
usb.run(); //接口回调：谁传给我，我就回调谁
}
}
public class Test1 {
public static void main(String[] args) {
Computer computer = new Computer();
computer.connect(new Mouse()); //电脑连接鼠标
computer.connect(new Disk()); //电脑连接硬盘
}
}
====================接口及抽象类实现多态===================
//案例: 人开门； 安全门，超级防盗门都是门，具备开的行为描述;安全门局部指纹识别标准；超级防盗门具备指纹识别和人脸识别标准
//分析：
//类: 人 安全门 超级防盗门， 门， 指纹识别， 人脸识别
//方法： 开，指纹检测，人脸 描述，1标准 描述，2标准 开的描述 标准 标准
//面向对象设计原则：ISP原则：
//接口隔离原则： 接口与接口之间是隔离的，往往一个接口只放一种方法
abstract class Door{
public abstract void info(); //开的行为描述
}
class SafeDoor extends Door implements IHandler{
@Override
public void info() {
System.out.println("安全门描述....");
}
@Override
public void handlerStandard() {
System.out.println("安全门的指纹识别检测...");
}
}
class SuperDoor extends Door implements IHandler,IFace{
@Override
public void info() {
System.out.println("超级防盗门描述....");
}
@Override
public void faceStandard() {
System.out.println("超级门的人脸识别...");
}
@Override
public void handlerStandard() {
System.out.println("超级门的指纹识别...");
}
}
interface IHandler{ //指纹检测接口
void handlerStandard();
}
interface IFace{ //人脸检测接口
void faceStandard();
}
class Person{
public void open(Door door) {//传参形式实现多态
door.info(); //门的描述--谁传给我，就就调谁
}
public void handlerCheck(IHandler handler) {
handler.handlerStandard(); //指纹识别的检测标准
}
public void faceCheck(IFace face) {
face.faceStandard(); //人脸识别的检测标准
}
}
public class Test2 {
public static void main(String[] args) {
Person person = new Person();
//------------抽象类实现多态------------
person.open(new SafeDoor()); //人开安全门
person.open(new SuperDoor()); //人开超级门
//------------接口实现多态--------------
person.handlerCheck(new SafeDoor()); //人指纹检测安全门
person.handlerCheck(new SuperDoor()); //人指纹检测超级门
person.faceCheck(new SuperDoor()); //人通过人脸检测超级门
}
}
/*
2. 内部类
概述：一个类的内部又包含了一个完整的类
特点：
1.外部类和内部类都可以生成独立字节码文件
2.内部类可直接使用外部类的私有成员属性，而不破坏封装性
3.外部类的具体实现可以交给内部类来完成
*/
// 2.1 实例内部类
//实例内部类用法： 1.使用特点 2.调用方式
class Outter{ //外部类
private String name="凤姐";
public int add(int a,int b) {
return new Inner().addFun(a, b); //具体功能交给内部类完成
}
class Inner{ //实例内部类： 在外部类中包含的一个类
//The field count cannot be declared static in a non-static inner type, unless initialized with a constant
private final static int count =1; //只能用静态常量，不能直接用静态变量
//private String name="刘亦菲";
public int addFun(int a,int b) {
return a+b;
}
public void innerTest() {
//如果外部类和内部类属性出现重名，内部类优先
System.out.println(name); //可以直接使用外部类的私有成员
}
}
}
public class Test1 {
public static void main(String[] args) {
//方式1：实例化外部类对象，调用add方法
Outter outter = new Outter();
System.out.println(outter.add(1, 2));
//方式2：直接实例化内部类对象，调用内部类的方法(了解)
Outter.Inner inner = new Outter().new Inner();
System.out.println(inner.addFun(3, 4));
inner.innerTest(); //
}
}
Java程序猿必学第十一篇——接口
猜你喜欢
转载自blog.csdn.net/m0_62718093/article/details/120958648
今日推荐
周排行