Java初步使用

java 目前属于甲骨文，长期支持版本为 java8 和 java11，主要学习JavaEE (Java Enterprise Edition) 企业版
java特性：

强类型静态类型的语言
跨平台 --> 不同平台的JVM保证
解释性 --> 使用JVM解释字节码

JVM是一台虚拟的计算机，具有指令集并使用不同的存储区域。负责执行指令，管理数据、内存、寄存器

JDK（Java Development Kit）是什么？
JDK 是 Java 语言的软件开发工具包，关于JDK与JRE:

JDK = JRE + java开发工具
JRE = JVM + 核心类库

如果只需要运行开发好的.class文件，只需要JRE即可

JDK的国内下载源，见：JDK下载

第一个程序#

创建一个Hello.java文件，写入如下内容：

 public class Hello {
    public static void main(String[] args){
        System.out.println("hello world");
    }
}

文件名要与类名相同
定义方式public class 和 public static void main(){xxx}
要以 ; 结尾
使用javac Hello.java编译java文件成Hello.class(字节码)

假如报错: 错误: 编码 GBK 的不可映射字符，那是因为编码问题，只需要添加-encoding utf8即可
使用java Hello运行程序（将字节码放到JVM中解释）

开发注意事项#

java源文件以.java为扩展名，源文件的基本组成部分为类
java应用程序的执行入口为main, 它有固定的写法：
```
 public static void main(String[] args){....}
```
java区分大小写
语句要以 ; 结尾

一个源文件中最多只能有一个public类，其他类不限

 public class Hello{
   public static void main(String[] args){
      System.out.println("hello 1");
   }
 
}
// 其他的类
 
class Dog{
   public static void main(String[] args){
      System.out.println("hello dog");
   }
}
 
class Cat{
   public static void main(String[] args){
      System.out.println("hello Cat");
   }
}

编译后会生成对应类的字节码如: Dog.class Cat.class

编写风格
有两种：行尾风格和次行风格
包名
多单词组成时，都小写且使用.链接，如：aaa.bbb.ccc
类名接口名
多单词组成时，使用大驼峰, 比如ShotGame
变量名方法名使用小驼峰, 比如shotGame
常量名全大写使用_连接，比如MAX_NUM

转义符号#

一般使用如下：

 public class Test{
    public static void main(String[] args){
        System.out.println("张三\t李四\t王五");  // 制表符
        System.out.println("你好\n世界"); // 回车
        System.out.println("c:\\d");  // \
        System.out.println("aaa\rbb");  // 换行会替换掉
        System.out.println("aaa\r\bbb");  // 换行+回车会在下一行
    }
}

注释#

java的注释分

单行注释

 public class Comment{
   public static void main(String[] args){
      // 单行注释
      /*
      多行注释
      */
      System.out.println("查看代码");
   }
}

多行注释

 public class Comment{
   public static void main(String[] args){
      /*
      多行注释
      */
      System.out.println("查看代码");
   }
}

文档注释
比较重要，文档注释可以被javadoc解析成网页，其写法有固定的格式。
```
 /**
* 这个类演示了文档注释
* @author lczmx
* @version 1.2
*/
 
public class Comment{
   public static void main(String[] args){
      System.out.println("查看代码");
   }
}
```
使用命令: javadoc Comment.java -d ./docs -encoding utf8 -author -version即可解析成网页
上面使用的是author和version这两个标签，更多的标签见：Java 文档注释
打开./docs/index.html即可查看文档
看文档时需要注意java类的组织形式：

变量定义#

有两种方式：

 public class Var{
    public static void main(String[] args){
 
        // 声明再赋值
        int a;
        a = 1;
        // 声明并赋值
        int b = 3;
        System.out.println("a=" + a + "b=" + b);
    }
 
}

+号的使用#

使用+时遵循如下规则：

两边为数值，加法运算
一边为字符串，拼接

 public class Plus{
    public static void main(String[] args){
        System.out.println(100 + 98);
        System.out.println("100" + 98);
        System.out.println(100 + 3 + "hello");
        System.out.println("hello" + 100 + 3);
        /*
        198
        10098    
        103hello 
        hello1003
         */
   
    }
}

基本数据类型#

注意, java的字符串不是基本数据类型，它是一个对象

使用例子：

 public class Type{
    public static void main(String[] args) {
        // 整形
        byte a = 1;  // -128 127 2^7
        short b = 22;  // -32768 32767
        int c = 123455; // -2147483648 2147483647
        long d = 123232323L; // -9223372036854775808 9223372036854775807
		// 形如1234 默认为int，可以手动指明为long类型
		// 不指明时会自动转换
		
        // 浮点型
        float f1 = 1.1234F;  
        // Java中的浮点字面值默认为双精度。要指定浮点字面值，必须在该常量后面附加一个 F 或 f 。
        double f2 = 1.231;
        // 字符
        char e = '六';  // !!!! 注意为单引号，内部就是一个数字, 所以可以 char e = 97 这样定义
        boolean f = true;  // or false
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
        System.out.println(f1);
        System.out.println(f2);
        System.out.println(e);
        System.out.println(f);
 
    }
}

关于浮点数的运算与比较，有点特殊：

 public class Float{
    public static void main (String[] args) {
        // 默认1.1为双精度浮点型， 需要指定F
        float f1 = 1.23456789F;
        double f2 = 1.23456789;
        System.out.println(f1); // 精度缺失
        System.out.println(f2); // 精度可以保存
 
        // 科学计数法
        double f3 = 1.23E2; // 1.23 * 10^2
        double f4 = 1.23E-2;  // 1.23 * 10^-2
        System.out.println(f3);  // 123.0
        System.out.println(f4);  // 0.0123
 
        // 比较浮点数
        // 由于计算后的浮点数在内存中为一个近似值，所以不能直接比较
        // 应该相减，小于一个固定范围视为相等（范围根据业务来）
        double money1 = 1.2;
        double money2 = 1.2;
        // 可以执行
        if ( money1 == money2 ) {
            System.out.println("money1与money2 金额相等!");
        }
        double money3;
        money3 = 0.4 * 3;  // 实质上可能是1.200000000001
        // 计算相差绝对值，是否小于固定范围
        if ( Math.abs(money1 - money3) <= 0.001 ) {
            System.out.printlnk("money1与money3 金额相等!");
        }
 
    }
}

这是因为浮点数不直接存放数字，而是存放：符号位 + 指数位 + 尾数位
而尾数部分可能丢失，造成精度损失（所以浮点数都是近似值）

关于字符类型，也要补充一下, 主要是编码方式的区别：

 public class CharDetail{
    public static void main(String[] args){
        // 一般使用
        char c1 = 'a';
        char c2 = 98;
        char c3 = 'a' + 2;
        // 输出
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        // =====> 输出数字
        System.out.println((int)c1);    
 
        // 1. Char两个字符表示， 对应的编码方式为unicode
        // 2. Char在内部以数字存储：
        //            a -(通过编码方式)-> 97 -> 内存
        // 3. 读取的时候会，自动将数字装换成编码方式中对应的字符
        //            内存 -> 97 -(通过编码方式)-> a
        // 补充一下字符编码
        // ASCII 8bit表示，128个字符（0~127）
        // unicode  中英文都为2字节
        // UTF-8  (1~6个字节) 大小可动态变化，英文1字节 中文3字节
        // ----------- 一个字符（即'a'或'中'）可以有多个字节
    }
}

字符集中只规定了字符的代码值并未规定具体如何存储，编码方式解决了字符在计算机中如何存储的问题。

类型转换#

即不同数据类型如何转换

自动类型转换#

低精度可以自动向高精度转换
有两条路线:

 // char -> int -> long -> float -> double
//   2      4      8        4        8
// byte -> short -> int -> long -> float -> double
//  1        2       4      8        4        8

这里有一个问题： float 4个字节可以存放 long 8个字节？
主要原因是float/double不是直接存储数值：浮点数的32位不是简单的直接表示大小，而是按照一定的标准分配的。其中

第1位，符号位。
接下来的8位，指数域。
剩下的23位，小数域，M的取值范围为[1，2）或[0，1）。
也就是说，浮点数在内存中的二进制值不是直接转换为十进制数值的，而是按照上述公式计算而来，通过这个公式，虽然只用到了4个字节，但是浮点数却比长整型的最大值要大。

一般使用的规则：

低精度可以转换成高精度，反之不行
多种类型运算时，先转化成最大的
( byte, short ) 不可以与 char 之间相互转化
byte short 和 char 之间虽然不能转化，但是这三者之间可以进行运算，结果提升为int，自身运算也会提升
boolean 不转化为数字

 // 类型转换
public class AutoConvert{
    public static void main(String[] args) {
        // 1. ======= 低精度可以转换成高精度
        // char -> int -> long -> float -> double
        //  2       4      8       4         8
        // byte -> short -> int -> long -> float -> double
        //  1        2       4      8       4         8
        int a = 'a';
        double b = 80;
        System.out.println(a);  // 97
        System.out.println(b);  // 80.0
 
        // 2. =========== 多种类型运算时，先转化成最大的
        int a2 = 10;
        // float b2 = a2 + 1.1;  // 不可以，因为1.1为double
        double b2 = a2 + 1.1;
        System.out.println(b2);
 
        // 3. =========== ( byte, short ) 不可以与 char 之间相互转化
        // 按照我的理解，byte 和 short 虽然有1字节和2字节大小，但是为有符号的数字
        // 所以不能让byte short 和 char之间进行转化
 
        /*
        byte c3 = 1;
        short s3 = 2;
        char char3 = c3; 
 
        */
        // 4. =========== 低精度往高精度转化，不行
        // int a4 = 1.1;
        // !! 但是 byte short 会先判断数值大小，才赋值，所以可以直接使用 1 2 3........
        byte b4 = 1;
        // !! 如果用int的话不行, 它先判断类型
        int ab4 = 2;
        // byte b44 = ab4;
        short s4 = 1;
 
        // 5. byte short 和 char 之间 虽然不能转化，但是这三者之间可以进行运算，结果提升为int
        byte b5 = 2;
        short s5 = 1;
        char c5 = 11;
 
        int result5 = b5 + s5;  // byte + short
        System.out.println(result5);  // 3
        int result6 = b5 + c5; // byte + char;
        System.out.println(result6);  // 13
        int result7 = s5 + c5; // short + char;
        System.out.println(result7);  // 12
 
        // !!! 与自身运算也是int
        int result8 = b5 + b5;  // byte + byte => int
        // short char 也是这样
        System.out.println(result8);  // 4
 
        byte num1 = 1;
        short num2 = 2;
        int num3 = 123;
        float num4 = 1.234F;
        double num5 = num1 + num2 + num3 + num4;  // => float 转化成 double
 
        System.out.println(num5);
 
        // 6. ========= boolean 不转化 为数字
        // !! 就行强制转化也不行
        /*
        boolean boo6 = true;
        int i6 = (int)boo5;
        int i6 = boo5;
        */
 
    }
}

强制类型转换#

我们可以对数值进行强制转化，不过强制类型转化会丢失精度或数据溢出，取舍权衡需要考虑好
一般的使用形式： (type)xx

 // 高精度 -> 低精度：需要强制类型转化
 
public class ForceConvert{
    public static void main(String[] args){
        int a = (int)2201.2;  // 精度丢失
        byte b = (byte)a;  // 数据溢出
 
        System.out.println(a);  // 2201
        System.out.println(b);  // -103 数据溢出了
        System.out.println( (byte)127 );  //  不超出范围则不会溢出 (byte 1个字节 -127 ~ 127)
    }
 
}

与字符串的相互转换#

即如何将其他类型转换成字符串和将字符串转化成其他类型
前者需要只需要+空字符串即可
后者需要通过基本类型的包装类调用 parseXxx方法即可

需要注意的是，字符串转字符类型，使用的是charAt(index)方法

 public class ToString{
 
    public static void main(String[] args){
        // 其他类型 => String
        char c1 = 97;
        int i1 = 2;
        float f1 = 3.14F;
        boolean b1 = true;
        String s1 = c1 + "";
        String s2 = i1 + "";
        String s3 = f1 + "";
        String s4 = b1 + "";
        //                      a 2 3.14 true
        System.out.println(  " " + s1 + " " + s2 + " " + s3 + " " + s4 );
 
    }
}
 
class ToOther{
 
    public static void main( String[] args ){
        // String => 其他类型
        // !! 通过基本类型的 包装类 调用 parseXxx方法即可
        // !! 属于面向对象内容
 
        // 注意Integer的写法
        String s1 = "123";
        
        int num1 = Integer.parseInt(s1);
        float num2 = Float.parseFloat(s1);
        short num3 = Short.parseShort(s1);
        // 其他的类推
        boolean b = Boolean.parseBoolean("true");
        System.out.println(num1);
        System.out.println(num2);
        System.out.println(num3);
        System.out.println(b);
 
        // !! 取字符
        System.out.println(s1.charAt(0));
 
        // !! 注意：可能不一定装换成功, 需要异常处理
    }
}

运算符#

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。

算术运算符#

算术运算符是对数值类型的变量进行运算的运算符

运算符	运算	例子	结果
`+`	正号	`+7`	7
`-`	负号	`b=11; -b`	-11
`+`	加	`9 + 9`	18
`-`	减	`10 - 8`	2
`*`	乘	`7 * 8`	56
`/`	除	`9 / 9`	1
`%`	取模（余数）	`11%9`	2
`++`	自增	`a=2;b=++a;`	a = 3;b=3
`--`	自减	`a=2;b=--a`	a=1;b=1;
`+`	字符串相加	`"lcz" + "mx"`	“lczmx”

需要特别注意 ++和--, 它们在给其他变量赋值时，在原变量的前后的结果是不一样的，看下面的例子

使用例子：

 public class ArithmeticOperator{
    public static void main(String[] args){
        // 注意混合运算后的结果类型
        // +
        int a = 2;
        int b = 1;
        System.out.println(a + b);  // 3
 
        // -
        System.out.println(a - b);  // 1
 
        // *
        System.out.println(a * b);  // 2
        // /
        System.out.println(a / b); // 2
 
        // ======= %
        // !! 取模运算公式
        // a % b = a - a / b * b
        System.out.println(10 % 3);  // 1
        System.out.println(-10 % 3);  // -1
        System.out.println(10 % -3);  // 1
        System.out.println(-10 % -3);  // -1
 
        // 总结一下：
        /*
        1. 正 % 正 = 正
        2. 负 % 正 = 负
        3. 正 % 负 = 正
        4. 负 % 负 = 负
 
        即 第一个数为负数时，结果为负数
        !! 假如a为double时会：
        a % b = a - (int)a / b * b
        */
 
        // ++ 和 --
        // i = j++   i = j-- : 先赋值再操作
        // i = ++j   i = --j : 先操作再赋值
        // 总结，看变量在前面还是运算符在前面
        // 变量在前，则先取变量的值，则运算
        // 运算符在前，则先运算，再取值
 
        int i = 10;
        int j = i++;
        System.out.println("i++: i = " + i + " j = " + j);
 
        i = 10;
        j = ++i;
        System.out.println("++i: i = " + i + " j = " + j);
 
        // !! 自己使用++ -- 赋值时的规则
        // 会引用一个临时变量，保存数据
        int count = 1;
        count = count++;
        // 1. 返回count使用临时变量保存，即 temp = count
        // 2. 运算++, 即 count = count + 1
        // 3. 赋值给count, 用的是temp的数据： count = temp
        System.out.println(count);  // 1
 
        count = ++count;
        // 1. 返回++使用临时变量保存
        //    count = count + 1
        //    temp = count
        // 2. 赋值给count，即 count = temp
        System.out.println(count);  // 2
    }
 
}

关系运算符#

关系运算符的结果都是boolean型，即true或者false
使用例子如下：

 public class RelationalOperator{
    public static void main(String[] args){
        System.out.println(1 == 1);
        System.out.println(1 != 1);
        System.out.println(1 < 2);
        System.out.println(1 > 2);
        System.out.println(1 <= 2);
        System.out.println(1 >= 2);
        boolean isInstance = "lczmx" instanceof String;
        System.out.println("\"lczmx\"为String子类: " + isInstance);
    }
}

逻辑运算符#

逻辑运算符有以下几种：

& && 逻辑与短路与
| || 逻辑或短路或
! 取反
^ 逻辑异或

解释一下：

与指的是两边同时为true时, 才为true
或指的是有一边为true时, 则为true
短路指的是不满足条件的立即返回如(false && true), 看到false就跳出了，不看true，而逻辑则会全部看完
取反即true变flase，false变true
逻辑异或指的是两边布尔值不同时为true, 否则为false, 如（false^ true=> true）

重点关注：逻辑与短路与逻辑或短路或，举个例子：

 public class LogicOperator{
    public static void main(String[] args){
    int a = 3;
	// 短路
    if (a < 2 && a++ > 10){}
    // 结果： a = 3
    System.out.println(a);
	
	// 逻辑
    if (a < 2 & a++ > 10){}
    // 结果： a = 4  
    System.out.println(a);
    }
}

赋值运算符#

比较简单：= += -= *= /= %=
使用例子：

 public class AssignOperator{
    public static void main(String[] args) {
	    int n1 = 10;
		n1 += 4;  // n1 = n1 + 4;
		System.out.println(n1); // 14
		
		n1 /= 3; // n1 = n1 /3; 
		System.out.println(n1); // 4
		
		byte b = 3;
		b += 2; // 等价于 b = (byte)(b + 2);
	}
}

三元运算符#

相当于if-else的简写版, 格式：

 int a = 10;
int b = 99;
int result = a > b ? a++ : b--;

表达式成立时，返回的第一个a++, 否返回第二个b--

需要主要返回类型是否为接收结果的类型

位运算符#

7个位运算符

& 按位与
| 按位或
^ 按位异或
~ 按位取反
>> 算术右移低位溢出，符号位不变并用符号位补充溢出的高位
<< 算术左移符号位不变低位补0
>>> 无符号右移低位溢出到位补0

注意：没有<<<

运算时注意转成补码, 取结果时注意转成原码
使用例子：

 public class BitOperator{
 
    public static void main(String[] args){
 
        // 2 & 3
        /*
        2的原码 00000000 00000000 00000000 00000010
        3的原码 00000000 00000000 00000000 00000011
        补码相同
            &   00000000 00000000 00000000 00000010
        补码为正，原码相同
                                                2
        */
        System.out.println(2 & 3);
        // ~-2
 
        /*
        -2的原码 10000000 00000000 00000000 00000010
            反码 11111111 11111111 11111111 11111101
            补码 11111111 11111111 11111111 11111110
             ~   00000000 00000000 00000000 00000001
            补码为正，原码相同
                                                1
        */
        System.out.println(~-2);
 
        // ~2
        /*
        2的原码 00000000 00000000 00000000 00000010
        补码相同
            ~   11111111 11111111 11111111 11111101
        结果反码
                11111111 11111111 11111111 11111100
        结果原码 10000000 00000000 00000000 00000011
                                                -3
        */
       System.out.println(~2);
 
        // 2|3
        /*
        2的原码 00000000 00000000 00000000 00000010
        3的原码 00000000 00000000 00000000 00000011
        都为正数 补码相同
            |  00000000 00000000 00000000 00000011
        结果为正数
                                                3
        */
        System.out.println(2|3);
 
        // 2^3
        /*
        2的原码 00000000 00000000 00000000 00000010
        3的原码 00000000 00000000 00000000 00000011
        都为正数 补码相同
            |  00000000 00000000 00000000 00000001
        结果为正数
                                                1
        */
        System.out.println(2^3);
 
        // 1 >> 2
         System.out.println(1 >> 2);
        /*
        00000001 => 000000000 => 1/2/2 = 0
        */
 
        // 1 << 2
        /*
        00000001 => 000000100 => 1*2*2 = 4
        */
        System.out.println(1 << 2);
 
        // 4 << 3
        /*
        00000100
        00100000
        => 32
        => 4 * 2 * 2 * 2 = 32
        !! 即我们无需写出位，可以直接*2或/2, 取整即可
        */
        System.out.println(4 << 3);
    
 
    }
}

运算符优先级#

如下图

输入输出#

输入使用Scanner类, 输出使用System.out.println或System.out.print
使用例子：

 // 1. 导入， 简单的文本扫描器
import java.util.Scanner;
 
public class ScannerIn{
    public static void main(String[] args) {
        // 2. 创建一个对象实例
        // 注意类型
        Scanner s = new Scanner(System.in);
        // 3. 打印提示
        System.out.println("请输入名字");
        // 4. 使用next等方法，接收用户输入
        String name = s.next();  // 字符串
        System.out.println("请输入年龄");
        int age = s.nextInt();  // int 
        System.out.println("请输入工资");
        double salary = s.nextDouble(); // double
        // !! 输入类型不对时，会报错
        System.out.println("用户信息如下：");
        System.out.println("name=" + name + "; age=" + age + "; salary=" + salary);
        // 5. 这些方法，可以看文档：https://www.matools.com/file/manual/jdk_api_1.8_google/java/util/Scanner.html
    }
}

System.out.print不会自动换行

进制#

定义方式#

通过数字前面的标记，确定进制，默认十进制

 public class BinaryTest{
    public static void main(String[] args) {
 
        // 二进制
        int num1 = 0B10; // or 0b1234
        // 八进制
        int num2 = 010; // 0开头
        // 十进制
        int num3 = 10;
        // 十六进制
        int num4 = 0X10; // or 0xa
        System.out.println(num1);  // 2
        System.out.println(num2);  // 8
        System.out.println(num3);  // 10
        System.out.println(num4);  // 16
    }
}

十进制转其他进制#

要点：

将该数不断除以进制数, 直到商为0
将每一步的余数倒过来

 public class DecimalToOther{
    public static void main(String[] args){
        int num1 = 123;  // -> 2
        /*
        123 / 2 = 61 余 1
        61 / 2 = 30  余 1
        30 / 2 = 15 余 0
        15 / 2 = 7 余 1
        7  / 2 = 3  余 1
        3  / 2  = 1 余 1
                 1        
         */
        // => 0b01111011
        // 记得补全八位
 
        int num2 = 679;  // -> 8
        /*
        679 / 8 = 84 余 7
        84 / 8 = 10 余 4
        10 / 8 = 1 余 2
                1 
        */
        // => 01247
 
        int num3 = 8912; // ->16
        /*
        8912 / 16 = 557 余 0
        557 / 16 = 34 余 d (13)
        34 / 16 = 2 余 2
                2
        */
        // => 0X22E0
    }
}

其他进制转十进制#

规则：从最低为开始（右边），将每位上的数据提取出来，乘以进制的（位数-1）次方

 public class OtherToDecimal{
    int num1 = 0b110001100;
    // 0 * 2^0 + 0 * 2^1 + 1 * 2^2 + 1 * 2^3 + 0 * 2^4 + 0 * 2^5 + 0 * 2^6 + 1*2^7 + 1*2^8
    // = 0 + 0 + 4 + 8 + 0 + 0 + 0 + 128 + 256
    // =  396
 
    int num2 = 02456;
    // 6 * 8^0 + 5 * 8^1 + 4 * 8^2 + 2 * 8^3
    // = 6 + 40 + 256 + 1024
    // = 1326
 
    int num3 = 0xa45;
    // 5 * 16^0 + 4 * 16^1 + 10 * 16^2
    // = 5 + 64 + 2560
    // = 2629
 
}

二进制转八/十六进制#

要点：

分组（3 位或 4 位一组）转换成10进制
合并即可
注意二进制与十进制的对应关系：

  1  1 1 1 1 1
32 16 8 4 2 1

这样就可以很快得出答案了，如：111 => 1 + 2 + 4 = 7
使用例子：

 public class BinaryToOther{
 
    public static void main(String[] args){
        int num1 = 0b11100101;  // -> 8
        /*
        11 100 101
        3   4   5
        =>0345
        */
        int num2 = 0b1110010110; // -> 16
        /*
        11 1001 0110
        3   9    6
        =>0x396
        */
    }
}

八/十六进制转二进制#

要点：

将一位数转换为（3 位或 4 位一组二进制）
合并即可

注意补全

使用例子：

 public class OtherToBinary{
 
    public static void main(String[] args){
        int num1 = 01230;
        /*
        1230
        1(001) 2(010) 3(011) 0(000)
        => 0b0000001010011000
        */
        int num2 = 0xAB29
        /*
        AB29
        A(1010) B(1011) 2(0010) 9(1001)
 
        数值太大时 只需要让8-当前值，等到小的值即可
        => 0b1010101100101001
        */
    }
}

原码反码补码#

这个问题比较重要

主要遵循如下规则：

二进制的最高位是符号位：0表示正数，1表示负数 (将1倒过来不就是-了吗)
正数的原码，反码，补码都一样（三码合一）
负数的反码=它的原码符号位不变，其它位取反 (0->1,1->0)
负数的补码=它的反码 + 1，即负数的反码=负数的补码 - 1
0的反码，补码都是0
java没有无符号数，换言之，java中的数都是有符号的
在计算机运算的时候，都是以补码的方式来运算的 (所以需要先转成补码)
当我们看运算结果的时候，要看他的原码（结果是补码，需要转成原码）

流程控制#

一般来说，流程控制用三种：

顺序控制一般的代码流程，从上到下执行
分支控制一个或多个分支执行
循环控制可以让代码重复执行

分支控制#

if分支#

举个例子：
做个出票系统：根据淡旺季的月份和年龄，打印票价

4-10月旺季:
1. 成人(18-60)：60
2. 儿童(<18)：半价
3. 老人(>60)：1/3
淡季:
1. 成人(18-60)：40
2. 其他：20

 import java.util.Scanner;
public class TicketingSytem{
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        System.out.println("月份");
        int month = s.nextInt();
        System.out.println("年龄");
        byte yearOld = s.nextByte();
 
        if (month >= 4 && month <= 10){
            int price = 60;
            if (yearOld < 18){
                System.out.println(price / 2);
            }else if(yearOld > 60){
                 System.out.println(price / 3);
            }else{
                 System.out.println(price);
            }
        }else{
            if (yearOld > 18 && yearOld < 60){
                 System.out.println(40);
            }else{
                System.out.println(20);
            }
 
        }
 
    }
}

赋值作为条件时，看赋值后的变量，如boolen a= false if(a=true)=> 这样是可以执行的

switch分支#

格式：

 switch (c){
            case 'a':
                System.out.println("星期一");
                break;
             default :
                System.out.println("未知");
                break;
            
	}

注意事项：

表达式数据类型，应和case后的常量类型一致，或者是可以自动转成可以相互比较的类型，比如输入的是字符而常量是int
switch(表达式)中表达式的返回值必须是：(byte,short,int,char,enum,String)
case子句中的值必须是常量，而不能是变量
default子句是可选的，当没有匹配的case时，执行default
break语句用来在执行完一个case分支后使程序跳出switch语句块；如果没有写break,程序会顺序执行到switch结尾(即不会判断case)

使用例子：

 /*
1.
使用switch把小写类型的char型转为大写（键盘输入）。只转换a,b,c,d,e.
其它的输出"other"。
2.
对学生成绩大于60分的，输出"合格”。低于60分的，输出"不合格”。（注：输入
的成绩不能大于100)，提示成绩/60
3.
根据用于指定月份，打印该月份所属的季节。3,4,5春季6,7,8夏季9,10,11
秋季12,1,2冬季[课堂练习，提示使用穿透]
*/
import java.util.Scanner;
 
public class SwitchExercise{
    public static void main(String[] args){
 
        // 1 
        System.out.println("char>>>");
        Scanner scanner = new Scanner(System.in);
        char c = scanner.next().charAt(0);
        switch (c){
            case 'a':
                System.out.println('A');
                break;
            case 'b':
                System.out.println('B');
                break;
            case 'c':
                System.out.println('C');
                break;
            case 'd':
                System.out.println('D');
                break;
            case 'e':
                System.out.println('E');
                break;
            default:
                System.out.println("other");
                break;
        }
        // 2
        System.out.println("成绩>>>");
        double score = scanner.nextDouble();
        // [60, 100] => /60 = 1;
        // [0, 60)  => /60 = 0;
        switch ( (int)score / 60 ){
            case 1:
                System.out.println("合格");
                break;
            case 0:
                System.out.println("不合格");
                break;
            default:
                System.out.println("异常数据");
                break;
        }
 
        // 3
        System.out.println("月份>>>");
        int month = scanner.nextInt();
        switch (month){
            case 3:
            case 4:
            case 5:
                 System.out.println("春季");
                 break;
 
            case 6:
            case 7:
            case 8:
                 System.out.println("夏季");
                 break;
 
            case 9:
            case 10:
            case 11:
                 System.out.println("秋季");
                 break;
            case 12:
            case 1:
            case 2:
                 System.out.println("冬季");
                 break;
 
            
 
        }
 
 
    }
}

循环控制#

for循环#

一般使用例子：

 public class For {
    public static void main(String[] args){
        // 1.打印1~100之间所有是9的倍数的整数，统计个数及总和
        int sum = 0, count = 0;
        int start = 1, end = 100;
        int t = 9; // 倍数
        for (int i = start; i <= end; i++){
            if (i % t == 0){
                sum += i;
                count++;
                // 81 90 99 
                // 9  10  11
            }
        }
        System.out.println("sum: " + sum + " count: " + count);
 
        //打印
        /*
        0 + 5 = 5
        1 + 4 = 5
        2 + 3 = 5
        3 + 2 = 5
        4 + 1 = 5
        5 + 0 = 5
        */
        int total = 5;
        for (int i=0; i<= total; i++){
            int temp = total - i;
            System.out.println(i + " + " + temp + " = " +  total);
        }
 
    }
}

注意：

循环内部语句只有一天是，可以省略{}, 但不建议使用
多个条件可以使用,隔开，如if(int i=0,j=0; i<count; i++, j+=2)
我们可以省略初始化条件和变量迭代, 灵活使用，如for( ; i<= 10 ; )
还可以全部省略，变成死循环，如for(;;)

关于增强for，是一种简化迭代器书写方式
使用例子：

  
public class Demo{
	public static void main(String[] args){
	    int arr[] = {1,2,3};
	    /**
	    *增强for
	    */
	    for(int num : arr){
	     System.out.println(num);
	    }
	}
}

只适合取数据，不能更改数据
只用于数组，或实现Iterable接口的集合类上；set，list

while循环#

使用格式：

 while (循环条件) {
    循环体（语句）;
	循环变量迭代;
}

使用例子：

 public class While{
    public static void main(String[] args){
        /*
        1.打印1一100之间所有能被3整除的数
        2.打印40一200之间所有的偶数
        */
        int end1 = 100, end2 = 200;
        int start1 = 1, start2 = 40;
 
        int t1 = 3;
        int t2 = 2;
        while (start1 <= end1){
            if (start1 % t1 == 0){
                System.out.println(start1);
            }
            start1++;
        }
 
        while (start2 <= end2){
            if (start2 % t2 == 0){
                System.out.println(start2);
            }
            start2++;
        }
 
 
    }
}

doWhile循环#

基本使用：

 do{
	循环体（语句）;
	循环变量迭代;
}while(循环条件);

先执行在判断，即至少执行一次
while后面有;

流程图:

使用例子：

 import java.util.Scanner;
 
public class DoWhile{
    public static void main(String[] args){
 
        // 一般使用
        // !! 至少会执行一次
        // ! 不要忘记while后面的 ';' 了
        int c = 0;
        do {
            System.out.println("lczmx " + c);
            c++;
        }while(c > 10);
 
        // 统计1 - 200之间能被5整除但不能被3整除的个数
        byte num1 = 5;
        byte num2 = 3;
        int i = 1;
        int count = 0;
        do {
            if(i % num1 == 0 && i % num2 != 0){
                count++;
            }
              i++;
        }while(i<=200);
        System.out.println("count " + count);
 
        // 如果李三不还钱，打到张三说还钱为止
        Scanner scanner = new Scanner(System.in);
        char input;
        do{
            System.out.println("打！！\n还钱? y or n >>>");
            input = scanner.next().charAt(0);
        }while(input != 'y');
 
    }
}

break和continue#

break跳出当前循环
continue跳过本次循环

它们都可以指定Label，跳到对应的俄循环中

默认是当前的循环

使用例子：

 lable1:
for (int j = 0; j < 4; j++) {
lable2:
        for (int i = 0; i<10;i++) {
		    if(i == 2){
			    break lable1
			}
		 }
}

同理，continue也可以像上面那样操作

本文根据韩顺平零基础30天学会Java视频整理而来

posted @ 2022-03-20 11:44 403·Forbidden 阅读(242) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· Java数组

· FastAPI快速查阅

· java基础语法

· 01-Java程序基础

· Java 程序设计语言概述

阅读排行：
· 阿里最新开源QwQ-32B，效果媲美deepseek-r1满血版，部署成本又又又降低了！
· 单线程的Redis速度为什么快？
· SQL Server 2025 AI相关能力初探
· AI编程工具终极对决：字节Trae VS Cursor，谁才是开发者新宠？
· 展开说说关于C#中ORM框架的用法！

	public class Hello {
	public static void main(String[] args){
	System.out.println("hello world");
	}
	}

	public class Hello{
	public static void main(String[] args){
	System.out.println("hello 1");
	}

	}
	// 其他的类

	class Dog{
	public static void main(String[] args){
	System.out.println("hello dog");
	}
	}

	class Cat{
	public static void main(String[] args){
	System.out.println("hello Cat");
	}
	}

	public class Test{
	public static void main(String[] args){
	System.out.println("张三\t李四\t王五"); // 制表符
	System.out.println("你好\n世界"); // 回车
	System.out.println("c:\\d"); // \
	System.out.println("aaa\rbb"); // 换行会替换掉
	System.out.println("aaa\r\bbb"); // 换行+回车会在下一行
	}
	}

	public class Comment{
	public static void main(String[] args){
	// 单行注释
	/*
	多行注释
	*/
	System.out.println("查看代码");
	}
	}

	/**
	* 这个类演示了文档注释
	* @author lczmx
	* @version 1.2
	*/

	public class Comment{
	public static void main(String[] args){
	System.out.println("查看代码");
	}
	}

	public class Var{
	public static void main(String[] args){

	// 声明再赋值
	int a;
	a = 1;
	// 声明并赋值
	int b = 3;
	System.out.println("a=" + a + "b=" + b);
	}

	}

	public class Plus{
	public static void main(String[] args){
	System.out.println(100 + 98);
	System.out.println("100" + 98);
	System.out.println(100 + 3 + "hello");
	System.out.println("hello" + 100 + 3);
	/*
	198
	10098
	103hello
	hello1003
	*/

	}
	}

	public class Type{
	public static void main(String[] args) {
	// 整形
	byte a = 1; // -128 127 2^7
	short b = 22; // -32768 32767
	int c = 123455; // -2147483648 2147483647
	long d = 123232323L; // -9223372036854775808 9223372036854775807
	// 形如1234 默认为int，可以手动指明为long类型
	// 不指明时会自动转换

	// 浮点型
	float f1 = 1.1234F;
	// Java中的浮点字面值默认为双精度。要指定浮点字面值，必须在该常量后面附加一个 F 或 f 。
	double f2 = 1.231;
	// 字符
	char e = '六'; // !!!! 注意为单引号，内部就是一个数字, 所以可以 char e = 97 这样定义
	boolean f = true; // or false
	System.out.println(a);
	System.out.println(b);
	System.out.println(c);
	System.out.println(d);
	System.out.println(f1);
	System.out.println(f2);
	System.out.println(e);
	System.out.println(f);

	}
	}

	public class Float{
	public static void main (String[] args) {
	// 默认1.1为双精度浮点型，需要指定F
	float f1 = 1.23456789F;
	double f2 = 1.23456789;
	System.out.println(f1); // 精度缺失
	System.out.println(f2); // 精度可以保存

	// 科学计数法
	double f3 = 1.23E2; // 1.23 * 10^2
	double f4 = 1.23E-2; // 1.23 * 10^-2
	System.out.println(f3); // 123.0
	System.out.println(f4); // 0.0123

	// 比较浮点数
	// 由于计算后的浮点数在内存中为一个近似值，所以不能直接比较
	// 应该相减，小于一个固定范围视为相等（范围根据业务来）
	double money1 = 1.2;
	double money2 = 1.2;
	// 可以执行
	if ( money1 == money2 ) {
	System.out.println("money1与money2 金额相等!");
	}
	double money3;
	money3 = 0.4 * 3; // 实质上可能是1.200000000001
	// 计算相差绝对值，是否小于固定范围
	if ( Math.abs(money1 - money3) <= 0.001 ) {
	System.out.printlnk("money1与money3 金额相等!");
	}

	}
	}

	public class CharDetail{
	public static void main(String[] args){
	// 一般使用
	char c1 = 'a';
	char c2 = 98;
	char c3 = 'a' + 2;
	// 输出
	System.out.println(c1);
	System.out.println(c2);
	System.out.println(c3);
	// =====> 输出数字
	System.out.println((int)c1);

	// 1. Char两个字符表示，对应的编码方式为unicode
	// 2. Char在内部以数字存储：
	// a -(通过编码方式)-> 97 -> 内存
	// 3. 读取的时候会，自动将数字装换成编码方式中对应的字符
	// 内存 -> 97 -(通过编码方式)-> a
	// 补充一下字符编码
	// ASCII 8bit表示，128个字符（0~127）
	// unicode 中英文都为2字节
	// UTF-8 (1~6个字节) 大小可动态变化，英文1字节中文3字节
	// ----------- 一个字符（即'a'或'中'）可以有多个字节
	}
	}

	// char -> int -> long -> float -> double
	// 2 4 8 4 8
	// byte -> short -> int -> long -> float -> double
	// 1 2 4 8 4 8

	// 类型转换
	public class AutoConvert{
	public static void main(String[] args) {
	// 1. ======= 低精度可以转换成高精度
	// char -> int -> long -> float -> double
	// 2 4 8 4 8
	// byte -> short -> int -> long -> float -> double
	// 1 2 4 8 4 8
	int a = 'a';
	double b = 80;
	System.out.println(a); // 97
	System.out.println(b); // 80.0

	// 2. =========== 多种类型运算时，先转化成最大的
	int a2 = 10;
	// float b2 = a2 + 1.1; // 不可以，因为1.1为double
	double b2 = a2 + 1.1;
	System.out.println(b2);

	// 3. =========== ( byte, short ) 不可以与 char 之间相互转化
	// 按照我的理解，byte 和 short 虽然有1字节和2字节大小，但是为有符号的数字
	// 所以不能让byte short 和 char之间进行转化

	/*
	byte c3 = 1;
	short s3 = 2;
	char char3 = c3;

	*/
	// 4. =========== 低精度往高精度转化，不行
	// int a4 = 1.1;
	// !! 但是 byte short 会先判断数值大小，才赋值，所以可以直接使用 1 2 3........
	byte b4 = 1;
	// !! 如果用int的话不行, 它先判断类型
	int ab4 = 2;
	// byte b44 = ab4;
	short s4 = 1;

	// 5. byte short 和 char 之间虽然不能转化，但是这三者之间可以进行运算，结果提升为int
	byte b5 = 2;
	short s5 = 1;
	char c5 = 11;

	int result5 = b5 + s5; // byte + short
	System.out.println(result5); // 3
	int result6 = b5 + c5; // byte + char;
	System.out.println(result6); // 13
	int result7 = s5 + c5; // short + char;
	System.out.println(result7); // 12

	// !!! 与自身运算也是int
	int result8 = b5 + b5; // byte + byte => int
	// short char 也是这样
	System.out.println(result8); // 4

	byte num1 = 1;
	short num2 = 2;
	int num3 = 123;
	float num4 = 1.234F;
	double num5 = num1 + num2 + num3 + num4; // => float 转化成 double

	System.out.println(num5);

	// 6. ========= boolean 不转化为数字
	// !! 就行强制转化也不行
	/*
	boolean boo6 = true;
	int i6 = (int)boo5;
	int i6 = boo5;
	*/

	}
	}

	// 高精度 -> 低精度：需要强制类型转化

	public class ForceConvert{
	public static void main(String[] args){
	int a = (int)2201.2; // 精度丢失
	byte b = (byte)a; // 数据溢出

	System.out.println(a); // 2201
	System.out.println(b); // -103 数据溢出了
	System.out.println( (byte)127 ); // 不超出范围则不会溢出 (byte 1个字节 -127 ~ 127)
	}

	}

	public class ToString{

	public static void main(String[] args){
	// 其他类型 => String
	char c1 = 97;
	int i1 = 2;
	float f1 = 3.14F;
	boolean b1 = true;
	String s1 = c1 + "";
	String s2 = i1 + "";
	String s3 = f1 + "";
	String s4 = b1 + "";
	// a 2 3.14 true
	System.out.println( " " + s1 + " " + s2 + " " + s3 + " " + s4 );

	}
	}

	class ToOther{

	public static void main( String[] args ){
	// String => 其他类型
	// !! 通过基本类型的包装类调用 parseXxx方法即可
	// !! 属于面向对象内容

	// 注意Integer的写法
	String s1 = "123";

	int num1 = Integer.parseInt(s1);
	float num2 = Float.parseFloat(s1);
	short num3 = Short.parseShort(s1);
	// 其他的类推
	boolean b = Boolean.parseBoolean("true");
	System.out.println(num1);
	System.out.println(num2);
	System.out.println(num3);
	System.out.println(b);

	// !! 取字符
	System.out.println(s1.charAt(0));

	// !! 注意：可能不一定装换成功, 需要异常处理
	}
	}

	public class ArithmeticOperator{
	public static void main(String[] args){
	// 注意混合运算后的结果类型
	// +
	int a = 2;
	int b = 1;
	System.out.println(a + b); // 3

	// -
	System.out.println(a - b); // 1

	// *
	System.out.println(a * b); // 2
	// /
	System.out.println(a / b); // 2

	// ======= %
	// !! 取模运算公式
	// a % b = a - a / b * b
	System.out.println(10 % 3); // 1
	System.out.println(-10 % 3); // -1
	System.out.println(10 % -3); // 1
	System.out.println(-10 % -3); // -1

	// 总结一下：
	/*
	1. 正 % 正 = 正
	2. 负 % 正 = 负
	3. 正 % 负 = 正
	4. 负 % 负 = 负

	即第一个数为负数时，结果为负数
	!! 假如a为double时会：
	a % b = a - (int)a / b * b
	*/

	// ++ 和 --
	// i = j++ i = j-- : 先赋值再操作
	// i = ++j i = --j : 先操作再赋值
	// 总结，看变量在前面还是运算符在前面
	// 变量在前，则先取变量的值，则运算
	// 运算符在前，则先运算，再取值

	int i = 10;
	int j = i++;
	System.out.println("i++: i = " + i + " j = " + j);

	i = 10;
	j = ++i;
	System.out.println("++i: i = " + i + " j = " + j);

	// !! 自己使用++ -- 赋值时的规则
	// 会引用一个临时变量，保存数据
	int count = 1;
	count = count++;
	// 1. 返回count使用临时变量保存，即 temp = count
	// 2. 运算++, 即 count = count + 1
	// 3. 赋值给count, 用的是temp的数据： count = temp
	System.out.println(count); // 1

	count = ++count;
	// 1. 返回++使用临时变量保存
	// count = count + 1
	// temp = count
	// 2. 赋值给count，即 count = temp
	System.out.println(count); // 2
	}

	}

	public class RelationalOperator{
	public static void main(String[] args){
	System.out.println(1 == 1);
	System.out.println(1 != 1);
	System.out.println(1 < 2);
	System.out.println(1 > 2);
	System.out.println(1 <= 2);
	System.out.println(1 >= 2);
	boolean isInstance = "lczmx" instanceof String;
	System.out.println("\"lczmx\"为String子类: " + isInstance);
	}
	}

	public class LogicOperator{
	public static void main(String[] args){
	int a = 3;
	// 短路
	if (a < 2 && a++ > 10){}
	// 结果： a = 3
	System.out.println(a);

	// 逻辑
	if (a < 2 & a++ > 10){}
	// 结果： a = 4
	System.out.println(a);
	}
	}

	public class AssignOperator{
	public static void main(String[] args) {
	int n1 = 10;
	n1 += 4; // n1 = n1 + 4;
	System.out.println(n1); // 14

	n1 /= 3; // n1 = n1 /3;
	System.out.println(n1); // 4

	byte b = 3;
	b += 2; // 等价于 b = (byte)(b + 2);
	}
	}

	public class BitOperator{

	public static void main(String[] args){

	// 2 & 3
	/*
	2的原码 00000000 00000000 00000000 00000010
	3的原码 00000000 00000000 00000000 00000011
	补码相同
	& 00000000 00000000 00000000 00000010
	补码为正，原码相同
	2
	*/
	System.out.println(2 & 3);
	// ~-2

	/*
	-2的原码 10000000 00000000 00000000 00000010
	反码 11111111 11111111 11111111 11111101
	补码 11111111 11111111 11111111 11111110
	~ 00000000 00000000 00000000 00000001
	补码为正，原码相同
	1
	*/
	System.out.println(~-2);

	// ~2
	/*
	2的原码 00000000 00000000 00000000 00000010
	补码相同
	~ 11111111 11111111 11111111 11111101
	结果反码
	11111111 11111111 11111111 11111100
	结果原码 10000000 00000000 00000000 00000011
	-3
	*/
	System.out.println(~2);

	// 2\|3
	/*
	2的原码 00000000 00000000 00000000 00000010
	3的原码 00000000 00000000 00000000 00000011
	都为正数补码相同
	\| 00000000 00000000 00000000 00000011
	结果为正数
	3
	*/
	System.out.println(2\|3);

	// 2^3
	/*
	2的原码 00000000 00000000 00000000 00000010
	3的原码 00000000 00000000 00000000 00000011
	都为正数补码相同
	\| 00000000 00000000 00000000 00000001
	结果为正数
	1
	*/
	System.out.println(2^3);

	// 1 >> 2
	System.out.println(1 >> 2);
	/*
	00000001 => 000000000 => 1/2/2 = 0
	*/

	// 1 << 2
	/*
	00000001 => 000000100 => 122 = 4
	*/
	System.out.println(1 << 2);

	// 4 << 3
	/*
	00000100
	00100000
	=> 32
	=> 4 * 2 * 2 * 2 = 32
	!! 即我们无需写出位，可以直接*2或/2, 取整即可
	*/
	System.out.println(4 << 3);


	}
	}

	// 1. 导入，简单的文本扫描器
	import java.util.Scanner;

	public class ScannerIn{
	public static void main(String[] args) {
	// 2. 创建一个对象实例
	// 注意类型
	Scanner s = new Scanner(System.in);
	// 3. 打印提示
	System.out.println("请输入名字");
	// 4. 使用next等方法，接收用户输入
	String name = s.next(); // 字符串
	System.out.println("请输入年龄");
	int age = s.nextInt(); // int
	System.out.println("请输入工资");
	double salary = s.nextDouble(); // double
	// !! 输入类型不对时，会报错
	System.out.println("用户信息如下：");
	System.out.println("name=" + name + "; age=" + age + "; salary=" + salary);
	// 5. 这些方法，可以看文档：https://www.matools.com/file/manual/jdk_api_1.8_google/java/util/Scanner.html
	}
	}

__ __ ______ / // ) ) ( / / o / / '--// / -/ -/--__ _ / , __/ __/ _ _ _ /(__/___/ _/ (_)/ (_/_)(_(_/_(_/_(/_/ / /_

Java初步使用

第一个程序#

开发注意事项#

转义符号#

注释#

变量定义#

+号的使用#

基本数据类型#

类型转换#

自动类型转换#

强制类型转换#

与字符串的相互转换#

运算符#

算术运算符#

关系运算符#

逻辑运算符#

赋值运算符#

三元运算符#

位运算符#

运算符优先级#

输入输出#

进制#

定义方式#

十进制转其他进制#

其他进制转十进制#

二进制转八/十六进制#

八/十六进制转二进制#

原码反码补码#

流程控制#

分支控制#

if分支#

switch分支#

循环控制#

for循环#

while循环#

doWhile循环#

break和continue#

公告

最新随笔

我的标签

积分与排名

阅读排行榜

评论排行榜

推荐排行榜

____ / // ) ) ( / / o / / '--// / -/ -/-- _ / , / / _ _ _ /(/_/ _/ (_)/ (_/_)(_(_/_(_/_(/_/ / /_

	public class BinaryTest{
	public static void main(String[] args) {

	// 二进制
	int num1 = 0B10; // or 0b1234
	// 八进制
	int num2 = 010; // 0开头
	// 十进制
	int num3 = 10;
	// 十六进制
	int num4 = 0X10; // or 0xa
	System.out.println(num1); // 2
	System.out.println(num2); // 8
	System.out.println(num3); // 10
	System.out.println(num4); // 16
	}
	}

	public class DecimalToOther{
	public static void main(String[] args){
	int num1 = 123; // -> 2
	/*
	123 / 2 = 61 余 1
	61 / 2 = 30 余 1
	30 / 2 = 15 余 0
	15 / 2 = 7 余 1
	7 / 2 = 3 余 1
	3 / 2 = 1 余 1
	1
	*/
	// => 0b01111011
	// 记得补全八位

	int num2 = 679; // -> 8
	/*
	679 / 8 = 84 余 7
	84 / 8 = 10 余 4
	10 / 8 = 1 余 2
	1
	*/
	// => 01247

	int num3 = 8912; // ->16
	/*
	8912 / 16 = 557 余 0
	557 / 16 = 34 余 d (13)
	34 / 16 = 2 余 2
	2
	*/
	// => 0X22E0
	}
	}

	public class OtherToDecimal{
	int num1 = 0b110001100;
	// 0 * 2^0 + 0 * 2^1 + 1 * 2^2 + 1 * 2^3 + 0 * 2^4 + 0 * 2^5 + 0 * 2^6 + 12^7 + 12^8
	// = 0 + 0 + 4 + 8 + 0 + 0 + 0 + 128 + 256
	// = 396

	int num2 = 02456;
	// 6 * 8^0 + 5 * 8^1 + 4 * 8^2 + 2 * 8^3
	// = 6 + 40 + 256 + 1024
	// = 1326

	int num3 = 0xa45;
	// 5 * 16^0 + 4 * 16^1 + 10 * 16^2
	// = 5 + 64 + 2560
	// = 2629

	}

	public class BinaryToOther{

	public static void main(String[] args){
	int num1 = 0b11100101; // -> 8
	/*
	11 100 101
	3 4 5
	=>0345
	*/
	int num2 = 0b1110010110; // -> 16
	/*
	11 1001 0110
	3 9 6
	=>0x396
	*/
	}
	}

	public class OtherToBinary{

	public static void main(String[] args){
	int num1 = 01230;
	/*
	1230
	1(001) 2(010) 3(011) 0(000)
	=> 0b0000001010011000
	*/
	int num2 = 0xAB29
	/*
	AB29
	A(1010) B(1011) 2(0010) 9(1001)

	数值太大时只需要让8-当前值，等到小的值即可
	=> 0b1010101100101001
	*/
	}
	}

	import java.util.Scanner;
	public class TicketingSytem{
	public static void main(String[] args) {
	Scanner s = new Scanner(System.in);
	System.out.println("月份");
	int month = s.nextInt();
	System.out.println("年龄");
	byte yearOld = s.nextByte();

	if (month >= 4 && month <= 10){
	int price = 60;
	if (yearOld < 18){
	System.out.println(price / 2);
	}else if(yearOld > 60){
	System.out.println(price / 3);
	}else{
	System.out.println(price);
	}
	}else{
	if (yearOld > 18 && yearOld < 60){
	System.out.println(40);
	}else{
	System.out.println(20);
	}

	}

	}
	}

	switch (c){
	case 'a':
	System.out.println("星期一");
	break;
	default :
	System.out.println("未知");
	break;

	}

	/*
	1.
	使用switch把小写类型的char型转为大写（键盘输入）。只转换a,b,c,d,e.
	其它的输出"other"。
	2.
	对学生成绩大于60分的，输出"合格”。低于60分的，输出"不合格”。（注：输入
	的成绩不能大于100)，提示成绩/60
	3.
	根据用于指定月份，打印该月份所属的季节。3,4,5春季6,7,8夏季9,10,11
	秋季12,1,2冬季[课堂练习，提示使用穿透]
	*/
	import java.util.Scanner;

	public class SwitchExercise{
	public static void main(String[] args){

	// 1
	System.out.println("char>>>");
	Scanner scanner = new Scanner(System.in);
	char c = scanner.next().charAt(0);
	switch (c){
	case 'a':
	System.out.println('A');
	break;
	case 'b':
	System.out.println('B');
	break;
	case 'c':
	System.out.println('C');
	break;
	case 'd':
	System.out.println('D');
	break;
	case 'e':
	System.out.println('E');
	break;
	default:
	System.out.println("other");
	break;
	}
	// 2
	System.out.println("成绩>>>");
	double score = scanner.nextDouble();
	// [60, 100] => /60 = 1;
	// [0, 60) => /60 = 0;
	switch ( (int)score / 60 ){
	case 1:
	System.out.println("合格");
	break;
	case 0:
	System.out.println("不合格");
	break;
	default:
	System.out.println("异常数据");
	break;
	}

	// 3
	System.out.println("月份>>>");
	int month = scanner.nextInt();
	switch (month){
	case 3:
	case 4:
	case 5:
	System.out.println("春季");
	break;

	case 6:
	case 7:
	case 8:
	System.out.println("夏季");
	break;

	case 9:
	case 10:
	case 11:
	System.out.println("秋季");
	break;
	case 12:
	case 1:
	case 2:
	System.out.println("冬季");
	break;



	}


	}
	}

	public class For {
	public static void main(String[] args){
	// 1.打印1~100之间所有是9的倍数的整数，统计个数及总和
	int sum = 0, count = 0;
	int start = 1, end = 100;
	int t = 9; // 倍数
	for (int i = start; i <= end; i++){
	if (i % t == 0){
	sum += i;
	count++;
	// 81 90 99
	// 9 10 11
	}
	}
	System.out.println("sum: " + sum + " count: " + count);

	//打印
	/*
	0 + 5 = 5
	1 + 4 = 5
	2 + 3 = 5
	3 + 2 = 5
	4 + 1 = 5
	5 + 0 = 5
	*/
	int total = 5;
	for (int i=0; i<= total; i++){
	int temp = total - i;
	System.out.println(i + " + " + temp + " = " + total);
	}

	}
	}


	public class Demo{
	public static void main(String[] args){
	int arr[] = {1,2,3};
	/**
	*增强for
	*/
	for(int num : arr){
	System.out.println(num);
	}
	}
	}