static关键字

1. 修饰属性，方法为静态
2. 被静态修饰的方法和属性，是同类一起加载的
3. 静态方法可以调用静态方法，不能调用非静态方法
4. 为什么要有静态方法？

代码块

public class Demo01 {
    //第二个执行，可以赋初始值
    {
        System.out.println("匿名代码块");
    }
    //第一个执行：只执行一次，随着类一起加载
    static{
        System.out.println("静态代码块");
    }
    //第三个执行
    Demo01(){
        System.out.println("构造方法");
    }

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

final

1. 一个类被final修饰之后，不能被继承

静态导入包

1. 示例：

//静态导入包--可以直接使用其中的方法
import static java.lang.Math.random;
public class Demo02 {
    public static void main(String[] args) {
        System.out.println(random());
    }
}

抽象类

1. abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法，如果修饰类，那么该类就是抽象类
2. 抽象类中可以没有抽象方法，但是有抽象方法的类一定是抽象类
3. 抽象类不能使用new关键字创建对象，作用：被子类继承
4. 抽象方法，只有方法的声明，没有方法的实现，方法的具体实现由子类完成
5. 子类继承抽象类，就必须实现抽象类中没有实现的抽象方法，否则该子类也要声明为抽象类

//abstract：修饰类和方法
//Java 单继承  但是（接口可以多继承）
public abstract class Demo03 {
    public abstract void test();

    public void test1(){

    }
}

6. 抽象类的意义：抽象的抽象，增强代码的复用性（定义非抽象方法）
7. 抽象类有构造方法吗？没有：new 关键字不能使用

接口（interface）

1. 普通类：只有具体的实现
2. 抽象类：具体的实现和抽象的方法都有
3. 接口：只有规范，自己不进行方法的具体实现；约束和实现分离：面向接口编程
4. oop的精髓，是对对象的抽象
5. 接口中的方法默认就是抽象的（public abstract void test();）
6. 接口都需要实现类，命名规范（*Impl.java）
7. 实现了接口的类，需要实现接口中的所有方法
8. 一个类可以实现多个接口，（变相的实现多继承）
9. 接口中的属性默认是静态常量修饰的（public static final int a=9;）

内部类

1. 定义：内部类就是在一个类的内部定义一个类，比如，A类中定义一个B类，那么B类就是A类的内部类，A类就是B类的外部类
2. 内部类的种类：
   1. 成员内部类
      1. 作用：可以获得外部类的私有属性和私有方法
   2. 静态内部类
   3. 局部内部类

package com.gaopeng.oop;

public class Demo04 {
    private int a=10;
    public void test(){
         class inner{
            public void test1(){
                System.out.println("成员内部类");
            }
        }
    }
    public class inner{
        public void test1(){
            System.out.println("内部类");
        }
    }
    public static class inner2{
        public void test1(){
            System.out.println("静态内部类");
        }
    }
}

4. 匿名内部类

public class Demo05 {
    public static void main(String[] args) {
        //没有名字初始化类，不用将实例化的对象保存到变量中，
        new a().test();
    }
}
class a{
    public void test(){
        System.out.println("匿名内部类");
    }
}