java中横杠替换空 java中的横杠和箭头

2.上机练习，所有的学习都不能作假
3.危机感满满
4.day2学习上传
String 存在与双引号中的若干个字符 "hello"  
char   字符'h' 'l'
类名：大驼峰
subline的快捷键：main pl
idea快捷键：psvm main sout
idea 集成开发环境

数据类型：
8种基本类型：byte short int long float double char boolean 
引用类型：String  类 接口 数组

转义字符\' \n \" \t \\

学习千万不要眼高手低，哪怕是最简单的东西都是有学习的意义的

   

public static void main(String[] args) {
        System.out.println("ab"+"cd");
        String str1 = "ab";
        String str2 = "cd";
        System.out.println(str1+str2);        //abcd
        System.out.println(10+str1+str2);    //10abcd
        System.out.println(10+20+str1+str2);//30abcd
        System.out.println(str1+str2+10+20);//abcd1020
        String ret1 = 10+str1+str2;            
        String ret2 = 10+20+str1+str2;
        String ret3 = str1+str2+10+20;
        System.out.println(ret1);
        System.out.println(ret2);
        System.out.println(ret3);
    }

任何类型的数据和字符串进行拼接结果就是一个字符串
字符串中的+号就是拼接的意思

public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println("a = " + a + " b = " + b);
        System.out.println("a+b="+(a+b));    //a+b=30
        System.out.println(10+""+20);        //1020
    }

变量：成员变量：实例成员变量 静态成员变量（类变量） 类内部，方法的外部
      局部变量：一般实在方法内部的变量
变量的作用域：变量的范围

一个变量只能包含数字字母下划线美元符
数字不能开头
不推荐下划线$开头
不要使用拼音
小驼峰 见名知意

字面值常量：10 20 1.0F true "abc"
final修饰的量为常量: final int A = 10;常量在使用前必须进行初始化
   

public static void main8(String[] args) {
        byte b = 10;    //-128 --- 127
        System.out.println(b);
    }
    public static void main7(String[] args) {
        int a = 1;
        boolean b = (boolean) a;//错误
        boolean c = true;
        int d = (int)c;         //错误
    }
    public static void main6(String[] args) {
        int a = 10;
        long l = 11;    //long b = a; //把小类型给大类型，隐式类型转换
        a = (int)l;

        double d = a;
        int c = (int)d;

        float f = a;
        int c2 = (int)f;

    }

大的数据类型给小的数据类型要进行强制类型转换
显示类型转换，把小类型给大类型 隐式类型转换
强制类型转换不是光看字节大小决定的，例如float 和 int 之间的类型转换
boole和int之间不能进行相互转换的，boolean类型中有true 和false两种值
如果需要把范围大的类型赋值给范围小的，需要强制类型转换，但是可能精度丢失
将一个字面值常量进行复制的时候，java会自动针对数字范围进行检查

public static void main(String[] args) {
        int a = 10;
        long b = 20;
        //int c = a + b;//报错是因为编译器自动进行类型提升，受限会把a提升为long类型，然后和b进行运算，结果为long类型
        long c = a + b;
        long c = (int)(a+b);

    }

数值提升问题：

public static void main(String[] args) {
        byte a = 1;
        byte b = 2;
        byte c = a + b ;//错误，因为a和b都是一个字节，计算机在处理小于一个自己的数的时候，会把小于四个字节的提升为4个字节再进行运算
        byte c = 1 + 2 ;//不会报错，是因为byte d = 3
        //byte c = (byte)a+b
        System.out.println(c);
    }

CPU按照4个字节去从内存中读写数据的，为了硬件式实现方便，byte short 一般都会提升为4个字节的类型
常量是在程序编译的时候就知道这个地方是几了
变量是在程序运行的时候才会去取这个数据

不同类型的数据混合运算，范围小的会提升为范围大的
对于short byte这种4个字节小的类型，会先提升为4个字节int再运算

int转换为String类型
  public static void main(String[] args) {
        //int转换为字符串
        int a = 10;
        String str1 = a +"";
        System.out.println(str1);
        String str2 = String.valueOf(a);
        System.out.println(str2);
    }

String转换为int
 public static void main(String[] args) {
        String s = "10";
        int num = Integer.valueOf(s);
        System.out.println(s);
    }

进行转换的时候需要进行的是拿到包装类，进行转换

变量+运算符=表达式

public static void main13(String[] args) {
        int a = 1;
        int b = 2;
        System.out.println(a / b);//结果为0
        /*int c = 10;
        int d = 0;
        System.out.println(c/d);  //报错，错误类型为算数异常，除零异常，*/
    }

取模运算

public static void main(String[] args) {
        int a = 10;
        int b = 3;
        System.out.println(a%b);//1
        System.out.println(11.5%2.0);//1.5  //百分号取余可以求小数
        System.out.println(-10 % -3);//-1
        System.out.println(-10 % 3);//-1
        System.out.println(10 % -3);//1
    }

public static void main(String[] args) {
        short s = 1;
       // s = s + 1;编译会报错，因为转化为int转化为了short
        s +=  1;//帮你进行强制类型转换
        System.out.println(s);
    }
    public static void main15(String[] args) {
        int a = 10;
        a += 1;
        a = a + 1;
        System.out.println(a);
    }

 

public static void main(String[] args) {
        int a = 10;
        ++a;//后置++
        a++;
        //int b = a++; 11 先使用后++
        //int b = ++a; 10 先++后使用
        System.out.println(a);
    }此结论适用于-- --

关系运算符的返回值要么是true要么是false
 

public static void main(String[] args) {
        int a = 1;
        int b = 2;
        System.out.println(a == b); //false
        System.out.println(a != b);//true
        System.out.println(a > b);//false
        System.out.println(a < b);//true
        System.out.println(a >= b);//false
        System.out.println(a <= b);//true
    }

逻辑运算符
&&  只有前后两个表达式都为真的时候，整体才为真，短路，如果表达式1为假，就不会执行表达式2了
||     或者 逻辑或表达式1||表达式2只要有一个为真的时候，那么整体为真，短路如果表达式1为真了，那就不执行表示式2了
！  后面跟布尔表达式  ！true =false !false = true

   

public static void main20(String[] args) {
        int a = 110;
        int b = 20;
        //System.out.println(!a < b);编译报错，后面只能是boolean表达式
        System.out.println(!(a<b));//编译不报错
    }

不推荐  & |

public static void main(String[] args) {
        System.out.println(10 > 20 && 10 / 0 ==0);
        System.out.println(10 > 20 || 10 / 0 ==0);
        //System.out.println(10 > 20 & 10 / 0 ==0);  //非短路会报错
        //System.out.println(10 > 20 | 10 / 0 ==0);
    }

按位& |  ~  
&如果对应位有0，则这一结果就是0
|如果有1就是1，其余都是0
^异或一样的位置上就是0不一样的位置上就为1 
0^n=n
n^n=0
~ 0-->1 1-->0

二进制转十六进制：4位放一起转为相应的十六进制
二进制转八进制： 3位数一起转为相应的八进制

移位运算符：<< >> >>>
<< 相当于乘法,左移一位，左移不管正数负数右侧补0，相当于乘法，*2
>>  前面补符号位，相当于除法，右移以为相当于除以2的一次放，右移两位相当于除以2的平方
 -1： 1111 1111 >> 1111 1111 -1
>>>无符号右移,不管符号位是0还是1统一补0  1111 1111 >>> 0111 1111
没有无符号左移没有
移动负数位或者移动位数过大都是没有意义的

关键字不能作为变量

顺序结构
选择分支结构if-esle switch
switch 的参数 
可以做switch参数的基本类型：char byte short int
能做参数的特殊类型： 枚举类型 字符串类型
不能做switch参数的进本类型：float double long boolean
循环结构