接口,枚举

---

接口

1.定义类：类中书写抽象方法（不建议使用，类只能单一继承）
2.定义接口，接口中写抽象方法

接口是什么？

接口作用：定义规则

概念：一个类中都是抽象方法，此类就是一个定义规则的一个类。
接口是一种引用数据类型，它比抽象类还抽象。

接口存在的意义？

规则定义/程序的扩展性

接口的定义和特点

public interface 接口名{
}

接口不能实例化
接口中没有构造方法（接口只能通过子类创建对象）
接口权限public/缺省
接口中的成员变量都是常量
类和接口之间是实现关系，通过implements关键字实现，单实现/多实现

public class 类名 implements 接口名{}

接口的子类（实现类）
要么重写接口中的所有抽象方法
要么就是抽象方法

//接口格式

    使用关键字 interface 声名接口
    public interface 接口 extends 接口A,B,C...
    {
        public static final 数据类型 成员变量 = 变量值；
        /*接口中的成员变量都是常量，声明时必须赋值，
          默认修饰符为public static final,不能声明实例成员变量*/
        //不能包含构造方法，构造方法没有抽象的
        //接口权限public/缺省
        //接口不能实例化
        public abstract 返回值 方法名(参数列表);
    }

接口中成员的特点

成员变量：只能是常量（public static final）
构造方法：没有构造方法没有抽象的
成员方法：只能抽象方法（public abstract）

接口和类的关系

类和类之间

继承关系，只能单继承，不能多层继承

类和接口的关系

实现关系，可以单一实现，也可以多实现，还可在继承一个类的同时实现多个接口

接口和接口的关系

继承关系，可以单继承，也可多继承

问题？接口为啥可以多继承呢？

接口中仅仅只是定义功能（没有实现功能，子类要自己实现功能）

接口和抽象类的区别

接口和抽象类都是抽象类型
都不能实例化，都当父类型使用
使用区别：事物共性内容（行为、属性），抽取到父类中（可以是抽象类）
特有行为，可以抽取到接口中

package jiekou;
/*
学习男/女同学：性别年龄学习
打篮球男/女同学：性别年龄学习打篮球
男的不爱学习，女的爱学习

分析：共性问题（性别年龄学习）
    特性问题：打篮球
共性问题：类 -->不想这个类实例化：抽象类
特有问题：接口

 */
public abstract class Person {
    //抽象类
    //注意 非抽象类：必须设定抽象方法的方法体，或者把这个类设定成抽象方法
    //    抽象类：可以是抽象方法，也可以是非抽象方法
   public String name;
   public int age;

    public Person(String name,int age){
        this.age = age;
        this.name = name;
    }
    public abstract void study();
}

---------------------------------
public class Boy extends Person{
    public Boy(String name, int age) {
        super(name, age);
    }

    public void study(){
        System.out.println("男的不爱学习");
    }
    public  void basketball(){
        System.out.println("男生打篮球");
    };
}

----------------------------------
public class Girl extends Person implements Play{
    public Girl(String name, int age) {
        super(name, age);
    }

    public void study(){
        System.out.println("女的爱学习");
    }
    public void basketball(){
        System.out.println("女生打篮球");
    };
}
----------------------------------
public interface Play {
    public abstract void basketball();
}
----------------------------------

public class Test {
    public static void main(String[] args) {
        Boy b = new Boy("xx", 22);
        Girl g = new Girl("LVLV", 22);
        System.out.println(b.age+b.name);//22xx
        System.out.println(g.name+g.age);//LVLV22
        b.study();//男的不爱学习
        b.basketball();//男生打篮球
        g.study();//女的爱学习
        g.basketball();//女生打篮球
    }
}

枚举

记得switch吗？

switch(常量表达式) {
//byte，short，int,char,string,枚举
case 常量值1:语句1;break;
}

枚举：what？

一种数据类型，用来表示：固定且有几种取值范围的数据

例子：性别
public interface Gender{
public static final String Boy = "男";
public static final String Girl = "女";
}
public class Student{
  String name;
   int age;
   String sex;
  public Student(String name,int age,String sex){
  this.name = name;
  this.age =age;
  this.sex = sex;
  }
}
Student s = new Student("xx",22,Gender.Girl);
Student s = new Student("ll",22,"bb");//发现没有报错，也可以赋值，但是不符合要求
解决方法：枚举类型
当程序中有数据是固定且只有几种数据范围，就可以使用枚举类型进行强制设置值

枚举格式

enum枚举关键字：
权限修饰符 enum 枚举名称{
枚举项1,枚举2…;
}
枚举之间使用逗号隔开，最后时分号结束

public enum Sex{
 Boy,Girl;
 }
 public class Student{
  String name;
   int age;
   Sex gender;
  public Student(String name,int age,Sex gender){
  this.name = name;
  this.age =age;
  this.gender= gender;
  }
  Student s = new Student("ll",22,"bb");//报错，性别必须时Sex枚举
  Student s = new Student("xx",22,Sex.Girl);//正确

枚举的具体了解

//枚举原来的样子
//枚举都是继承java.lang.Enum
//枚举都是最终类，不可以继承
//构造器都是私有的，枚举对外不能创建对象
//枚举的第一行都是列举对象的名称
//枚举相当于多例模式
/*
枚举本质上是一个final类，继承Enum类
枚举是一个类，可以类中定义成分 比如：成员变量，构造方法等（枚举内部可以定义什么）
是私有的，外界无法调用，只能定义枚举项的时候使用（构造方法）
直接调用枚举项（使用方法）
/
/
public enum Siganl extends java.lang.Enum<_Siganl> {
public static final Siganl GREEN;
public static final Siganl RED;
public static final Siganl YELLOW;
public static final Siganl[] $VALUES;
public static Siganl[] values();
//将所有对象返回
public static Siganl valueOf(java.lang.String);
//根据枚举常量名字字符串，转换为枚举类型
private Siganl(); 构造方法
static{};//静态代码块
}

枚举例子

public class hll {
    public  static void chang(Siganl color){
        switch (color) {
            case GREEN:
                System.out.println("绿灯");
            case RED:
                System.out.println("红灯");
            case YELLOW:
                System.out.println("黄灯");
        }
    }
}
 class test{
     public static void main(String[] args) {
         hll.chang(Siganl.GREEN);
     }

}
------------------------------------
package meiju;

public class hll {
    public  static void chang(Siganl color){
        switch (color) {
            case GREEN:
                System.out.println("绿灯");
            case RED:
                System.out.println("红灯");
            case YELLOW:
                System.out.println("黄灯");
        }
    }
}
 class test{
     public static void main(String[] args) {
         hll.chang(Siganl.GREEN);
     }

}
----------------------------------