【趣学程序】java基础知识（一）

命名(起名)规则：    (1) 由字母、数字、下划线、$组成，不能以数字开头        注意:此处的字母还可以是中文,日文等,不建议使用中文;    (2) 大小写敏感（class A  和 class a 是两个类）    (3) 不得使用java中的关键字和保留字    (4) 建议不使用Java API中已存在类名作为自己的类名。
建议java程序中使用驼峰命名规则：    (1)类名首字母大写。（例：class Dog     class HelloWorld)    (2)方法名/变量名第一个单词全小写，其他单词首字母大写。        (例：int index = 0;  int fristIndex = 0;void getState(){})    (3)常量名称单词全部大写，单词之间用下划线分割。
        (例：final int SUCCESS_CODE = 200;)

变量的概念： 
   (1)占据着内存中的某一个存储区域;  
   (2)该区域有自己的名称（变量名）和类型（数据类型）; 
   (3)该区域的数据可以在同一类型范围内不断变化;

变量的定义格式：数据类型    变量名 =   初始化值；    int i   =   0;

整数型：    byte -> short -> int -> long 
整数型是一类代表整数值的类型。当需要代表一个整数的值时，可以根据需要从4 种类型中挑选合适的，如果没有特殊要求的话，一般选择int 类型。
按照上面的书写顺序，从左至右所表示的范围逐渐增大。
各个类型使用方式：    byte b = 10;    short s = 20;    int i = 100;    long l = 1000L;
浮点型(小数)：    float -> double
java默认浮点型为double,如需定义float类型的变量，后缀必须加 F 或者 f, 建议使用 F小数型是一类代表小数值的类型。当需要代表一个小数的值时，可以根据需要从以上2 种类型中挑选合适的。如果没有特殊要求，一般选择double类型。
各个类型使用方式：        float f = 0.5F;    double d = 1.5;
字符型(单个字符)：    char
    char c = 'a';    char c = '。';
布尔型:    boolean
注意：布尔型变量只有两个值：true(正确),false(错误)，经常用于条件判断
    boolean flag1 = true;    boolean flag2 = false;

向上转换(隐式类型转换)：
    整型，字符型，浮点型的数据在混合运算中相互转换，转换时遵循以下原则：    容量小的类型可自动转换为容量大的数据类型；
        byte,short,char → int → long → float → double        byte，short，char之间不会相互转换，他们在计算时首先会转换为int类型。        boolean 类型是不可以转换为其他基本数据类型。        Eg：        int i = 123;        long l = i; //自动转换，不需强转        float f = 3.14F;        double d = f;
向下转换(显式类型转换/强制类型转换)：
    整型，字符型，浮点型的数据在混合运算中相互转换，转换时遵循以下原则：    容量小的类型可自动转换为容量大的数据类型；        byte,short,char → int → long → float → double        byte，short，char之间不会相互转换，他们在计算时首先会转换为int类型。        boolean 类型是不可以转换为其他基本数据类型。        Eg：        long l = 123L;        int i = (int) l;//必须强转        double d = 3.14;        float f = (float) d;

byte，short，char之间不会相互转换，他们在计算时首先会转换为int类型。
//下列程序的执行结果是什么public class DataTypeDemo {    public static void main(String[] args) {
        byte a = 1;        byte b = 1;
        byte c = a + b;    }}
答案：编译时期异常报错
应将程序修改为：int c = a + b; 或者  byte c = (byte)(a+b);

public class Demo2 {
 public static void main(String[] args) {  
       int i;//局部变量没有赋初始值，编译时期就会报错 
             System.out.println(i);  
  }
}

public class Demo2 { 
 static int i;//这里是成员变量，程序会默认给初始值，所以程序不会报错 
    public static void main(String[] args) { 
        System.out.println(i);  
     }
}

    int addRes = a + b;//结果：12    int dRes = a - b;//结果：8    int cRes = a * b;//结果：20    int ddRes = a / b;//结果：5    int aaRes = a % b;//结果：0    int resubb = 10 % 3;//结果：1

    %  是取模运算，即求余数运算。10 % 3 (10 对 3 取模)结果为1

    int c = 100;    int d = 200;
    c += d;//该等式等价于 c = c + d;    //输出300    System.out.println(c);
    c -= d;//该等式等价于 c = c - d;    //输出100    System.out.println(c);
    c *= d;//该等式等价于 c = c * d;    //输出 20000    System.out.println(c);
    c /= d;//该等式等价于 c = c / d;    //100    System.out.println(c);
    c %= d;//该等式等价于 c = c % d;    //100    System.out.println(c);

//考点：赋值运算符，默认进行了强制类型转换
// 题目：下面的程序有问题吗？byte a  = 10;byte b = 10;
a  = a + b;a += b;

// 答案:a = a + b;  a + b 在计算的时候会转为int类型进行计算，所以编译报错：a = (byte)(a + b);a += b; 赋值运算符，默认进行了强制类型转换

        int e = 10;        int f = 20;
        // 结果false        System.out.println(e > f);// e 大于    f  是真的吗        // 结果false        System.out.println(e >= f);// e 大于等于    f  是真的吗        //结果true        System.out.println(e < f);// e 小于    f  是真的吗        //结果true        System.out.println(e <= f);// e 小于等于     f  是真的吗        //结果true        System.out.println(e != f);// e 不等于 f  是真的吗

        int h = 10;        int i = 20;
        //结果false        //从左往右运算 (h>i)是真的吗？结果是false  遇到&& 直接返回false不会走右边的表达式，形成短路        System.out.println((h > i) && (h != 10));        //结果false        //从左往右运算 (h<i)是真的吗？结果是true 遇到&&="" 判断右侧表达式，右侧表达式为true则返回true，false则返回false<="" span="">        System.out.println((h < i) && (h != 10));        //从左往右运算 (h>i)是真的吗？结果是false  遇到 || 判断右侧表达式是否为真，如果是真的返回true,false 则返回false        //结果true        System.out.println((h > i) || (h == 10));        //从左往右运算 (h<i)是真的吗？结果是true 遇到="" ||="" 直接返回true="" 不会运行右边的表达式="" 形成短路<="" span="">        //结果true        System.out.println((h < i) || (h != 10));
        //结果false        //从左往右运算 (h>i)是真的吗？结果是false  遇到 & 返回false,但是执行右侧表达式        System.out.println((h > i) & (h != 10));        //结果false        //从左往右运算 (h<i)是真的吗？结果是true 遇到&="" 判断右侧表达式，右侧表达式为true则返回true，false则返回false<="" span="">        System.out.println((h < i) & (h != 10));        //从左往右运算 (h>i)是真的吗？结果是false  遇到 | 判断右侧表达式是否为真，如果是真的返回true,false 则返回false        //结果true        System.out.println((h > i) | (h == 10));        //从左往右运算 (h<i)是真的吗？结果是true 遇到="" |="" 直接返回true="" 不会运行右边的表达式<="" span="">        //结果true        System.out.println((h < i) | (h != 10));
        //结果 true  ! 是非运算符  如果表达式结果为true，前面加上 ! 将取反。原本为true，结果为false。反之        System.out.println(!(h != 10));
        // ^ 异或运算  结论：一个数对一个数异或两次还等于原数        //10        System.out.println(h ^ i ^ i);        //true        System.out.println((h ^ i ^ i) == h);

通过异或运算交换两个变量的值(不使用第三方变量交换两个数的值)

int a = 10;int b = 20;
//要求输出结果为；a = 20; b = 10;
a = a ^ b;b = a ^ b;a = a ^ b;
/*解释：a = a ^ b;b = (a ^ b) ^ b;上一步已经让 b = a;
a = (a ^ b) ^ a;
最终将 a = b;

*/

    &：与运算    |：或运算    ^：异或运算    `：取反运算    >>：右移    <<：左移    <<<：无符号左移    >>>：无符号右移


    暂略，与二进制有关。