接口与类

static关键字

 //执行顺序：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();//输出：匿名代码块   构造方法
 }

 //不使用静态导入包
 public class Test{
     public static  void main(String[] args){
          System.out.println(Math.random());
 }
 }
 //使用静态导入包
 import static java.lang.Math.random();
 import static java.lang.Math.PI;
 public class Test{
     public static  void main(String[] args){
         System.out.println(random());
         System.out.println(PI);
 }
 }

被final修饰的类不能被继承

抽象类

1. 通过abstract修饰

   public abstract class Action{//抽象类

   //abstract,抽象方法，只有方法名字，没有方法的实现，别人帮忙实现

   public abstract void doSomething();

   }

2. 抽象类的所有方法，继承了它的子类，都必须要实现它的方法，除非子类也是抽象类,由子子类去实现

   public class A extends Action{

   @override

   public void doSomething(){

   }

   }

3. 总结

   1. 不能new这个抽象类，只能靠子类去实现它 它是一个约束

   2. 抽象类中可以写普通的方法

   3. 抽象方法必须在抽象类中

   4. 抽象的抽象：约束

   5. 提高开发效率，提高可拓展性

   6. 抽象类可以有构造方法，它的作用不是实例化对象而是初始化变量

接口

接口可以多继承

1. 接口和其它类的区别：

   普通类：只有具体实现

   抽象类：具体实现和规范（抽象方法）都有

   接口：只有规范！自己无法写方法 专业的抽象 实现约束和实现分离：面向接口编程

   声明类的关键词是class,声明接口的关键词是interface

2. 接口的本质是契约（就像人间的法律一样。制定好后大家都遵循）

3.  

    public  interface UserService{
        //接口中的所有定义其实都是抽象的public abstract（默认）
        void run();
        //常量  public static final   不常用
        int AGE = 99;
    }
    public  interface Timer{
        void time();
    }

4. 接口都需要实现类，实现类的命名规范：名字后加Impl

    //实现了接口的类，就需要重写接口中的方法
    public class UserServiceImpl implements UserService,Timer{
        @Override
        public void run(){
            
        }
        @Override
        public void time(){
            
        }
    }

5. 作用：

   1. 约束

   2. 定义一些方法，让不同的人实现 一个接口可以通过十个人实现10个不同的接口

   3. 接口中默认方法修饰符 public abstract

   4. 常量修饰词 public static final

   5. 接口不能被实例化，接口中没有构造方法

   6. implements可以实现多个接口

   7. 必须要重写接口中的方法

内部类

1. 在一个类的内部再定义一个类 A中定义一个B类，那么B类相对A类就是内部类，而A类相对B类来说就是外部类

2. 成员内部类

    public class Outer {
        private int id = 10;
        public  void out(){
            System.out.println("这是外部类的方法");
        }
        class Inner{
            public void in(){
                System.out.println("这是内部类的方法");
            }
            //获得外部类的私有属性
            public void getID(){
                System.out.println(id);
            }
        }
    }
    public class Application {
        public static void main(String[] args) {
            Outer outer = new Outer();
            outer.out();
            //通过外部类来实例化内部类
            Outer.Inner inner = outer.new Inner();
            inner.in();
            inner.getID();
        }
    }

3. 静态内部类

    public class Outer {
        private int id = 10;
        public  void out(){
            System.out.println("这是外部类的方法");
        }
        public static class Inner{
            public void in(){
                System.out.println("这是内部类的方法");
            }
        }
    }

4. 局部内部类

    public class Outer {
        public void method(){
            class Inner{
                public void in(){
                    
                }
            }
        }
    }

5. 匿名内部类

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

6.  public class Outer {
    ​
    }
    //一个java类中可以有多个class类，但是只能有一个public class类
    class C{
        public static void main(String[] args) {
            
        }
    }