Java基础1

Java编程基础

1. Java程序的编译流程。

   我们编写的源文件.java，通过 javac.exe 编译成 字节码文件.class，JVM 只识别字节码文件，不识别源文件。然后通过 java.exe 将 .class 文件装载到JVM中 ,通过JVM执行字节码文件。

2. 成员变量、实例变量、静态变量、常量、属性、字段、局部变量

   1. 成员变量：一般定义在类的申明下，作用于整个类，定义在方法和代码块之外，也称之为全局变量。包含：

      实例变量：不用static修饰的变量。

      静态变量：用static修饰的变量。又称类变量。

      常量：用static final 修改的变量。

   2. 局部变量：定义在方法和代码块中的变量。

   3. 属性：其实就是getter和setter方法，截去其中的get和set。

   4. 字段：和成员变量概念相同。

   public class person {
           private String name;
           private String gender;
           public int age;
           public static final String mood="开心";
           public static String height="很高";
           
           public void eat() {
               String eat="delicious";
           }
           public String getName() {
               return name;
           }
   
           public void setName(String name) {
               this.name = name;
           }
           public int getAge() {
               return age;
           }
           public void setAge(int age) {
               this.age = age;
           }
           public static String getHeight() {
               return height;
           }
           public static void setHeight(String height) {
               person.height = height;
           }
       }
   // 该Person类中有：5个字段、5个成员变量、1个局部变量、3个实例变量、1个静态变量(类变量)和1个常量、3个可读写属性
   

3. 数据类型

   Java数据类型，每种数据都有具体的数据类型，每种数据类型在内存中都有大小不同的内存空间（字节）。

   基本数据类型

   数值型

   整型（byte[1] -2^7 ~ 2^7 - 1、short[2]、int[4]、long[8]）

   浮点型（float[4] 单精度、double[8] 双精度）

   字符型(char[2]，存放“a”)

   布尔型(boolean[1]，存放 true、false)

   // 1、数值型
       // 1.1、整型 （byte[1] （-2^7 ~ 2^7 - 1） short[2](-2^15 ~ 2^15 - 1) int[4](-2^31 ~ 2^31 - 1) long[8]）(-2^65 ~ 2^65 - 1)
       // 1.2、浮点型(float[4] double[8])
       public static void testNumber(){
           byte a = 127;
           int b = 127; // 默认为int
           long c = 123L; // long 必须在数值后加L
           short d = 12;
           float e = 12.1F; // 浮点型必须在数值后加F
           float g = 5.21e2F; // 5.12 * 10^2
           float h = 5.21E-2F;
           double f = 12.2; // 浮点型默认值为double
           System.out.println(e);
           System.out.println(f);
           System.out.println(g);
           System.out.println(h);
   
           float num1 = 1234567.123F;
           double num2 = 1234567.123;
           System.out.println(num1);
           System.out.println(num2);// 通过对比double的精度要高一点，如果浮点型的长度大小未知，默认使用double类型。
   
           double num3 = 2.7;
           double num4 = 8.1 / 3.0;
           System.out.println(num3); // 2.7
           System.out.println(num4);  // 2.6999999999999997
           System.out.println(String.format("%.2f",num4)); // 2.70
   
       }
       // 2、字符型
       public static void testChar(){
           char c1 = 'a'; // 字符只能用单引号，双引号表示字符串。
           char c2 = '\t'; // 转移字符
           char c3 = '韩';
           char c4 = 97; //char 可以存储数字，对应的unicode码。ASCII编码表。
           System.out.println(c1);
           System.out.println(c2);
           System.out.println(c3);
           System.out.println((int)c3);
           System.out.println(c4);
           System.out.println((int)c1); // 97
           char c5 = 'a' + 10;
           System.out.println(c5); // k
           System.out.println((int)c5); // 107
           // 字符型的存储过程。
           //'a' 通过 ASCII 编码表 得出用 97 表示，97再转成二进制后，将二进制码存储到内存中。
           // 常用的字符编码表
           // ASCII编码 （用一个字节表示，一共有128个字符。其实一个字节，对表可表示256个字符，但是美国只用了128个就表示完了）
           // Unicode编码 （用两个字节表示，字母和汉子都是两个字节）
           // UTF-8编码 （字母用一个字节表示，汉子用三个字节表示）
           // gbk编码 （字母用一个字节表示，汉子用两个字节表示）
       }
       // 基本数据类型自动转化，从精度小的类型向精度大的类型转化。
       // char > int > long > float > double
       // byte > short > int > long > float > double
       public static void autoCover(){
           int i = 97;
   //        char c = 'a';
   //        int i = c;
   //        char c = i; // 报错
           System.out.println(i);
           // char 和 byte 、 short 之间不自动转化
           char c = 'a';
   //        short s = c; // 报错
       }
   

   引用数据类型

   类（class）

   接口（interface）

   数组（[]）

4. 原码、反码、补码。

   1. 二进制的最高位为符号位，0表示正数，1表示负数。

   2. 正数的原码、反码、补码都一致。

   3. 负数的反码=它的原码符号位不变，其他位取反。

   4. 负数的补码=它的反码+1，负数的反码=它的补码-1

   5. 0的反码、补码都是0

   6. Java中都是有符号数。

   7. 在计算机运算的时候，都是以补码的方式运算。

   8. 当我们看运算结果时，要看原码。

5. 位运算符（~ 、 ^、 & 、 | 、 >> 、 << 和 >>>）

   1. ～ 按位取反 ： 0 -> 1, 1->0

   2. & 按位与：两位全是1 ，结果为1，否则为0

   3. | 按位或：两位有一位时1，结果为1，否则为0

   4. ^ 按位异或：两位中，一位为1，另一位为0，结果为1，否则为0

   5. 算数右移 >> ：低位溢出，符号位不变，并用符号位补充缺失的高位。

   6. 算数左移 << ：符号位不变，并用0补充缺失的低位。

   7. 无符号右移 >>> : 低位溢出，高位补0，没有符号位。