java、day12 static总结 程序加载顺序 抽象类 接口 implement

static总结

1.假如在同一类下

static可以通过类名点方法来访问（甚至可以不创建对象就可以），其他的是不可以的。只能通过对象点方法来调用

 public class Test2 {
     public static int age;
 ​
     public static void main(String[] args) {
 //不用创建对象，因为age是静态变量
         Test2.age=18;
         System.out.println(Test2.age);
     }
 }

 

• 静态方法可以直接调用静态方法

• 动态方法可以直接调用动态方法

• 动态方法可以直接调用静态方法

• 只有静态方法不能调用动态方法

 //Demo02  类
 public class Demo03 {
 ​
     public static void main(String[] args) {
 ​
     }
 //可以直接静态调用静态
 public static void a(){    b();       }
 public static void b(){           }
 ​
 //动态可以直接调用动态
 public void c(){    d();       }
 public void d(){           }
 ​
 //动态可以调用静态
 public   void e(){    f();       }
 public  static void f(){           }
 ​
 ​
 //不可以报错
 //public  static void w(){      z();     }
 //public   void z(){          }
 ​
 }

 

2.程序加载顺序

1. 首先加载类

2. 和类同时加载的有静态static（只加载一次）

3. 加载其他匿名代码块(也可以用来初始化)

4. 加载构造器

5. 每次用创建该对象的类，都会加载匿名模块和构造器（所以可以用来初始化，演示如下图代码所示）

 public class Test {
     {
         System.out.println("匿名代码块");
     }
 ​
     static {
         System.out.println("静态代码块");
     }
 ​
     public Test() {
         System.out.println("构造器");
     }
 ​
     public static void main(String[] args) {
         Test test1 = new Test();
         System.out.println("==============");
         Test test2 = new Test();
     }
 ​
 }
 ​
 结果：
 静态代码块
 匿名代码块
 构造器
 ==============
 匿名代码块
 构造器

 

3.狂神小玩静态

 import static java.lang.Math.random;
 //静态导入包
 public class Test3 {
 ​
 ​
     public static void main(String[] args) {
 //        正常使用时
         System.out.println(Math.random());
 ​
 //        静态导入包以后
         System.out.println(random());
 ​
     }
 }
 结果两个随机数

 

抽象类（abstract）

1.抽象类是什么

• 抽象类就是在其中写一个抽象方法，但是自己不去实现他

• 抽象类的所有抽象方法需要子类继承他的时候需要重写，除非子类也是抽象类

• 适合写框架的人来写

• 也是实现约束的方法

2.抽象类的特点

• 不能new这个对象，只能靠子类来实现他：约束！

• 抽象类中可以写普通方法

• 抽象方法必须写在抽象类中

 

接口（interface）

1.接口的特点

• 普通类：只有具体实现

• 抽象类：具体实现和规范都有

• 接口：只有规范！自己无法写方法~专业的约束：面向接口编程

2.接口中的所有定义都是抽象的

• 如果你不写都是默认 public abstract 的只要写void 方法就行了

3.多继承以及程序演示

 //程序1
 ​
 package oop.Demo09;
 ​
 //一般实现类，我们都会用impl来结尾
 //实现类关键词 implements +接口
 //实现了接口的类，就要重写接口的方法
 //多继承，通过接口来实现多继承
 public class UserServiceImpl implements  UserService,TimeService{
 ​
 ​
     @Override
     public void add(String name) {
 ​
     }
 ​
     @Override
     public void del(String name) {
 ​
     }
 ​
     @Override
     public void update(String name) {
 ​
     }
 ​
     @Override
     public void query(String name) {
 ​
     }
 ​
     @Override
     public void sha() {
 ​
     }
 }
 ​
 //程序2
 public interface TimeService {
     void sha();
 }
 ​
 ​
 //程序3
 //定义的关键字 interface,接口都需要有实现类
 public interface UserService {
 ​
 //增删改查
 //    默认都是抽象类public abstract
 ​
     public abstract void add(String name);
     void del(String name);
     void update(String name);
     void query(String name);
 ​
 ​
 }

 

4.接口中的常量（一般不会有人在接口中定义常量）

• public static final

5.接口中的作用

• 约束

• 定义一些方法，让不同的人实现

• 接口里面的方法public abstract

• 接口里面的常量public static final

• 接口不能被实例化 接口中没有构造方法

• impements可以实现多个接口

• 必须重新接口中的方法

•