Java-笔记2

/*
标识符的使用
1.标识符：凡是自己可以起名字的地方都叫标识符。
   比如：类名、变量名、方法名、接口名、包名...

2.标识符的命名规则：--> 如果不遵守如下的规则，编译不通过！需要大家严格遵守

> 由26个英文字母大小写，0-9 ，_或 $ 组成  
> 数字不可以开头。
> 不可以使用关键字和保留字，但能包含关键字和保留字。
> Java中严格区分大小写，长度无限制。
> 标识符不能包含空格。

3. Java中的名称命名规范： --->如果不遵守如下的规范，编译可以通过！建议大家遵守

包名：多单词组成时所有字母都小写：xxxyyyzzz
类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ

4.
注意1：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。
注意2：java采用unicode字符集，因此标识符也可以使用汉字声明，但是不建议使用。 


*/
class IdentifierTest{

    public static void main(String[] args){
        
        //int myNumber = 1001;
        //System.out.println(myNumber);
        int mynumber = 1002;
        System.out.println(mynumber);

        int 学号 = 1003;
        System.out.println(学号);
        
    
    }


}

class Hello1_${

}
//class 1Hello{
//}
class staticpublic{
}
class Static{
}

class User{
}

class Account{
}

/*
变量的使用
1. java定义变量的格式：数据类型 变量名 = 变量值;

2. 说明：
   ① 变量必须先声明，后使用
   ② 变量都定义在其作用域内。在作用域内，它是有效的。换句话说，出了作用域，就失效了
   ③ 同一个作用域内，不可以声明两个同名的变量

*/
class VariableTest {
    public static void main(String[] args) {
        //变量的定义
        int myAge = 12;
        //变量的使用
        System.out.println(myAge);
        
        //编译错误：使用myNumber之前并未定义过myNumber
        //System.out.println(myNumber);

        //变量的声明
        int myNumber;
        
        //编译错误：使用myNumber之前并未赋值过myNumber
        //System.out.println(myNumber);

        //变量的赋值
        myNumber = 1001;
        //编译不通过
        //System.out.println(myClass);

        //不可以在同一个作用域内定义同名的变量
        //int myAge = 22;
        
    }

    public void method(){
        int myClass = 1;
    }
}

//class VariableTest {}//逆向思维，反证法

 

/*
Java定义的数据类型

一、变量按照数据类型来分：

    基本数据类型：
        整型：byte  short  int  long
        浮点型：float  double
        字符型：char
        布尔型：boolean


    引用数据类型：
        类(class)
        接口(interface)
        数组(array)


二、变量在类中声明的位置：
        成员变量  vs  局部变量
*/
class VariableTest1 {
    public static void main(String[] args) {
        //1. 整型：byte(1字节=8bit)  short(2字节)  int(4字节)  long(8字节)
        //① byte范围：-128 ~ 127
        //
        byte b1 = 12;
        byte b2 = -128;
        //b2 = 128;//编译不通过
        System.out.println(b1);
        System.out.println(b2);
        // ② 声明long型变量，必须以"l"或"L"结尾
        // ③ 通常，定义整型变量时，使用int型。
        short s1 = 128;
        int i1 = 1234;
        long l1 = 3414234324L;
        System.out.println(l1);

        //2. 浮点型：float(4字节)  double(8字节)
        //① 浮点型，表示带小数点的数值
        //② float表示数值的范围比long还大

        double d1 = 123.3;
        System.out.println(d1 + 1);
        //③ 定义float类型变量时，变量要以"f"或"F"结尾
        float f1 = 12.3F;
        System.out.println(f1);
        //④ 通常，定义浮点型变量时，使用double型。

        //3. 字符型：char (1字符=2字节)
        //① 定义char型变量，通常使用一对'',内部只能写一个字符
        char c1 = 'a';
        //编译不通过
        //c1 = 'AB';
        System.out.println(c1);

        char c2 = '1';
        char c3 = '中';
        char c4 = 'ス';
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);

        //② 表示方式：1.声明一个字符 2.转义字符 3.直接使用 Unicode 值来表示字符型常量
        char c5 = '
';//换行符
        c5 = '	';//制表符
        System.out.print("hello" + c5);
        System.out.println("world");

        char c6 = 'u0043';
        System.out.println(c6);

        //4.布尔型：boolean
        //① 只能取两个值之一：true 、 false
        //② 常常在条件判断、循环结构中使用
        boolean bb1 = true;
        System.out.println(bb1);

        boolean isMarried = true;
        if(isMarried){
            System.out.println("你就不能参加"单身"party了！\n很遗憾");
        }else{
            System.out.println("你可以多谈谈女朋友！");
        }

    }
}

/*
基本数据类型之间的运算规则：

前提：这里讨论只是7种基本数据类型变量间的运算。不包含boolean类型的。

1. 自动类型提升：
    结论：当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。
    byte 、char 、short --> int --> long --> float --> double 

    特别的：当byte、char、short三种类型的变量做运算时，结果为int型
    
2. 强制类型转换：见VariableTest3.java


说明：此时的容量大小指的是，表示数的范围的大和小。比如：float容量要大于long的容量
*/
class VariableTest2 {
    public static void main(String[] args) {
        
        byte b1 = 2;
        int i1 = 129;
        //编译不通过
        //byte b2 = b1 + i1;
        int i2 = b1 + i1;
        long l1 = b1 + i1;
        System.out.println(i2);

        float f = b1 + i1;
        System.out.println(f);

        short s1 = 123;
        double d1 = s1;
        System.out.println(d1);//123.0

        //***************特别地*********************
        char c1 = 'a';//97
        int i3 = 10;
        int i4 = c1 + i3;
        System.out.println(i4);

        short s2 = 10;
        //char c2  = c1 + s2;//编译不通过

        byte b2 = 10;
        //char c3 = c1 + b2;//编译不通过

        //short s3 = b2 + s2;//编译不通过

        //short s4 = b1 + b2;//编译不通过
        //****************************************

    }
}

/* 结果
------------------------------
131
131.0
123.0
107
------------------------------
*/

/*
强制类型转换：自动类型提升运算的逆运算。
1.需要使用强转符：()
2.注意点：强制类型转换，可能导致精度损失。



*/
class VariableTest3 {
    public static void main(String[] args) {
        
        double d1 = 12.9;
        //精度损失举例1
        int i1 = (int)d1;//截断操作
        System.out.println(i1);
        
        //没有精度损失
        long l1 = 123;
        short s2 = (short)l1;
        
        //精度损失举例2
        int i2 = 128;
        byte b = (byte)i2;
        System.out.println(b);//-128

    }
}

/* 结果
------------------------------
12
-128
------------------------------
*/

class VariableTest4 {
    public static void main(String[] args) {
        
        //1.编码情况1：
        long l = 123213;
        System.out.println(l);
        //编译失败：过大的整数
        //long l1 = 21332423235234123;
        long l1 = 21332423235234123L;


        //****************
        //编译失败
        //float f1 = 12.3; #后面需要加上F
        float f1 = (float)12.3;


        //2.编码情况2：
        //整型常量，默认类型为int型
        //浮点型常量，默认类型为double型

        byte b = 12;
        //byte b1 = b + 1;//编译失败

        //float f1 = b + 12.3;//编译失败
        
    }
}

/* 结果
----------------------
123213
----------------------
*/

/*
String类型变量的使用
1. String属于引用数据类型,翻译为：字符串
2. 声明String类型变量时，使用一对""
3. String可以和8种基本数据类型变量做运算，且运算只能是连接运算：+
4. 运算的结果仍然是String类型

*/
class StringTest {
    public static void main(String[] args) {
        
        String s1 = "Hello World!";

        System.out.println(s1);

        String s2 = "a";
        String s3 = "";

        //char c = '';//编译不通过

        //***********************
        int number = 1001;
        String numberStr = "学号：";
        String info = numberStr + number;// +：连接运算
        boolean b1 = true;
        String info1 = info + b1;// +：连接运算
        System.out.println(info1);

        //***********************
        //练习1
        char c = 'a';//97   A:65
        int num = 10;
        String str = "hello";
        System.out.println(c + num + str);//107hello
        System.out.println(c + str + num);//ahello10
        System.out.println(c + (num + str));//a10hello
        System.out.println((c + num) + str);//107hello
        System.out.println(str + num + c);//hello10a

        //练习2
        //*    *
        System.out.println("*    *");
        System.out.println('*' + '	' + '*');
        System.out.println('*' + "	" + '*');
        System.out.println('*' + '	' + "*");
        System.out.println('*' + ('	' + "*"));


        //***********************

        //String str1 = 123;//编译不通过
        String str1 = 123 + "";
        System.out.println(str1);//"123"
        
        //int num1 = str1;
        //int num1 = (int)str1;//"123"

        int num1 = Integer.parseInt(str1);
        System.out.println(num1);//123
    }
}

/* 结果
--------------------------
Hello World!
学号：1001true
107hello
ahello10
a10hello
107hello
hello10a
*       *
93
*       *
51*
*       *
123
123
--------------------------
*/

/*
计算机中不同进制的使用说明

对于整数，有四种表示方式：
> 二进制(binary)：0,1 ，满2进1.以0b或0B开头。
> 十进制(decimal)：0-9 ，满10进1。
> 八进制(octal)：0-7 ，满8进1. 以数字0开头表示。
> 十六进制(hex)：0-9及A-F，满16进1. 以0x或0X开头表示。此处的A-F不区分大小写。
    如：0x21AF +1= 0X21B0



*/
class BinaryTest {
    public static void main(String[] args) {
        
        int num1 = 0b110;
        int num2 = 110;
        int num3 = 0127;
        int num4 = 0x110A;

        System.out.println("num1 = " + num1);
        System.out.println("num2 = " + num2);
        System.out.println("num3 = " + num3);
        System.out.println("num4 = " + num4);

    }
}

/* 结果
---------------
num1 = 6
num2 = 110
num3 = 87
num4 = 4362
---------------
*/