面向对象-接口

static静态

由于static是和类一起加载的，所以：

• 非静态方法可以直接访问类中的静态方法

• 静态方法不能直接调用非静态中的方法

public class Student {
    public static int age;//静态的变量  多线程！
    public double score;//非静态的变量

    public void run(){
    }
    public static void go(){
        System.out.println("go");
      //Student.run();
      //静态方法不可以直接调用非静态方法
    }

    public static void main(String[] args) {
        go();
    }
}

public class Person {
    //2.赋初值
    {
        System.out.println("匿名代码块");
    }
    //1.只执行一次
    static {
        System.out.println("静态代码块");
    }
    //3.第三个执行
    public Person(){
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println("-----------");
        Person person2 = new Person();
    }
}

//静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class MathImport {
    public static void main(String[] args) {
        System.out.println(random());//随机数方法
        System.out.println(PI);
    }
}

接口

意义

• 普通类：只有具体实现
• 抽象类：具体实现和规范（抽象方法）都有
• 接口：只有规范！自己无法写方法！专业的约束，约束和实现分离。
  • 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须能…”，比如如果你是鸟则必须能飞。
  • 接口的本质是契约，就像我们人间的法律
  • 面向对象的精髓是对对象的抽象，最能体现这一点的就是接口。
• 声明类的关键字是class，声明接口的关键字是interface。

实现

//interface 定义的关键字，接口都需要有实现类
public interface UserService {
    //接口中的所有定义的方法其实都是抽象的 public abstract
    //public abstract void add();所以可以省略public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

public interface TimeService {
    void timer();
}

//抽象类：extends
//类可以实现接口：implements 接口
//实现了接口的类，就需要重写接口中的方法
public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void add(String name) {
    }
    @Override
    public void delete(String name) {
    }
    @Override
    public void update(String name) {
    }
    @Override
    public void query(String name) {
    }
    @Override
    public void timer() {
    }
}

作用

1. 约束
2. 定义一些方法，让不同的人实现，比如一个接口有十种不同的完成方式
3. 定义方法：public abstract
4. 定义静态常量：public static final
5. 接口不能被实例化，因为接口中没有构造方法
6. 用implements可以实现多个接口
7. 必须要重写接口中的方法

内部类

写在外部类里面的类称为内部类，内部类可以获得外部类的私有属性。一个Java类中可以有多个class类，但是只能有一个public class。

public class Outer {
    private int id = 10;
    public void out(){
        System.out.println("这是外部类的方法");
    }
public class Inner {
     public void in(){
        System.out.println("这是内部类的方法");
        }
    //获得外部类的私有属性
    public void getId(){
        System.out.println(id);
    }
    }
}

public class App {
    public static void main(String[] args) {
        Outer outer = new Outer();
        //通过这个外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getId();

    }
}

• 静态内部
  • 不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员。
  • 静态内部类会先加载static,只有内部类可以用静态修饰

//外部类
public class Outer {
    private String name = "张";
    private int age = 18;
    //静态内部类 等同于外部类
    static class Inner{
        private String name = "李";
        private int age = 20;
        //静态成员
        private static String count = "1000";
        public void test1() {
            //调用外部类属性
            //1.创建外部类对象
            Outer outer = new Outer();
            //2.调用外部类对象的属性
            System.out.println(outer.name);
            System.out.println(outer.age);
            //调用静态内部类属性和方法
            System.out.println(this.name);
            System.out.println(this.age);
            System.out.println(Inner.count);
        }
    }
}

public class Test extends Outer{
    public static void main(String[] args) {
        //直接创建内部类对象
        Outer.Inner inner = new Outer.Inner();
        //调用方法
        inner.test1();
    }
}

• 局部内部类
  • 定义在外部类方法中，作用范围仅限于当前方法。
  • 局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为 final。
  • 限制类的适用范围。

public class Outer{
    //局部内部类
    public void method(){
        class Inner{
           public void in(){   }
        }
    }
}

• 匿名内部类
  • 没有名字初始化类，不用将实例保存到变量中，相当于创建了一个局部内部类。
  • 必须继承一个父类或者实现一个接口。
  • 定义类、实现类、创建对象的语法合并，只能创建一个该类的对象。
  • 优点：减少代码量
  • 缺点：可读性低

public class Test {
    public static void main(String[] args) {
        //匿名对象：没有名字初始化类，不用将实例保存到变量中
        new Apple().eat();
        //匿名类
        UserService1 userService=new UserService1(){
           @Override
           public void hello(){
            }
        };
    }
}
class Apple{
        public void eat(){
            System.out.println("1");
        }
    }
interface UserService1{
    void hello();
}