Java基础----常量、变量、运算符、语言结构、包、类、Java虚拟机加载类的步骤总结----含思维导图

一、变量

1、成员（全局）变量

   定义在类中方法外的变量统称为成员（全局、实例）变量 ，作用范围在整个类中

2、局部变量

  (1)、定义在方法中的变量定义为局部变量；只有本方法中可以使用。
  (2)、方法的参数就是局部变量

3、成员变量与局部变量区别

  (1)、优先级
    局部变量的优先级大于全局变量
  (2)、作用域
    ①成员变量：整个类中。
    ②局部变量：定义该变量的方法中。
  (3)、默认值
    ①成员变量：如果没有赋值，jvm会给其赋予默认值。
    ②局部变量：没有默认值，如果要使用，必须手动赋值；方法的参数就是局部变量，参数在调用的时候，必然会被赋值。
  (4)、内存中位置
    ①成员变量：位于堆内存。
    ②局部变量：位于栈内存。
  (5)、生命周期。
    ①成员变量：随着对象的创建而诞生，随着对象被垃圾回收而消失。
    ②局部变量：随着方法进栈而诞生，随着方法出栈而消失。

4、数字字面量

  用_分割数值，不影响实际值。例：int a = 12_000_000; System.out.println(a);输出结果为：12000000；

5、注意事项

  (1)、在用一个方法中，不允许有图中的嵌套定义，在类中定义的全局变量，还可以在本类方法中定义同名的局部变量。
  (2)、如果创建多个变量，那么变量之间的名称不可以重复
  (3)、没有进行赋值的变量，不能直接使用；一定要赋值之后，才能使用。
  (4)、变量使用不能超过作用域的范围
  (5)、可以通过一个人语句来创建多个变量，但是一般不推荐这么写：int a,b,c;a=b=c=1;还可以这样写：int a=1,b=2,c=3;但是不能写成下面这样：int a=b=c=1。

二、 常量

  (1)、一旦定义，值不能修改的变量； final 类型 常量名=“常量值”。
  (2)、字符串常量：凡是用双引号引起来的部分，叫做字符串常量。例如：“abc”、“Hello”、“123”；两个双引号之间的内容可以为空。
  (3)、整数常量：直接写上的数字，没有小数点。例如：100、200、0、-250。
  (4)、浮点数常量：直接写上的数字，有小数点。例如：2.5、-3.14、0.0。
  (5)、字符常量：凡是用单引号引起来的单个字符，就是字符常量。例如：‘A’、‘b’、‘9’；两个单引号之间必须有且只有一个字符，且不能为空。
  (6)、布尔常量：只有两种取值。true、false。
  (7)、空常量：null。代表没有任何数据。
注意： 空常量不能直接用来打印输出。例如：System.out.println(null);运行后会报错。

三、 Java运算符

1、算术运算符

   （1）正号+、负号-、加+、减-、乘*、除/、取模%、++、––
   （2）++a：a先自加1，然后再运算。   a ++：先运算，然后a再自加1。
   （3）––a：a先自减1，然后再运算。    a––：先运算，然后a再自减1。

2、赋值运算符

   （1）赋值=、加等于+=、减等于-=、乘等于*=、除等/=、模等于%=
   （2）Java 中可以把赋值语句连在一起，如：int x,y,z;x=y=z=5;

3、比较运算符

   （1）相等==、不等于！=、小于<、大于>、小于等于<=、大于等于>=
   （2）比较运算符的结果都是boolean型，也就是要么是true，要么是false
   （3）“==”比较运算符,如果比较的是引用数据类型，只是比较它们的内存地址是否相等。如果比较的是基本数据类型，只是比较他们的值是否相等
   （4）“equals()”如果比较的是基本数据类型，只是比较它们的值是否相等

4、逻辑运算符

   （1）逻辑运算符用于对boolean型结果的表达式进行运算，运算的结果都是boolean型。
   （2）&（与）AND：表达式两边同为true结果才为true。
   （3）|（或）OR：表达式两边同为flase结果才为flase。
   （4）^（异或）XOR：表达式两侧不同为true，相同为flase；一个数异或同一个数两次还是它本身。
   （5）！（非）NOT：非true即flase，非flase即true。
   （6）&&（短路与）AND：先判断运算符左边的表达式是否成立，如果不成立则直接返回false，如果成立再判断第二个表达式。
   （7）||（短路或）OR：先判断运算符左边的表达式是否成立，如果成立则直接返回true，如果不成立再判断第二个表达式。
   （8）&&（短路与）比&（与）的效率比较高，||（短路或）比|（或）的效率比较高。

5、移位运算符

   （1）浮点类型不能进行移位运算；对于正数而言，>>和>>>效果等同。
   （2）<< 左移：将数字转为对应二进制之后全部往左移动n位，一个整数左移n位等于这个数乘以2的n次方，一个int类型的整数，如何左移n位，左移的有效位数位n%32得到的余数。
   （3）>> 右移：将数字转为对应的二进制后全部往右移动n位；一个数右移n位等于这个数除以2的n次方；一个整数右移n位，有效的右移数位n%32得的余数，最高位是0补0，是1 补1。
   （4）>>> 无符号右移：将数字转为对应的二进制后全部按顺序进行右移n位，最高不论1和0，统一补0。
   （5）移位运算符适用类型有byte、short、char、int、long.对低于int型的操作数将先自动转换为int型再移位。

6、三元运算符

   （1）expression ? result1 : result2
      解析：首先计算表达式expression，它的结果是一个布尔值，如果该值为true，则返回表达式result1的值，否则返回表达式result2的值。
      注意：result1和result2返回的数据类型必相同。

7、运算符的优先级

   （1）一元、二元、三元
   （2）括号、++、–、（非）！算术运算符、移位运算符、比较运算符、逻辑运算符、三元运算符、赋值运算符

四、Java的两种语句

1、结构定义语句（不带 分号 ; 的语句）

2、功能执行语句（最后必须用分号 ;结束）

五、Java程序的三种注释

1、// 单行注释 Ctrl + Shift + C

2、/* */ 多行注释Ctrl + shift + /

3、/** */ 文本注释Alt + Shift + J

六、Java的三大结构

1、顺序结构

2、选择结构

   （1）单分支选择结构、双分支选择结构、多分支选择结构
   （2）if语句：执行的语句如果超过一条，必须使用{}
   （3）switch语句（多分支）：switch的变量必须是整数；判断条件可接受 byte,short，int,char,String型；float、double、long型不可以
   （4）case标签是唯一的，不允许两个case具有相同的值。
   （5）default语句是可选的，default语句的位置不限，谁也不要的都归它。
   （6）break语句：一个无标号的break语句会退出当前(最内)循环(while、do…while、for)，执行循环结构后面的代码。
   （7）当循环有嵌套时，使用一个有标号的break语句可以退出内层的循环。

3、循环结构

   （1）循环结构描述重复执行某段代码，循环结构可以减少源程序重复书写的工作量。
   （2）循环结构有三个要素：循环变量、循环体和循环终止条件
   （3）while语句do…while语句
   （4）一个无标号的continue语句会跳过当前循环的剩余语句块，立刻执行下次循环。当循环有嵌套时，使用一个有标号的continue语句可以继续执行外层的循环。

4、break语句与continue语句的区别

   （1）break语句：是用于永久终止循环。即不执行本次循环中break后面的语句,直接跳出循环。
   （2）continue语句：是用于终止本次循环。即本次循环中continue后面的代码不执行,进行下一次循环的入口判断。

七、Java包

1、包命名规范

   全小写，有多个单词中间用.隔开，最好以所在公司或单位的网站倒叙来写：例如：com.baidu.demo。

2、Java中包的实质

  (1) Java中的包(Package)其实指的就是目录。Java工程中的文件都是放在各个包中的。
  (2) 使用包可以更好地管理工程中的文件(类、接口、图片等等)。
  (3) 不同包下的文件可以重名，包也可以被另一个Java包所使用。
  (4) package语句是Java源文件的第一条语句。如果没有package语句，则为缺省无名包。(不推荐使用)例如：直接在src下面新建一个类：class。
  (5) 如果文件不是放在默认包下，需要在最前面用package关键字声明该类所属的包。例：package sample.test;
  (6) 如果要引用其他包中的类，则需要通过import关键字对所引用的类进行引入。
  (7) * ：代表通配符，表示该报下的所有类（不推荐）例如：import com.hisoft.java.*;
注意： 一个java文件中可以申明多个类：class,但是只有和类文件名一致的类才能用public进行修饰。但是不建议一个文件中声明多个类:class。

3、Java中常用的包

  3.1、常用包
    （1）java.lang——包含一些Java语言的核心类，如String、Math、Integer、System和Thread，提供常用功能。
    （2）java.util——包含一些实用工具类，如定义系统特性、使用与日期日历相关的方法。
    （3）java.io——包含能提供多种输入/输出功能的类。
    （4）java.sql——提供使用Java编程语言访问并处理存储在数据库中的数据的API。
  3.2、非常用包
    （1）java.net——包含执行与网络相关的操作的类。
    （2）java.awt——包含用于创建用户界面和绘制图形图像的所有类。这些类被用来构建和管理应用程序的图形用户界面(GUI)。
    （3）javax.swing——提供一组“轻量级”(全部是Java语言)组件。这些swing组件是对AWT组件的改进。
注意： 1：在同一类中不能导入不同包下面的与此类是相同类名的类；
    2：同一包中，不同class.java文件中的类名称不可以相同，因为类的全名是：包.类名。

八、Java类

1、类声明语法

   [类修饰符] class 类名
      [extends 超类名]
      [implements 接口名] {
　　　　　成员变量定义；
   方法定义；
   }

2、类的生命周期

  

3、静态成员（类变量）

  （1）用static修饰的全局变量或者方法、代码块。
  （2）在main方法中可以通过 类名.静态成员进行赋值访问。

4、实例变量（实例成员变量）

  （1）没有用static修饰的全局变量被称为实例变量。包括：实例变量；实例代码段；实例方法。值访问。
  （2） 只能通过实例对象进行调用。

5、代码段

  （1）静态代码段：用static修饰 { } 的代码段。
  （2）实例代码块：在方法外用{}括起来的代码。

6、Java虚拟机加载类的步骤

  (1) 加载：找到相应的class字节码文件，由类加载器将类的信息读入到Java虚拟机中。如果找不到该类，则会抛出ClassNotFoundExcetpion异常。
  (2) 验证：确认读取文件类型的正确性，即class是否符合Java规范并且不会损害Java虚拟机的完整性。
  (3) 准备：为静态成员变量分配内存同时设置默认初始值。
  (4) 解析：把符号引用转为直接引用的过程。例如将变量名转为内存地址。以后使用这个成员变量时，就直接去这个内存地址去找了。同时类的成员方法也会被映射到某个内存地址以待调用。
  (5) 类的初始化：此阶段会为静态成员变量赋予正确的初始值，并且调用类中所有的静态代码块。 注意：初始化阶段只会进行一次。
  (6) 对象实例化：
    ① 为实例变量分配内存。
    ② 调用类中的所有实例代码块。
    ③ 调用相应的构造方法。
  (7) 垃圾收集：
    ① 对象实例化后就会在堆内存中为对象分配空间，当对象不再使用的时候，Java就会通过垃圾回收机制将对象销毁回收内存
    ② 垃圾回收线程平时是处于睡眠状态的，当内存不够分配时该线程就会被唤醒，按照特定的垃圾收集算法找出内存中的垃圾并回收。
    ③ Java把内存分为：新生代、老年代、持久代。新生代和老年代又被称为堆内存。垃圾回收主要就是针对堆内存进行的。
    ④ 垃圾回收有2种方式：minor gc(快速GC)和full gc(全局GC)。快速GC是在新生代中进行垃圾回收。
    ⑤ 当经过垃圾回收之后还是不能给对象分配内存空间，则会抛出OutOfMemoryError。
    ⑥ 通过system.gc呼叫GC。
  (8) 对象终结：此对象从内存彻底消失。
注意： Java在需要使用类的时候，才会将类加载。如果只是定义一个变量为XXX类型，则不会加载类。

三、类的实例化

  1、在堆中为实例变量分配内存空间并且赋值。
  2、调用类中所有的实例代码块：{……}。
  3、调用相应的构造方法。
  4、具体实现：
   （1）编译阶段Java编译器会把类中所有的实例变量初始化代码和实例代码块封装到一个方法中去，此时JVM会调用这个方法。
   （2）方法程序员不能调用，只能被JVM调用。
   （3）方法在每次实例化时都会被执行。实例代码块按源文件顺序执行，最后才执行构造方法。

  5、实质：类名 对象名 = new 类名（）；实质是：类名 对象名 = new 构造方法（）；也就是说，实例化对象时实质就是new 构造方法（）；

四、类的初始化和实例化的三种方式

  1、加载，初始化，实例化一起进行：例：new 类名(); Animal ani = new Animal();
  2、反射：使用Class类的forName方法，Class.forName(“包名+类名”)；//这一句完成：加载+初始化操作 Class对象.newInstance()//这句完成实例化操作。
  3、通过类加载器加载类（使用ClassLoader类的loadClass方法），然同通过class对象.newInstance()方法完成对象实例化操Class c=ClassLoader.getSystemClassLoader().loadClass(“包名+类名”); // 加载 c.newInstance();// 初始化 —> 实例化
注意： 实例方法只能通过对象.方法的形式进行调用。

五、类的初始化和实例化的区别

  1、在初始化操作完成之后才进行实例化操作。
  2、初始化是为静态成员变量赋初值，是在方法区(持久代)中分配空间。实例化是为实例变量赋初值，是在堆内存中分配空间。
  3、初始化完成之后只能使用该类的静态成员(变量和方法)，实例化完成之后即可以使用该类的静态成员，也可以使用该类的实例成员。
注意： 静态方法只能访问静态成员，不能调用实例成员(原因 : 静态的内容是随着类的加载而加载的,它是先进内存，初始化先于实例化进行。

六、 一个标准的类

  1、所有的成员变量都要使用private关键字修饰。
  2、为每一个成员变量编写一对Getter/Setter方法。
  3、编写一个无参的构造方法。
  4、编写一个全参的构造方法。
  5、重写toString()方法。
拓展： 一个标准的类也叫做Java Bean。

标准的student类：

package test;

class Student {
	//私有化名字
	private String name;
	//私有化年龄
	private int age;
	public void setName(String name) {
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public int getAge() {
		return age;
	}
	//无参构造方法
    public Student() {
    	
    }
    //全参构造方法
	public Student(String name, int age) {
		this.name = name;
		this.age = age;
	}
    //重写toString()方法
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
}

九、 思维导图