面向对象编程（2）

static关键字

1. 加在变量前，将变量变成静态变量
2. 加在方法前，将方法变成静态方法
3. 静态方法，静态变量是可以直接调用的

public class test {
    public static int age;   //静态变量
    public String name="lerry"; //非静态变量
    public static void main(String[] agrs) {
        System.out.println(age);   //不报错，可以直接调用
        System.out.println(name);  //报错，必须创建对象调用
    }
}

静态变量与非静态变量

• 静态变量可以不赋初始值，非静态变量必须赋初始值
• 静态变量可以直接使用，在加载类的时候已经将静态变量加载完成

静态方法和非静态方法

• 静态方法可以直接被调用
• 非静态方法需要构建对象，然后通过对象调用

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

• 静态代码块：

  static{
      .....   //只在最开始构建对象时被执行一次
  }
  

• 匿名代码块：

  {
      .....  //每次构建对象时都会被执行，可以进行初始化赋值
  }
  

  构建对象：静态代码块->匿名代码块->构造器->构造

静态导入包

import static java.lang.Math.方法;  //导入后，可以直接在代码中调用该方法，而不用写Math.方法()

使用final修饰的类不能被继承

抽象类

1. 抽象类：使用abstract修饰符修饰一个类
2. 抽象方法里面只有方法的名字，没有方法的实现
3. 继承了抽象类的子类，必须重写父类的方法，除非子类也是一个抽象类

public abstract class Person {   //抽象类Person
    public abstract void test();   //抽象方法test
}

public class Student extends Person{   //抽象类的子类Student

    @Override  //重写方法
    public void test(){
        System.out.println("test");
    }
}

注意：1. 抽象类的方法可以是抽象方法，也可以是正常方法，但是抽象方法必须在抽象类里面

​ 2.抽象类就是一个约束，不能被new，只能靠子类去实现

​ 3.抽象类虽然不能被new,但是存在构造器，在子类中可以通过super()调用抽象类的构造器

​ 4.存在的意义：提高开发效率，谁用谁实现

​ 5.Java的类是单继承的

接口

1. 是一个约束！！！

2. 接口：使用interface关键字修饰

3. 其他的类要调用接口时，需要使用implements关键字，可以继承多个接口

4. 调用接口的类，必须改写接口中的方法

5. 在接口中定义的方法,关键字都是public abstract

6. 在接口中定义的变量，关键字是public static final,但是一般不会在接口中定义变量

7. 接口不能直接被实例化，里面没有构造方法

   public interface TimeService {  //接口1
       void insert();
       void run();
       void go();
   }
   public interface UserService {   //接口2
       void insert();
       void delete();
       void update();
       void select();
   }
   
   public class test implements UserService,TimeService{  //test类调用了两个接口
       @Override
       public void run() {
   		System.out.println("run");
       }
   
       @Override
       public void go() {
   		System.out.println("go");
       }
   
       @Override
       public void insert() {
   		...
       }
   
       @Override
       public void delete() {
   		...
       }
   
       @Override
       public void update() {
   		...
       }
   
       @Override
       public void select() {
   		...
       }
   }
   

   内部类

   1. 成员内部类

      在一个类内部再定义一个类

      public class Outer{
          private int age=10;
          public void go(){
              System.out.println("这是内部类");
          }
          class Inner{
              public void run(){
                  System.out.println("这是内部类");
              }
              public void getAge(){   //获取外部类的私有属性
                  System.out.println(age);
              }
          }
      }
      
      
      public class test {
          public static void main(String[] agrs){
              Outer a=new Outer();
              Outer.Inner b= a.new Inner();
              a.go();
              b.run();
              b.getAge();
          }
      }
      

      注意：要通过外部类来实例化内部类，内部类可以调用外部类的私有属性

   2. 静态内部类

      将成员内部类用static修饰，只能获取外部类的静态属性

      因为static修饰之后，在创建类的时候同时创建了这个类，而此时外部类的非静态属性还没有被定义

   3. 局部内部类

      在一个方法里面写一个类，不可以使用public或者private访问修饰符进行声明

      局部内部类作用域被限定在声明这个局部类的块中，可适用范围很小，一般不使用

      public class test {
          public static void main(String[] agrs){
             //In就是一个局部内部来
              class In{
                  int id=100;
              }
              
              In c=new In();
              System.out.println("id为"+c.id);
          }
      
      }
      
      

   4. 匿名内部类

      在实例化这个类的时候，不将实例保存到变量中

      public class NoName {
          public void take(){
              System.out.println("获取到了匿名内部类");
          }
      }
      public class test {
          public static void main(String[] agrs){
              //没有变量保存，直接调用相关方法
              new NoName().take();
          }
      
      }