JAVA入门学习一

JDK -- 开发工具- https://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html
IDE:Eclispe/VScode -- 开发编辑器 http://www.eclipse.org/downloads/packages/
Java SE Development Kit 8u211


#JDK目录文件说明
PS C:Program Files (x86)Javajdk1.8.0_211> tree 
+---bin  #存储可执行程序（java编译器/java运行工具/jar打包工具/javadoc.exe嗡的生产工具）
+---include #由于JDK是通过C和C++实现的,启动的时候需要引入一些C语言头文件;
+---jre #java运行环境
+---lib #java的library类或库文件是开发工具使用的归档文件
+---src.zip  #放置了JSK核心类的源代码，通过该文件可以查看java基础类的源代码;

#配置环境不多说：
C:UsersAdministrator>ECHO %path%
C:Program Files (x86)Common FilesOracleJavajavapath;

变量名：JAVA_HOME
变量值：C:Program Files (x86)Javajdk1.8.0_211                    // 要根据自己的实际路径配置

变量名：CLASSPATH #在1.5jdk不怎么重要(可以执行生成的.class)，记录java类运行文件
变量值：.;%JAVA_HOME%libdt.jar;%JAVA_HOME%libtools.jar;         //记得前面有个"."

变量名：Path #记录的可执行文件
变量值：%JAVA_HOME%bin;%JAVA_HOME%jrebin;


#linux
# Java SE Development Kit 8u211
$tar -zxvf jdk-8u211-linux-x64.tar.gz -C /usr/local/
$vi /etc/profile 

#Java Env
export JAVA_HOME=/usr/local/jdk1.8.0_211/
export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar;
export PATH=$PATH:$JAVA_HOME/bin

//注：String args[] 与 String[] args 都可以执行，但推荐使用 String[] args，这样可以避免歧义和误读。
//修饰符  类   类名   （注意要一致）
public class HelloWorld {
    //主方法相当于C中的main函数,入口;
    public static void main(String[] args) {
       System.out.println("Hello World");
    }
}

//采用jdk目录中javac/java进行编译然后执行（下面为了防止乱码在编译成为字节码文件的时候采用utf8编码）    
>javac -encoding UTF-8 HelloWorld.java  ## 该命令用于将 java 源文件编译为 class 字节码文件，会出现一个 HelloWorld.class 的文件
>java HelloWorld   # java 后面跟着的是java文件中的类名(注意：java命令后面不要加.class)
Hello World
Hello World

//空白行，或者有注释的行，Java编译器都会忽略掉。
- 单行注释：//注释
- 多行注释：/* 注释 */
- 文档注释：/** 注释 **/

合法标识符举例：age、$salary、_value、__1_value
非法标识符举例：123abc、-salary

- 包package: 就是文件夹用于解决相同类名问,要求全部小写,一般是域名倒起写
  com.java.www

- 类或者接口：驼峰命名
  一个单词：Demo
  多个单词：DemoStudy

- 方法与变量：
  一个单词：demo
  多个单词：demoStudy

- 常量：(通常大写)
  一个单词：MAX
  多个单词：MAX_VALUE

// Constant 常量案例
class Demo_Constant {
    public static void main(String[] args) {
        /***
         * 字符串常量：使用双引号括起来的内容例如 "abc"
         * 整数常量：例如 123
         * 小数常量：例如 12.3
         * 字符常量：例如 'a' 'b' 'c'
         * 布尔常量：例如 true / false
         * 空常量：null (数组部分)
         */
        final int DC = 1314520;  //使用 final 关键字来修饰常量，声明方式和变量类似
        System.out.println("abc");  //字符串常量
        System.out.println(123);   //整形常量
        System.out.println(12.3);  //小数常量
        System.out.println('a');  //字符常量
        System.out.println(' ');  //空格常量
        System.out.print(true);   //布尔常量
    }
}

//######## 执行结果 #######
// abc
// 123
// 12.3
// a
 
// true

//进制转换案例
class Demo_Scale {
    public static void main(String[] args) {
        //进制输出表示形式
        System.out.println(0b100);   //二进制  4
        System.out.println(0100);    //八进制  64
        System.out.println(100);    //十进制  
        System.out.println(0x100);   //十六进制 256

        //byte、int、long、和short都可以用十进制、16进制以及8进制的方式来表示。
        //使用常量的时候，前缀 0 表示 8 进制，而前缀 0x 代表 16 进制
        int decimal = 100;   //一下输出都是100
        int octal = 0144;
        int hexa =  0x64;
        
        //原码/反码/补码
        /* 
        1.已知原码求补码
        * 0b1 011 0100  原码
        * 0b1 100 1011  反码
        * 0b1 100 1100  补码 = 反码 + 1

        2.已知补码求原码
          0b1 110 1110  补码
          0b1 110 1101  反码 = 补码 - 1
          0b1 001 0010  原码  
        */
    }
}

//数据类型与变量 案例
class Demo_DataType {
    public static void main(String[] args) {
/**
byte：类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；
Short ：数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一；
int：一般地整型变量默认为 int 类型；
long：这种类型主要使用在需要比较大整数的系统上
float：在储存大型浮点数组的时候可节省内存空间，浮点数不能用来表示精确的值，如货币；
double：浮点数的默认类型为double类型， double类型同样不能表示精确的值，如货币；
boolean： 这种类型只作为一种标志来记录 true/false 情况；
char： 数据类型可以储存任何字符；
**/
        //整数类型
        byte b = 10;   //1Byte
        short s = 20;  //2Byte
        int  i = 30;   //4Byte
        long x = 40;   //8Byte 有时候还需要加入一个L字符表示long类型
        long x1 = 888888888888L; //在long类型后也可使用l但是不建议使用小写的l  (注意点)

        //浮点数
        float f = 12.36F;  //4Byte 如果是小数要为float类型需要在小数后加F (主要点)
        double d = 33.67;  //8Byte 小数默认的数据类型是Double; 也可以加上d/D 表示()

        //字符类型
        char c = 'a';   //2Byte (注意java字符类型占用两个字节)
        System.out.println(c);

        //布尔类型
        boolean b1 = true;  //没有明确得规定占用几个字节 （注意点）
        boolean b2 = false;
        System.out.println(b1);

        //变量问题 
        //1.使用前必须赋值
        int x2,y,z;
        x2 = 1;
        y = 2;
        z = 3;
        System.out.println(x2); //1

        //Float和Double的最小值和最大值都是以科学记数法的形式输出的，结尾的"E+数字"表示E之前的数字要乘以10的多少次方。
        //比如3.14E3就是3.14 × 103 =3140，3.14E-3 就是 3.14 x 10-3 =0.00314。
    }
}

// 数据类型 长度
class Demo_DataTypeLength {
    public static void main(String[] args) {
        //数据类型的长度
        // byte  
        System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE);  
        System.out.println("包装类：java.lang.Byte");  
        System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE);  
        System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE+"n");
        
        //short
        System.out.println("基本类型：short 二进制位数" + Short.SIZE);
        System.out.println("包装类：java.lang.Short");  
        System.out.println("最小值：Short.MIN_VALUE=" + Short.MIN_VALUE);  
        System.out.println("最大值：Short.MAX_VALUE=" + Short.MAX_VALUE+"n");
        
         //int  
        System.out.println("基本类型：int 二进制位数：" + Integer.SIZE);  
        System.out.println("包装类：java.lang.Integer");  
        System.out.println("最小值：Integer.MIN_VALUE=" + Integer.MIN_VALUE);  
        System.out.println("最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE);  
        System.out.println();  
  
        // long  
        System.out.println("基本类型：long 二进制位数：" + Long.SIZE);  
        System.out.println("包装类：java.lang.Long");  
        System.out.println("最小值：Long.MIN_VALUE=" + Long.MIN_VALUE);  
        System.out.println("最大值：Long.MAX_VALUE=" + Long.MAX_VALUE);  
        System.out.println();  
  
        // float  
        System.out.println("基本类型：float 二进制位数：" + Float.SIZE);  
        System.out.println("包装类：java.lang.Float");  
        System.out.println("最小值：Float.MIN_VALUE=" + Float.MIN_VALUE);  
        System.out.println("最大值：Float.MAX_VALUE=" + Float.MAX_VALUE);  
        System.out.println();  
  
        // double  
        System.out.println("基本类型：double 二进制位数：" + Double.SIZE);  
        System.out.println("包装类：java.lang.Double");  
        System.out.println("最小值：Double.MIN_VALUE=" + Double.MIN_VALUE);  
        System.out.println("最大值：Double.MAX_VALUE=" + Double.MAX_VALUE);  
        System.out.println();  
  
        // char  
        System.out.println("基本类型：char 二进制位数：" + Character.SIZE);  
        System.out.println("包装类：java.lang.Character");  
        // 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台  
        System.out.println("最小值：Character.MIN_VALUE=" + (int) Character.MIN_VALUE);  
        // 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台  
        System.out.println("最大值：Character.MAX_VALUE=" + (int) Character.MAX_VALUE);  
    }
}

//################### 执行结果 ##################
// 基本类型：byte 二进制位数：8
// 包装类：java.lang.Byte
// 最小值：Byte.MIN_VALUE=-128
// 最大值：Byte.MAX_VALUE=127

// 基本类型：short 二进制位数16
// 包装类：java.lang.Short
// 最小值：Short.MIN_VALUE=-32768
// 最大值：Short.MAX_VALUE=32767

// 基本类型：int 二进制位数：32
// 包装类：java.lang.Integer
// 最小值：Integer.MIN_VALUE=-2147483648
// 最大值：Integer.MAX_VALUE=2147483647

// 基本类型：long 二进制位数：64
// 包装类：java.lang.Long
// 最小值：Long.MIN_VALUE=-9223372036854775808
// 最大值：Long.MAX_VALUE=9223372036854775807

// 基本类型：float 二进制位数：32
// 包装类：java.lang.Float
// 最小值：Float.MIN_VALUE=1.4E-45
// 最大值：Float.MAX_VALUE=3.4028235E38

// 基本类型：double 二进制位数：64
// 包装类：java.lang.Double
// 最小值：Double.MIN_VALUE=4.9E-324
// 最大值：Double.MAX_VALUE=1.7976931348623157E308

// 基本类型：char 二进制位数：16
// 包装类：java.lang.Character
// 最小值：Character.MIN_VALUE=0
// 最大值：Character.MAX_VALUE=65535

低  ------------------------------------>  高
byte,short,char—> int —> long—> float —> double    //需要注意 long 与 float之间的转换

Q：什么可以将long强制转换到float？
long 8 个字节 / float 4 个字节

通过IEEE 754 标准：float代表了32个二进制位
1 位表达符号位,8 位表达指数位, 23 位代表尾数位
0000000 - 11111111
0       - 255   //0代表0，而255代表的是无穷大
1       - 254   //除去 0 和 255
-126    - 127   //每个指数减去127 该范围超过了long的范围 (所以float 比 float大)

//结论：flaot表示的数据范围比long的范围要大;
long : 2^63 - 1
float : 3.4*10^38 > 2*10^38 > 2*8^38 = 2*2^3^38 = 2*2^114 > 2^63-1

// 数据类型转换案例
class Demo_DataTypeConversion {
    public static void main(String[] args) {
        //1.隐式转换
        byte b = 3;
        int i = 4;
        i += b; // 这里的b将自动转换成为int类型(注意点)
        System.out.println(i); //7

        //2.强制转换
        byte b1 = 3;
        int i1 = 4;
        b1 = (byte)(i1 + b1);
        System.out.println(b1); //7

        //3.如果值不该该类型得取值范围内（向下强转）将会损失精度
        /***
         * 0000000 00000000 00000000 10000010 = 130二进制
         * 经过byte强制类型转换(去掉前面的3个字节)
         * 10000010  = -126的补码
         * 10000001 = -126的反码
         * 11111110 = -126的原码
         */
        byte b2 = (byte)(126 + 4); 
        System.out.println(b2); //-126

        //4.面试题
        /***
         * 1) byte与byte(或short,char)进行运算的时候会提升为int,两个类型相加的结果也是int类型
         * 2) bt1与bt2是两个变量,变量妞的值是变化的,在编译的时候无法判断里面具体的值,有可能会超出 byte的取值
         **/
        byte bt1 = 3;
        byte bt2 = 4;
        //byte bt3 = bt1 + bt2;  //输入bt3会进行报错
        

        //5.对比面试题
        byte bt4 = 3 + 4; //java编译器有常量的优化机制 (且固定在byte类型范围内)
        System.out.println(bt4);  //7


        //6.long与float转换
        float f1 = 12.34f;
        long l1 = 123456;
        float f2 = l1; //隐型转换 
        long l2 = (long)f1;    //强制转换 
        System.out.println(f2);  //123456.0
        System.out.println(l2);  //12


        //实际案例1:
        char charword = 'A';     //ASCII 65 
        int ch = charword + 1;   // 隐形转换
        System.out.println(ch);  // 65 + 1 = 66
        System.out.println("'A'+1 = "+ charword + 1);   //字符串+整形 或者 字符 == 自动转换成字符串形式
        
        //实际案例2:
        ch = 97;
        char chr = (char)ch;  //将整形转换成为字符类型
        System.out.println((char)48+ch);  //自动转换成为整形进行相加
        System.out.print(chr+"n");
    
        //实际案例3:
        System.out.println((int)12.2132f);  //强制转换 (小数直接虐去)
        System.out.println((float)12);
        System.out.println((double)ch);
    }
}

//######### 执行结果 ######
// 66
// 'A'+1 = A1
// 145
// a
// 12
// 12.0
// 97.0

// char 数据类型 与 字符和字符串参与运算
class Demo_CharString {
    public static void main(String[] args) {
      //1. 字符串参与运算
      System.out.println('a' + 1); // 'a' 转换成ascii码 = 97 + 1 => 98
      System.out.println('a' + 1 + "K-BiuBiu");  //在有字符串参与中被称为字符串连接符  98K-BiuBiu
      System.out.println("5+5="+5+5);   // 5+5=55
      System.out.println("5+5="+(5+5));  //对比上方 5+5=10

      //2. char类型
      char c1 = 97; //取值范围0-65535
      char c2 = 65;
      System.out.println(c1);  //a
      System.out.println(c2);  //A
      //Char类型是可以存储中文，在JAVA中字符都是占用2个字节（中文也是）
      char c3 = '中';
      System.out.println(c3); //中
      //支持unicode编码
      char a = 'u0001';  //字符串常量和字符常量都可以包含任何Unicode字符
      String a = "u0001";
      System.out.println("u6182");   //憂
    }
}

import java.math.BigDecimal;

class Demo_String {
    public static void main(String[] args) {
        /**
         * 1.数字类型转换成字符串型
         * 2.字符串型转换成各种数字类型
         * 3.扩展大数类型与字符串之间的转换 import java.math.BigDecimal;
         */

        //方法1：整形 -> 字符串
        double num1 = 1234.1234567;
        String snum1 = String.valueOf(num1);
        System.out.println("(1)整型 num1 采用string转换 成为字符串：" + snum1);
        System.out.println("(2)整型 num1 输出 成为字符串：" + num1);

        
        //方法2：字符 -> 整形(强制)
        String s = "64"; 
        byte b = Byte.parseByte( s );       //byte 类型
        short t = Short.parseShort( s );    //short 类型
        int i = Integer.parseInt( s );      //int 类型
        long l = Long.parseLong( s );       //Long int 类型
        Float f = Float.parseFloat( s );    //float 类型
        Double d = Double.parseDouble( s ); //double 类型
        System.out.println("(3)字符串 s = " + s);
        System.out.println(b + " - " + t + " - " + i + " - " + l + " - " + f + " - " + d);


        //方法3：大数类型与字符串之间的转换扩展
        String doubleStr = "44444.55555";
        BigDecimal bignum = new BigDecimal(doubleStr); //String类型转成bigdecimal类型生成bignum对象
        String str = bignum.toString();                //实现bigdecimal类型转成String类型：
        BigDecimal bd = bignum.setScale(2, BigDecimal.ROUND_HALF_UP);   //设置小数位数，第一个变量是小数位数，第二个变量是取舍方法(四舍五入) 
        System.out.println("str 的大数据类型值是： " + str + "  提取str的小数点后两位的值：" + bd);   //str 的值是： 44444.55555   //44444.56
    }
}

- 算术运算符 ：+ - * / % ++ --
- 赋值运算符 ：= += -= *= /= %= 
- 比较(关系或条件)运算符: == != > < >= <= 
- 逻辑运算符 ：&& & | ! ^ 
- 位运算符 ：& | ^ ~ >> << >>>
- 三目运算符 ：
- 字符串连接运算符 : +

// 运算操作符 （使用）
class Demo_OperationalCharacter {
    public static void main(String[] args) {
        /**#算法运算符*/
        //0. 整数与小数相除
        System.out.println( 10 / 3.0); //3.3333333333333335

        //1. % 符号
        System.out.println(-3 % 5);  //左边|-3| < |5| 则返回 -3
        System.out.println(-3 % 3); //左右两边绝对值一样返回 0
        System.out.println(-13 % 3); //余数操作至和左边值有关，-1 （正就是正/负就是负）
        System.out.println(13 % 3);  //余数操作至和左边值有关 1

        //2. 自加/自减
        int a = 0;
        System.out.println(a++);  //0 先赋值在++
        System.out.println(++a);  //2 先++再赋值
        //第二题
        int x = 1;
        int y = (x++)+(++x)+(x*10); //1 + 3 + 30
        System.out.println(y);      //34

        //3. 面试题（那一句话回报错）
        byte b = 10;
        b++; //默认在底层进行转换 b = (char)(b+1) 所以不会报错
        //b = b + 1;  //会产生错误需要进行强制类型转换由于byte和int计算，通过隐型需要将byte转换为int
        System.out.println(b); //11


        /*#赋值运算符 ：把右边的常量值赋值给左边的变量,左边必须是变量;*/
        //4.面试题：
        //short s = 1;s = s + 1; //当short与int进行运算时候，会将提升为int类型返回两个int相加后的结果
        short s = 1;s += 1; //不会报错 底层进行自动转换处理 s = (short)(s+1) 
        System.out.println(s); //2


        /*#关系运算符 */
        System.out.println(4 == 3); //false


        /*#逻辑运算符  
         5.&& 与 & 的区别：
            1）效果一样 
            2)&&类似于C有短路求值效果; 左边false，则右边不执行； 
         6.|| 与 |的区别：
            1）效果一样
            2）||也存在短路求值效率；左边为true，则右边不执行；
        */
        int a1 = 10;
        int b1 = 20;
        int c1 = 30;
        System.out.println(a1 > b1 ^ b1 < c1); //true（ ^ 逻辑异或 （true|false）则为真 ,其他都为假）
        System.out.println(a1 < b1 ^ b1 < c1); //false  (true|true) 则为假
        //7.a1 先赋值在++ 这时 a1 = 10 != 3 为假,由于短路求值的原因 ++b1是不被执行的；(结果还是false| a/b 返回 11，20)
        System.out.println((a1++ == 3) && (++b1 == 4));  
        //6.a1 先++在赋值 这时 a1 = 12 == 12 为真，由于短路求值的原因 b1++是不被执行的；（结果为true | a/b返回 12，20）
        System.out.println((++a1 == 12) || (b1++ == 4));  
        System.out.println(a1); //11
        System.out.println(b1); //20
        
        
        /*#为运算符 : 
            ~ ：按位取反 3 = -（3+1）
            << : 向左移动最高位丢弃，右边填0补齐（左移，向左移动几位就是乘以2的几次幂）
            >>> : 无符号右移动，无论最高位是0还是1，左边补齐0
         */  
        System.out.println(6 & 3); // 0110 
                                   // 0011 = 0010 = 2
        System.out.println(6 | 3); // 0111 = 7 
        System.out.println(6 ^ 3); // 0101 = 5
        //7.按位取反
        // 0000 0011 3的原码/反码/补码
        // 1111 1100 对3按位取反
        // 0000 0001  
        // 1111 1011 反码 = 补码 - 1
        // 1000 0100 原码
        System.out.println(~3);  // -4
        //8.^位异或运算符的特定：一个数据对另一个数据位异或两次，该数不变(常常使用在对称加密中)
        System.out.println(5 ^ 10 ^ 5); // 10
        //利用：交换两个数且只有两个变量 (还有一种 x = x + y的方法有弊端可能会超过int取值类型范围)
        int change1 = 5;
        int change2 = 6;
        change1 ^= change2;  // 5 ^ 6 
        change2 ^= change1;  // 6 ^ 5 ^ 6 = 5 
        change1 ^= change2;  // 5 ^ 6 ^ 5 = 6
        System.out.println(change1); //6
        System.out.println(change2); //5

        //9. << 与 >>> 移位运算 (运算效率最高，对二进制位进行操作)
        System.out.println(12 << 1); // 12 * (2 ^ 1) =  24
        System.out.println(24 >> 2); // 24 / (2 ^ 2) = 6
        System.out.println(24 >>> 2); // 6 无符号移动
        System.out.println(-24 >>> 2); // 1073741818 无符号移动
        // 10000000 00000000 00000000 00011000 = -24 （原码）
        // 00100000 00000000 00000000 00000110 > 向右移动2位  （最高位可以不管了）
        // 00011111 11111111 11111111 11111001 > 反码
        // 00011111 11111111 11111111 11111010 > 补码 = 1073741818


        /***
         * #三元运算符
         * (关系表达式)？表达式1 ： 表达式2
         */
        int three = (change1 > change2)? 1:0;
        System.out.println(three); //1
        //获取三个值里面的最大值
        int max = (a1 > b1) ? a1:b1; 
        max = (max > c1) ? max:c1;
        System.out.println(max);  //30
    }
}