关于java:Java-SE复习

JDK(java 开发工具包)

JDK 包含 JRE,JRE 包含 JVM.
JDK 的环境变量配置:
PATH: %JAVA_HOME%/bin;

变量

标识符的命名规定
** 8 大根本类型
byte,short,int,long,float,double,boolean,char**
Scanner 工具类
`import java.util.Scanner;
Scanenr sc=new Scanner(System.in);
String name=sc.next();`
变量替换
`int a=c;
int b=a;
int c=b;`
根本类型的字面值
整数字面值是 int 类型
浮点数的字面值是 double 类型
字面值的后缀 lL fF dD
long g=100000000L;
float h=3.6F;
double s=3d;
根本类型的类型转换

// 小转大 --- 隐式转换
byte a = 10 ;
// 把右侧的小类型 byte 类型的 a, 转成左侧的大类型 long 类型的 b -- 能够间接转
long b = a ; 
// 大转小 --- 显式转换 double->int
double m = 9.9 ;
// 拿着右侧的大类型 double 类型的 m, 转成左侧的下类型 int 类型的 n -- 不能够间接转
// 解决方案是: 强转 / 显示转化 -- 加代码 --(小类型)
int n = (int)m ; 
// 小类型 long 大类型 float
// 小转大  -- 能够间接转
long x = 10;
float y = x;
// 大转小 -- 不能间接转, 须要强转
float o = 9.9F ;// 右侧的 9.9 字面值是 double, 非要变成 float 须要加后缀 F
long p = (long) o ;// 右侧的 o 是 float 类型是大类型. 给左侧的 plong 类型小类型赋值 --

运算规定

//1, 计算结果的数据类型，与最大类型统一
System.out.println(3/2); //int/int--> int  -- 1 
System.out.println(3d/2); //double/int --> double -- 1.5   

//2, byte,short,char 三种比 int 小的整数，运算时会先主动转换成 int
byte a = 1 ;
byte b = 2 ;
byte c = (byte) (a + b) ;
// 右侧曾经变成大类型 int 了, 给左侧的小类型, 不能够间接赋值 --- 须要强转 

//TODO 测试 short 或者 char 的景象, 同 byte...

//3, 计算：光速运行一年的长度是多少米
// 整数运算时, 曾经超出了 int 的范畴, 就会呈现溢出景象
// 解决方案就是, 把字面值是 int 类型, 加后缀 L 转成 long 类型.
System.out.println(30000000L*60*60*24*365);

//4, java 对于小数运算时会产生不准确的景象
System.out.println(1-0.8);//0.19999999999999996

//5, 小数运算时的非凡值
System.out.println(1.5/0);//Infinity
System.out.println(0/0.0);//NaN -- not a number

自增自减 ++ —

int a = 1;
// 符号在后, 先应用再变动
System.out.println(a++);//1

int b = 1;
// 符号在前, 先变动再应用
System.out.println(++b);//2
System.out.println(++b+a+b++);//3+2+3

// 自减
int c = 1;
// 符号在后, 先应用再变动
System.out.println(c--);//1

int d = 1;
// 符号在前, 先变动再应用
System.out.println(--d);//0

System.out.println(--d-d-d--);//-1-(-1)-(-1)

三元运算符 1 ? 2 : 3
— 运算后果可能是 2, 也可能是 3. 到底是谁? 由 1 决定.
– 当 1 的地位判断成立时, 后果就是 2
– 当 1 的地位判断不成立时, 后果就是 3

//1, 定义两个变量
int a = new Scanner(System.in).nextInt() ;
int b = new Scanner(System.in).nextInt() ;

//2, 比两个数里的大值
// 判断 a > b 成立, 就把 a 的值交给 max 保留. 否则就把 b 的值交给 max 保留.
int max = a > b ? a : b ;
System.out.println("两个数里的大值是:"+max);

//TODO 三个数里的大值?
int c = new Scanner(System.in).nextInt() ;
int res = max > c  ? max  : c ;
System.out.println("三个数里的大值是:"+res);

逻辑运算符: 后果是 boolean 值

• !(取反, 非真即假, 非假即真)

     -- &(逻辑与) -- 示意并且关系
         -- 1 & 2 , 想得到最终的后果是 true, 要求是:1 是 true 并且 2 是 true
     -- &&(双与 / 短路与)-- 示意并且关系 -- 高效
         -- 1 && 2 , 当 1 为 false 时, 后果早都注定了是 false,2 的代码就会被短路不必执行了, 提高效率
     -- |(逻辑或) -- 示意或者关系
         -- 1 | 2 , 想得到最终的后果是 true, 要求是:1 是 true 或者 2 是 true
     -- ||(双或 / 短路或) -- 示意或者关系 -- 高效
         -- 1 || 2 , 当 1 为 true 时, 后果早都注定了是 true,2 的代码就会被短路不必执行了, 提高效率
  

public class Test5_Runnian {public static void main(String[] args) {
        //1, 接管用户输出的年号
        int year = new Scanner(System.in).nextInt() ;
        
        String desc = "平年" ;// 给变量设置默认值
        //2, 判断这个年是不是平年 -- 如果满足条件, 就改成平年
        //if(判断条件){干活}
        //if(判断条件 1 || 判断条件 2){改成平年}
        //if(小条件 1 &&  小条件 2  || 判断条件 2){改成平年}
        //if(能被 4 整除 &&  不能被 100 整除  || 能被 400 整除){改成平年}
        if(year % 4 == 0 && year % 100 != 0 || year % 400 == 0){desc = "平年" ;}
        System.out.println(year+"年是"+desc);
    }
}