[

](Java%E5%AD%A6%E4%B9%A0%EF%BC%88%E4%B8%80%EF%BC%89)

已经有C的基础，所以不会特别基础。主要是和C不同的地方。
学习的视频是【零基础 快速学Java】韩顺平 零基础30天学会Java
https://www.bilibili.com/video/BV1fh411y7R8?p=180

环境的不同

Java8：编译时需要先javac text.java,生成一个text.class,然后java text，执行程序。可以分别执行各个类。
java11: 编译时直接 java text,java,会直接生成text,class并运行程序。似乎不可以分别执行各个类，只能执行主类。

+的特性

+左右是数值则数值相加，有一边是字符串则拼接运算

  1. System.out.println(100 + 8); //108
  2. System.out.println("100" + 8); //1008
  3. System.out.println("hello"+100 + 8); //hello1008

浮点数的细节

java浮点数默认是double,用float声明要在浮点数后加后缀f（不加会报错），所以一般使用double。
不要用运算结果是小数的进行相等判断，最好用相减的绝对值小于某个精度来处理。

字符编码

java的字符类型是unicode码
ASCII码，一个字节表示，一共128个字符。
Unicode：固定大小编码， 两个字节表示一个字符。
Utf-8：大小可变的编码，字母使用一个字节，汉字使用3个字节。
gbk:字母一个字节，汉字两个字节。
big5：繁体字

类型转换

byte,short,char三者进行运算，会自动转换晨int类型。

  1.         char c =1;
  2.         char d = 2;
  3.         byte e =1;
  4.         short f = 1;
  5.         short s1 = f + e; //错误: 不兼容的类型: 从int转换到short可能会有损失
  7.         char  c1 = c + d ; //错误: 不兼容的类型: 从int转换到char可能会有损失

字符串转基本类型，用库方法。

运算符

除法细节

  1.         System.out.println(10 / 4);     //2
  2.         System.out.println(10.0 / 4);    //2.5
  3.         double d = 10 / 4;
  4.         System.out.println(d);             //2.0

switch

  • 细节1：switch表达式的类型应一致或可以转换。
  • 细节2：switch表达式的值必须为 byte,short, int, char, enum, String.
  • 细节3：case表达式必须为常量或产量表达式，不能为变量。
  • 细节4： 如果没遇到break,会顺序执行，不需要判断下面的case。只判断一次switch.

数组

数组的拷贝不能直接将数组的名赋值，拷贝要将值一一赋值。

  1.         int[] arr1 = {1, 2, 3};
  2.         int[] arr2 = arr1;   //将arr1的地址赋给了arr2,arr1和arr2指向同一个地址，修改arr2的值arr1的值也会改变。
  3.         arr2[0] = 10;
  4.         for(int i = 0;i < arr1.length; i++)
  5.             System.out.println(arr1[i]);   //10,2,3

二维数组可以先初始化最高位，再初始化后面的，并且可以不同大小。
一个例子，杨辉三角。这个二维数组的每个一维数组长度都不同。

  1. public class YangHui{
  2.     public static void main(String[] args){
  3.         int n =10;
  5.         int [][] yanghui = new int[n][];
  6.         for(int i = 0; i < yanghui.length; i++){
  7.             yanghui[i] = new int [i+1];             //给每一个二维数组初始化
  8.             for(int j = 0; j < yanghui[i].length; j++){
  9.                 if(j == 0 || j ==yanghui[i].length -1)
  10.                     yanghui[i][j] = 1;                 //第一列和最后一列都为1
  11.                 else{
  12.                     yanghui[i][j] = yanghui [i-1][j] + yanghui[i-1][j-1];
  13.                 }
  14.             }
  15.         }
  16.         for(int i = 0; i < yanghui.length; i++){
  17.             for(int j =0; j < yanghui[i].length; j++)
  18.                 System.out.print(yanghui[i][j]+"\t");
  19.             System.out.println();
  20.         }
  22.     }
  23. }

可变参数

  1. java允许将同一类中的多个同名同功能但参数个数不同的方法，封装成一个方法。
  2. 基本语法
    【访问修饰符】 【返回类型】 【方法名】（数据类型… 形参名）{ }
    实参可以为0个或多个。可以是数组。
    可变参数可以和普通类型参数一起放在形参列表，但必须保证可变参数放在最后。
    一个形参列表中只能有一个可变参数。
  3. 案例 
  1. public class VarParameters{
  2.     public static void main(String[] args){
  4.         Method m = new Method();
  5.         System.out.print(m.sum(1,2,3,4));
  7.     }
  8. }
  9. class Method {
  10.     // pubilc int sum( int n1, int n2){
  11.     //     return n1 + n2;
  13.     // }
  14.     // pubilc int sum( int n1, int n2, int n3){
  15.     //     return n1 + n2 + n3;
  17.     // }
  18.     // pubilc int sum( int n1, int n2, int n3, int n4){
  19.     //     return n1 + n2 +n3 + n4;
  21.     // }
  23.     public int sum(int... nums){               // nums 当作数组使用
  24.         int res = 0;
  25.         for(int i = 0; i < nums.length; i++){
  26.             res += nums[i];
  27.         }
  28.         return res;
  29.     }
  30. }

this

用this访问构造方法 this(形参列表)。
只能在构造方法中使用this(形参列表)，且==this(形参列表)==必须在第一行。