java知识点

//----------------------------------------------------------------------------------------
//public 公共的
//class 定义类关键字
//DT_01 类名,自定义命名
//创建一个公共的类,类名是DT_01
//一个java文件中,可以有很多class,但是 public class 只能有一个,并且 public class 的类名 必须和文件名一致
//-------------------------------------------------------------------------------------------------------------
public class Y1 {
    // 入口方法,程序的入口
        // 可以理解为 java的执行 只会执行main方法
        // public 公共的
        // static 静态的
        // void 没有返回值
        // main 方法名
        // (String[] args) 参数列表
        // main方法为固定写法,哪里也不能变
        // 唯一可以修改的地方是 args  写成什么都可以,需要符合命名规则
    public static void main(String[] args) {
        //控制台打印
 

// 创建一个8bit的空间,并给空间取名为b1,然后把2保存到该空间中
       byte b1=127;
       short s1=-32768;
    // long类型的值必须使用L或l结尾,不区分大小写,建议大写
       long i1=2147483647L;
    // float 需要F/f结尾,不区分大小写
       float f1=3.5F;
    // double 需要D/d结尾,不区分大小写,另外也可以省略
       double d1=55.6;
    // 布尔型的值,只有true和false
       boolean flag=true;
    // 字符型 使用单引号表示,并且有且只有一个字符
    // ASCII是 字符和整数直接的映射
     char c1='!';
             c1='王';
    // 把c1转换为int类型
    int c2=(int)c1;
    System.out.println(c2);
 // char 也是16位,范围 0~65535 因为不需要负数
    System.out.println((char)(45555));
 // unnicode 编码,\ u 4位十六进制整型值 0~f
    char c3 ='\u4e00';
    c3='\u9fa5';
    System.out.println(c3);

  // 布尔型 不能参与转换
        // 低精度到高精度 可以自动类型转换
        // 高精度 到低精度 需要强制类型转换
        byte b1 = 13;
        short s1 = b1;
        int i1 = s1;
        long l1 = i1;
        // 浮点型 采用科学计数法进行存储
        // 所以  float的32位  可存储的数据量远大于 long的64位
        System.out.println(Long.MAX_VALUE);
        // 9223372036854775807
        float f1 = 92233720368547758072231231241231231212.2F;
        System.out.println(f1);
        f1=l1;
        double d1 =f1;
        // byte --> short --> int --> long --> float --> double  是自动类型转换,反之则需要强制类型转换
        //     char --> int --> long --> float --> double
        short s2 = 129;
        // 高到低,需要强制类型转换,  (类型)
        // 强制类型转换有可能损失精度,导致数据不正确
        byte b2 = (byte) s2;
        System.out.println(b2);
        // -----
        System.out.println(Integer.toBinaryString(-265));
        // -265 1111111011110111
        // 
        // 1111111011110111  -265二进制
        //  当不考虑符号位时  对应的是 65271
        // 正数转换为char是,是忽略负数的,会把响应负数的二进制转换为对应的正数,然后再进行ASCII码
    char c1 =(char)-265;
    System.out.println(c1);
    System.out.println((char)65271);
    char c2 ='a';
    int i3 =c2;
    System.out.println(i3);

// 布尔型 不能参与运算
        byte b1 = 2;
        int i1 = 10;
        long l1 = 11L;
        // 当进行多类型混合运算时,结果为参与运算的最大类型
        long result = b1 + i1 + l1;
        // 当混合运算类型 只出现了 byte short int char 四种类型时
        // 任意一种或多种进行运算,结果一定是int类型 (可以理解为,混合运算,结果为参与运算的最大类型,但最低也是int类型)
        byte b2 = 1;
        byte b3 = 1;
        int b4 = b2 + b3;
        char c1 = 'a';
        int c2 = c1 + b2;
        System.out.println(c2); 

    // 常量:生命周期中,值不能修改,但是可以复用
        final int i = 2;
        // i = 3;
        // 字面量,占用临时空间存储,数字 默认是int
        // 并且不能复用,只能临时使用一次,由于没有找到的路径,所以压根也不能修改
    System.out.println(123);

// 局部变量
        int i = 2;
        // 局部变量调用,在方法中,直接写变量名调用,方法外 调用不了
        System.out.println(i);
        // 静态变量调用,使用类名.静态变量名,需要考虑权限修饰符
        System.out.println(Y6.a);
        // 如果在类中调用当前类的静态变量,类名也可以省略
        System.out.println(a);
        // 创建对象
        Y6 obj = new Y6();
        System.out.println(obj.b);

public class Y7 {
    static int a ;
    static double d;
    static char c;
    static boolean b;
    static  Y7 xY7 ;
    

    public static void main(String[] args) {
        // 局部变量,不赋值不能使用,没有默认自
                int i;
                // System.out.println(i);
                // 整数 默认 0
                System.out.println(a);
                // 小数 默认 0.0
                System.out.println(d);
                // 字符型 默认 \u0000
                System.out.println(c);
                // 布尔型 默认值 false
                System.out.println(b);
                // 引用类型默认值 null
                System.out.println(xY7);

 public class Y8 {
    static int a = 2;
    public static void main(String[] args) {
        int a = 3;
        // 同名后,优先使用局部变量
        System.out.println(a);
        // 如何区分同名的局部变量和静态变量呢?  类名
        System.out.println(Y8.a);       

    System.out.println(10 + 3);
        System.out.println(10 - 3);
        System.out.println(10 * 3);
        // 由于都是整数,所以结果也是整数 3
        System.out.println(10 / 3);
        // 由于3.0是double 所以结果是 double 3.3333335
        System.out.println(10 / 3.0);
        // 由于10和3都是整数,所以得 3 , 由于 1.0是double,所以 得 4.0
        System.out.println(10 / 3 + 1.0);
        // 余数
        System.out.println(10 % 3);
        // =====================
        // ++ : 自身+1, 把值取出来+1在放回去 , i++ 就等于 i=i+1
        int i = 10;
        i++;
        ++i;
        // 如果 i++ 和 ++i 单独出现,则没有区别, 直接自身+1 完事
        System.out.println(i);
        // 如果 在混合运算中 i++ 和 ++i 就有区别了
        // i++ 先赋值 后 + 1(i的值,是+1之前的值)
        // ++i 先+1 后赋值 (i的值,是+1之后的值)
        i = 10;
        i = i++;
        // i = i++; i = 10
        // i = 10++; i = 10
        // i = 10; i = 11
        // i = 10;
        // ++ -- 属于一元运算, 一元优先级大于二元
        i = i++ + i;
        // i = i++ + i; i = 10
        // i = 10++ + i; i = 10
        // i = 10 + i; i = 11
        // i = 10 + 11; i = 11
        // i = 21; i = 11
        // i = 21;

        i = 10;
        i = ++i + i;
        System.out.println(i);

        int x = 3;
        int y = x + x++ + ++x + ++x + x++ + x;
        // int y = 3 + x++ + ++x + ++x + x++ +x; x = 3;
        // int y = 3 + 3 + ++x + ++x + x++ +x; x = 4;
        // int y = 3 + 3 + 5 + ++x + x++ +x; x = 5;
        // int y = 3 + 3 + 5 + 6 + x++ +x; x = 6;
        // int y = 3 + 3 + 5 + 6 + 6 +x; x = 7;
        // int y = 3 + 3 + 5 + 6 + 6 +7; x = 7;
        System.out.println(y);
        System.out.println(x);
        int a = 10;
        a = a++ + ++a + (a++ - 10) * a;
        // a = 48; a = 13
        System.out.println(a);

}