1. 访问修饰符的关键字

public （公有的）：可跨包
protected (受保护的)：当前包内可用
private (私有的)：当前类可用

2. 定义类、接口、抽象类和实现接口、继承类的关键字、实例化对象
class：声明一个类，public class A(){}花括号里是已实现的方法体，类名需要与文件名相同
interface (接口)：public interface B(){}花括号里有方法体，但没有实现，方法体句子后面是英文分号;结尾
- 接口中的所有成员变量都默认是由public static final修饰的。
- 接口中的所有方法都默认是由public abstract修饰的。
- 接口没有构造方法。构造方法用于创建对象
- 实现接口的类中必须提供接口中所有方法的具体实现内容。
- 多个无关的类可以实现同一个接口
- 一个类可以实现多个无关的接口
- 与继承关系类似，接口与实现类之间存在多态性
- 接口也可以继承另一个接口，使用extends关键字。
abstract (声明抽象)：public abstract class C(){}介于类与接口中间，可以有，也可以没有已经实现的方法体
- abstract修饰类，会使这个类成为一个抽象类，这个类将不能生成对象实例，但可以做为对象变量声明的类型，也就是编译时类型，抽象类需要子类继承并覆盖其中的抽象方法。
- abstract修饰方法，会使这个方法变成抽象方法，也就是只有声明（定义）而没有实现，实现部分以”；”代替。需要子类继承实现（覆盖）
- 有抽象方法的类一定是抽象类。但是抽象类中不一定都是抽象方法，也可以全是具体方法。
  interface与abstract：
  - 如果一个类中，既有抽象方法，又有非抽象方法，那么该类只能定义为抽象类，不能定义为接口
  - 如果一个类中，只有抽象方法，没有非抽象方法，那么该类可以定义为接口一般就定义为接口，接口是一种特殊的抽象类，接口中除了定义方法外，还可以定义成员变量。
  - 接口可以被多重实现（implements）,抽象类只能被单一继承（extends）
  - 接口的字段定义默认为:public static final, 抽象类字段默认是”friendly”(本包可见)
implemenst (实现)：用于类或接口，实现接口public class A interface B(){}
extends (继承)：用于类继承类public class A extends D(){}
new (创建新对象)：A a=new A();A表示一个类

3. 包的关键字
import (引入包的关键字)：

当使用某个包的一些类时，仅需要类名，然后使用ctrl+shift+o或者选定类名（类或属性或方法）按住ctrl+单击，即可自动插入类所在的包

package (定义包的关键字)：

将所有相关的类放在一个包类以便查找修改等

4. 数据类型关键字

byte (字节型)：8bit
char (字节型)：16bit
boolean (布尔型)：单独只用4个字节，数组中是1个字节
short (短整型)：16bit
int (整型)：32bit
float (浮点型)：32bit
long (长整型)：64bit
double (双精度)：64bit
void (无返回)：public void A(){}其他需要反回的经常与return连用
null (空值)
true (真)
false (假）

5. 条件循环
if (如果) ：if（条件语句）｛执行代码｝如果条件语句成立，就开始执行｛｝里面的内容
else (否则，或者) ：常与if连用，用法相同：if(…){…}else{…}
while (当什么时候)：while（条件语句）｛执行代码｝
for（满足三个条件时）：for(初始化循环变量；判断条件；循环变量值｛｝
switch (选择结构)：switch(表达式）｛case 常量表达式1：语句1；…case 常量表达式2；语句2；default:语句；｝default就是如果没有匹配的case就执行它，default并不是必须的。case后的语句可以不用大括号。
case (匹配switch的表达式里的结果) ：同上
default (默认)： default就是如果没有匹配的case就执行它， default并不是必须的
do (运行) ：通长与while连用
break (跳出循环)：直接跳出循环，执行循环体后的代码
continue (继续) ：中断本次循环，并开始下一轮循环
return (返回) ：return 一个返回值类型
instanceof(实例)：instanceof 严格来说是Java中的一个双目运算符，用来测试一个对象是否为一个类的实例，用法为：
```
boolean result = obj instanceof Class;
```
- obj 必须为引用类型，不能是基本类型
```
int i = 0;
System.out.println(i instanceof Integer);//编译不通过
```
- obj为null，返回false
  
  6. 修饰方法、类、属性和变量
static(静态的)：属性和方法都可以用static修饰，直接使用类名、属性和方法名。只有内部类可以使用static关键字修饰，调用直接使用类名、内部类类名进行调用。static可以独立存在。
- static修饰类
  - 禁止在静态成员方法中访问非静态成员方法,因为此时连对象都没有，非静态成员就不存在。
  - 对于非静态成员方法，它访问静态成员方法/变量显然是毫无限制的
- static修饰变量
  - static变量也称作静态变量，静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。
  - static是不允许用来修饰局部变量
  - static成员变量的初始化顺序按照定义的顺序进行初始化。
```
public class multiprocess {
private static final String str1 = "str1";
private final String str2 = "str2";
public void main(String[] args) {
this.print1();
print2();
}
public void print1(){
System.out.println(str1);
System.out.println(str2);
}
public static void print2(){
System.out.println(str1);
System.out.println(str2);// 无法从静态上下文中引用非静态 变量 str2
}
}
```
- static修饰代码块
  - static关键字还有一个比较关键的作用就是用来形成静态代码块以优化程序性能。static块可以置于类中的任何地方，类中可以有多个static块。在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次。很多时候会将一些只需要进行一次的初始化操作都放在static代码块中进行。 ```java class Person{ private Date birthDate;
    public Person(Date birthDate) { this.birthDate = birthDate; } boolean isBornBoomer() { Date startDate = Date.valueOf(“1946”); Date endDate = Date.valueOf(“1964”); return birthDate.compareTo(startDate)>=0 && birthDate.compareTo(endDate) < 0; } } // isBornBoomer是用来这个人是否是1946-1964年出生的，而每次isBornBoomer被调用的时候，都会生成startDate和birthDate两个对象，造成了空间浪费，如果改成这样效率会更好：

class Person{ private Date birthDate; private static Date startDate,endDate; static{ startDate = Date.valueOf(“1946”); endDate = Date.valueOf(“1964”); } public Person(Date birthDate) { this.birthDate = birthDate; } boolean isBornBoomer() { return birthDate.compareTo(startDate)>=0 && birthDate.compareTo(endDate) < 0; } }

<br />
- **final**(最终的不可被改变)：方法和类都可用final来修饰；final修饰的类是不能被继承的；final修饰的方法是不能被子类重写。常量的定义：final修饰的属性就是常量
   - 如果引用为基本数据类型，则该引用为常量，该值无法修改；
   -  如果引用为引用数据类型，比如对象、数组，则该对象、数组本身可以修改，但指向该对象或数组的地址的引用不能修改。
   -  如果引用时类的成员变量，则必须当场赋值，否则编译会报错。
   - 当使用final修饰方法时，这个方法将成为最终方法，无法被子类重写。但是，该方法仍然可以被继承(意思就是在派生类中仍可使用，但是不可写)。 
- **super**(调用父类的方法)：常见public void paint(Graphics g){super.paint(g);...}
- **this**(当前类的对象)：this 关键字用来表示当前对象本身，或当前类的一个实例，通过 this 可以调用本对象的所有方法和属性
   - this可以作为方法名来调用本类的其他构造方法，他必须最为构造方法的第一句：
```java
public class Demo{
    public String name;
    public int age;
    public Demo(){
        this("小明", 3);
    }
    public Demo(String name, int age){
        this.name = name;
        this.age = age;
    }
    public void say(){
        System.out.println("他的名字是" + name + "，他已经" + age + "岁了");
    }
    public static void main(String[] args) {
        Demo obj = new Demo();
        obj.say();
    }
}

native(本地)：
- 意思就是被这个关键字修饰的方法是一个原生函数，是由C++实现的，并且已经被编译为DLL，不需要管实现，只调用就ok。
- native是用作Java和其他语言（如C++）进行协作时用的，也就是native后的函数的实现不是用Java实现的
strictfp(严格，精准)：即strict float point
synchronized(线程，同步)：一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块
transient(短暂)
volatile(易失)

Java 基础

Java中的关键字

1. 访问修饰符的关键字

2. 定义类、接口、抽象类和实现接口、继承类的关键字、实例化对象

3. 包的关键字

4. 数据类型关键字

5. 条件循环

6. 修饰方法、类、属性和变量