1.抽象Abstract：抽象类和抽象方法；

抽象类：不完整的类，就是抽象类：abstract class 类名；

抽象方法:只有声明，没有实现的方法；

abstract 返回值类型 方法名（参数）；

因为类不完整，所以无法直接构建对象；抽象类无法直接构建对象，但是可以通过子类间接构建对象；

如果一个类中含有抽象方法，那么这个类是抽象类；

如果一个类是抽象类，他的方法不一定是抽象方法；

例如：

import java.util.concurrent.Callable;

public class java_3_24
{
    public static void main(String[] args) {
    Child c = new Child();
    c.eat();
    }

}
abstract class Person{
    public abstract void eat();
}
class Child extends Person{
    public void eat(){
        System.out.println("中国人");
    }
}

注意：在抽象类中只需声明方法即可；再在子类中把方法进行补充；

小心：abstract关键字不能和final同时使用；

2.接口：

所谓的接口，可以简单理解为规则；

基本语法：   interface 接口名称{    规则属性， 规则的行为}；

接口其实是抽象的；

规则的属性必须是固定值，而且不能修改；

属性和行为的访问权限必须为公共的；

属性应该是静态的；

行为应该是抽象的；

接口和类是两个层面的东西；

接口可以继承其他接口；

类的对象需要遵循接口，在Java中，这个遵循，称之为实现（implements），类需要实现接口，而且可以实现多个接口；

例如：

import java.util.concurrent.Callable;

public class java_3_24
{
    public static void main(String[] args) {
    Computer c = new Computer();
    Light light = new Light();
    c.usb1 = light;
    Light light1 = new Light();
    c.usb2 = light1;
    c.powerSupply();
    }

}
interface USBInterface{

}
interface USBSupply extends USBInterface{
    public void powerSupply();
}
interface USBReceive extends USBInterface{
    public void powerReceive();
}
class Computer implements USBSupply{
    public USBReceive usb1;
    public USBReceive usb2;
    public void powerSupply(){
        System.out.println("电脑提供能源");
        usb1.powerReceive();
        usb2.powerReceive();
    }
}
class Light implements USBReceive{
    public void powerReceive(){
        System.out.println("电灯接收能源");
    }
}

首先定义了USB接口的规则，然后分别让supply和receive分别继承该规则，然后让计算机和台灯分别满足对应规则，计算机中定义两个usb接口，定义能源提供的方法；light中定义能源接收的方法；

3.枚举：

枚举是一个特殊的类，其中包含了一组特定的对象，这些对象不会发生改变，一遍都使用大写的标识符。

枚举使用enum关键字使用；

枚举类会将对象放置在最前面，那么和后面的语法需要使用分号隔开；

枚举类不能创建对象，它的对象是在内部自行创建；

例如：

import java.util.concurrent.Callable;

public class java_3_24
{
    public static void main(String[] args) {
        System.out.println(City.BEIJING.name);
        System.out.println(City.SHANGHAI.code);
    }

}
enum City{
    BEIJING("北京", 1001), SHANGHAI("上海", 1002);
    City( String name, int code){
        this.code = code;
        this.name = name;
    }
    public String name;
    public int code;
}

创建了两个城市，在构造时传参，并赋值给城市的属性，这样就达到了创建类的一个效果；

4.匿名类：

import java.util.concurrent.Callable;

public class java_3_24
{
    public static void main(String[] args) {
    Me me = new Me();
    me.sayHello(new Zhangsan());
    }

}
abstract class Person{
    public abstract String name();
}
class Me{
    public void sayHello(Person person){
        System.out.println("Hello " + person.name());
    }
}
class Zhangsan extends Person{
    public String name(){
        return "zhangsan";
    }
}

创建一个me对象，然后调用sayhello方法，传入一个Zhangsan类的对象，他是改写的抽象类Person的所以将对象传进去，打印hello+name；

也可以这样写：

import java.util.concurrent.Callable;

public class java_3_24
{
    public static void main(String[] args) {
    Me me = new Me();
    me.sayHello(new Person() {
        @Override
        public String name() {
            return "wangwu";
        }
    });
    }

}
abstract class Person{
    public abstract String name();
}
class Me{
    public void sayHello(Person person){
        System.out.println("Hello " + person.name());
    }
}

直接传入抽象的类并在小括号内进行函数方法的初始化；

再例：

import java.util.concurrent.Callable;

public class java_3_24
{
    public static void main(String[] args) {
        Bird b = new Bird();
        b.fly();
    }

}
interface Fly{
    public void fly();
}
class Bird implements Fly{
    public void fly(){
        System.out.println("使用翅膀飞翔");
    }
}

转换为对应的匿名类模式：

import java.util.concurrent.Callable;

public class java_3_24
{
    public static void main(String[] args) {
        new Fly(){
            @Override
            public void fly() {
                System.out.println("使用飞行器飞翔");
            }
        }.fly();
    }

}
interface Fly{
    public void fly();
}

5.建立数据模型：

Bean类的设计规范：Bean规范：

（1）类要求必须含有无参，公共的构造方法；

（2）属性必须私有化，然后提供公共的set，get方法；

一个简单的登陆系统：

public class java_3_24
{
    public static void main(String[] args) {
        User user = new User();
        user.account = "admin";
        user.password = "admin";
        System.out.println(login(user));

    }
    public static boolean login(User user){
        if (user.account.equals("admin") && user.password.equals("admin")){
            return true;
        }else {
            return false;
        }
    }
}
class User{
    public String account;
    public String password;
}

优化后：

public class java_3_24
{
    public static void main(String[] args) {
        User user = new User();
        user.setAccount("admin");
        user.setPassword("admin");
        System.out.println(login(user));

    }
    public static boolean login(User user){
        if (user.getAccount().equals("admin") && user.getPassword().equals("admin")){
            return true;
        }else {
            return false;
        }
    }
}
class User{
    private String account;
    private String password;
    public void setAccount(String account){
        this.account = account;
    }
    public void setPassword(String password){
        this.password = password;
    }
    public String getAccount(){
        return account;
    }
    public String getPassword(){
        return password;
    }
}