一 static关键字

• 静态变量再内存中只有一个，可以被本类共享
• 静态变量可以通过类名直接访问。
• 非静态变量，再实例化之后才可以访问
• 静态方法可以通过类名直接访问。
• 非静态方法，再实例化之后才可以访问。
• 静态方法跟类一起加载，可以通过类去访问

public class Demo01 {

    private static int age=10;//静态的变量
    private double score=10;//非静态的变量

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

        System.out.println(Demo01.age);
        System.out.println(demo01.age);
        System.out.println(demo01.score);

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

二 匿名代码块和静态代码块

• 匿名代码块：程序在执行的时候，并不能主动调用这些模块；创建对象的时候，自动就创建了，而且在构造器之前。
• 静态代码块：类一加载就直接执行，永久就执行一次。

public class Demo01 {
    {
        System.out.println("匿名代码块");
    }
	//只执行一次
    static {
        System.out.println("静态代码块");
    }
    public Demo01() {
        System.out.println("构造方法");
    }

    public static void main(String[] args) {

        Demo01 demo01=new Demo01();
        System.out.println("================");
        Demo01 demo011=new Demo01();

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

为了不写math的花样——展示【了解】

Final修饰的类不能被继承

public final class Person() {

}
1
2
3

三 抽象类

• 理解秘诀：抽象的抽象【约束】

abstract修饰符可以用来修饰方法也可以修饰类：
如果修饰方法.那么该方法就是抽象方法：如果修饰类，那么该类就是抽象类。

• 抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类。
• 抽象类，不能使用new关键字来创建对象，它是用来让子类继承的。
• 抽象方法，只有方法的声明，没有方法的实现它是用来让子类实现的。
• 子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。
• Java类是单继承的；接口可以是多继承。
• Abstract修饰的类会变成抽象类，这个类可以有正常的方法，抽象的方法靠非抽象的子代实现。
• 抽象类不可以实例化【new】，只能实例化它的一些非抽象的子类或者后代对象。

注意：
不能new这个抽象类，只能靠子类去实现它：约束
抽象类中可以写普通的方法
抽象方法必须在抽象类中



选择实现方法

思考题：

• 1 java 抽象类有构造器吗?
  • 有，Java抽象类的构造方法和普通类的构造方法一样，都是用来初始化类。只是抽象类的构造方法不能直接调用 因为抽象类不能实现实例。但是一旦一个普通类继承了抽象类，便也可以在构造函数中调用其抽象类的构造函数，也可以使用其方法。
  • 这么理解： 抽象类就是一个不能实例化的不同类，不过如果方法加了abstract那么就必须在子类里面重写了
• 2 抽象类存在的意义？
  如果一个类里面有一种方法只有方法名却没有方法体，这样的类就是抽象类。
• 我们举个简单的例子：我们有一个动物的类，里面有一个Run的方法，这个时候我们需要继承他，一只狗说我会跑，老虎说我也会跑，孔雀说我也会跑，这个时候每一个子类都要继承他，而且由于Run方法已经被父类实现了，所以每一个都要重写方法体，是不是很麻烦，这个时候JDK就说了，既然那么多类需要继承他，我直接不实现这个方法，你们谁用谁实现算了。这个就是抽象类存在的意义！
  官方语言：就是抽象类可以将设计和实现分离，你写你的抽象类，我写我的实现方法。这也是为什么说抽象方法必须被继承才有意义！
• 3 抽象类和接口可以有构造器吗？
  • 1)接口不能有构造方法，抽象类可以有。
  • 2)接口不能有方法体，抽象类可以有。
  • 3)接口不能有静态方法，抽象类可以有。
  • 4)在接口中凡是变量必须是public static final，而在抽象类中没有要求。

四 接口

• 普通类：只有具体实现。
• 抽象类：具体实现和规范（抽象方法）都有！
• 接口：只有规范！自己无法写方法～专业的约束！约束和实现分离：面向接口编程～
• 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须能…的思想。如果你是天使，则必须能飞：如果你是汽车，则必须能跑：如果你好人，则必须干掉坏人；如果你是坏人，则必须欺负好人。
• 接口的本质是契约，就像我们人间的法律一样，制定好后大家都遵守。
  OO的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如c++、iava、c#等），就是因为设计模式所研究的，实际上就是如何合理的去抽象

声明类的关键字是class.声明接口的关键字是interface

4.1 接口的作用

1. 约束
2. 定义一些方法，让不同的人实现。
3. 接口中是所有定义的方法都是抽象的 public abstract 修饰
4. 接口中的常量是 public static final 修饰
5. 接口不能被实例化，接口中没有构造方法
6. implments可以实现多个接口
7. 必须重写接口中的方法

代码案例

package 接口;
//interface 定义的关键字 接口都需要实现类
public interface UserService {
    //接口中是所有定义的方法都是抽象的 public abstract
    //public abstract 默认省略；写上会变灰色
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}
1
2
3
4
5
6
7
8
9
10

package 接口;

public interface TimeService {
    void time();
}

1
2
3
4
5
6

package 接口;
//实现了接口的类，就必须重写接口的所有的方法
//多继承 接口可以实现多继承
public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void time() {

    }

    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

五 内部类

• 内部类就是在一个类的内部在定义一个类。
• 比如，A类中定义一个B类，那么B类相对A类来说就，称为内部类，而A类相对B类来说就是外部类了

1. 成员内部类

- 成员内部类位于类的成员位置，内部类可以访问外部类的成员以及方法（包括私有private）。
- 外界创建对象使用（即先创建外部类对象再创建内部类对象调用）：外部类名.内部类名=外部对象.内部对象
1
2

• 外部类访问内部类
  • 外部类可以通过创建成员内部类实例来访问成员内部类中的属性和方法
• 成员内部类访问外部类
  • 成员内部类可以直接访问外部类的所有属性和方法

注意： 如果成员内部类B与外部类A包含同名的成员，那么在类B中， this.v表示类B的成员， A.this.v表示类A的成员。

public class Outer {
    //定义一个实例变量和一个静态变量
    private int a;
    private static int b;
    //定义一个静态方法和一个非静态方法
    public static void say(){}
    public void test(){
        //在外部类中调用内部类的属性和方法
        Inner inner = this.new Inner();
        inner.d = 1;    //通过创建内部类实例来调用内部类属性
        inner.number();    //通过创建内部类实例来调用内部类方法
    }
    //成员内部类
    public class Inner{
        //定义一个静态常量
        static final int m = 1;
        //在内部类中定义一个实例变量
        int c;
        public void number(){
            //在内部类中调用外部类的属性和方法
            a = 1;
            b = 1;
            say();
            test();    //内部类可以直接访问外部类的所有属性和方法
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

2. 静态内部类

• Java 的静态内部类就是定义在一个类的内部，并且标注为 static 的类。由于类是静态的，所以不需要通过外围类的实例来创建。
• 静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字static。
• 静态内部类是不需要依赖于外部类的，这点和类的静态成员属性有点类似，并且它不能使用外部类的非static成员变量或者方法。
• 这点很好理解，因为在没有外部类的对象的情况下，可以创建静态内部类的对象，如果允许访问外部类的非static成员就会产生矛盾，因为外部类的非static成员必须依附于具体的对象。

3. 局部内部类

• 局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。
• 注意，局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰符的。

class People{
    public People() {
         
    }
}
 
class Man{

    public People getWoman(){
        class Woman extends People{   //局部内部类
            int age =0;
        }
        return new Woman();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

4. 匿名内部类

• 匿名内部类是唯一一种没有构造器的类。正因为其没有构造器，所以匿名内部类的使用范围非常有限，大部分匿名内部类用于接口回调。

public class Demo01 {
    public static void main(String[] args) {
        //没有名字初始化类，不用将实例保存到变量中
        new Apple().eat();

         new UserService() {//实现接口的类，没有名字
            @Override
            public void Hello() {

            }
        };
    }
}

class Apple {
    public void eat() {
        System.out.println("eat");
    }
}

interface UserService {
    void Hello();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23