一、 static关键字

1、静态变量

private static String str1=“staticProperty”

2、静态方法

public static void print2(){
  逻辑;
}

3、 静态代码块

这种一般用来给某个变量初始化

static{
   static int a=1;
}

4、例子

package com.itheima.springboottest;

public class Astatic {
    static {
        int a=3;
    }
    private static String newa="zhangsan";
    public static void myPrint(){
        System.out.println("hhhhh");
    }
}

class Test1{
    public static void main(String[] args){
        Astatic.myPrint();
    }
}

二、final关键字

1、final修饰类

final修饰的类，不能被继承

2、 final修饰方法

不被重写，但是子类可以用父类中final修饰的方法

3、修饰变量

（1） 基本类型变量使用final修饰了就不可以变了
（2） 对于引用类型变量【接口、类、数组、string】被final修饰了，引用类型变量引用不可变，但是引用对象的内容可以变

public class Test3{
 public static void main(String[] args){
      A a = new A();
      a.a=1;
      a.b=2;
    }
}

final class A(
   public int a=3;
)

package com.itheima.springboottest;

final class A{

    public int  a = 3;
    public int  b = 3;

    public int getA() {
        return a;
    }

    public void setA(int a) {
        this.a = a;
    }

    public int getB() {
        return b;
    }

    public void setB(int b) {
        this.b = b;
    }

    public void myPrint(){
        System.out.println(a);
    }
}



class Test3{
    public static void main(String[] args){
        A a = new A();
        a.a=1;
        a.b=2;
        a.myPrint();

    }
}

三、抽象类

1、 抽象类

public abstract class Action{
    public abstract void doSomething();//抽象方法
    public void test(){
    }
}

父类的抽象方法需要通过子类进行重写，抽象方法不能有大括号

package com.itheima.springboottest;

import java.awt.print.Printable;

public abstract  class AbstractTest {
    public String username;
    int a = 3;
    public static  int  age = 39;
    public  void  myPrint(){
        System.out.println("nihao");
    }
    public  abstract  void  myPrint2();//抽象类型方法不能有大括号{}
}
class Son2 extends AbstractTest{
    @Override
    public  void  myPrint2(){
        System.out.println("子类中重写父类的抽象方法");
    }
}
class TestAbstract {
    public static void main(String[] args){
        Son2 son = new Son2();
        son.myPrint2();
    }
}

四、接口

1、接口实际上就是class替换为interface
2、接口中的所有定义的方法中其实都是抽象的 public abstract
3、 变量只能是public static final 类型的
4、public abstract void add(); 等效于 void add();
public static final int n = 3；等效于 int n =3

package com.itheima.springboottest;

public interface UserDao {
    int a = 3;// public static final int a =3;
    void  myPrint();//public abstract   void  myPrint();
    int insert(Person a);//public abstract int insert(A a);
}

package com.itheima.springboottest;

public class UserTest implements UserDao{
    public void myPrint(){
        System.out.println("你好，ok");
    }
    public int insert(Person a){
        System.out.println("ni");
        return 1;
    }
}

class TestUserdao{
    public static void main(String[] args){
        Person person = new Person();
        UserTest user = new UserTest();
        user.myPrint();
        int a = user.insert(person);
        System.out.println(a);
    }
}

接口全部为方法的声明，抽象类里全为方法的实现

还差多态、java中的异常、java中常用类库、集合