java基础

注释

1. 单行注释： 只能注释一行文字 用//
2. 多行注释：可以注释一段文字 用/* 内容 */

标识符

1. 关键字
   

2. 标识符注意点

   

数据类型

1. 强类型语言

   要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用

2. 弱类型语言

​ Long类型要在数字后面加L ， float类型要在数字后面加F ，

什么是字节？

数据类型扩展

public class Demo1 {
    public static void main(String[] args) {
        //1.浮点数扩展  银行业务怎么表示
        //BigDecimal  数学工具类

        //2.字符扩展
        char c1='a';
        char c2='国';
        System.out.println(c1);

        System.out.println((int)c1); //强制类型转换
        System.out.println(c2);
        System.out.println((int)c2);//强制类型转换
        //所有的字符本质还是数字
        /*
        编码 Unicode 表：（97 =a  65=A） 2字节   0-65536  Excel  2  16 = 65536
        U0000    UFFFF
         */
        char c3='\u0061';
        System.out.println(c3);//a

        //3.转义字符
        // \t 制表符
        //  \n 换行
        System.out.println("hello  \n world");
        //4.布尔值扩展

        boolean flag =true;
  /*      if(flag == true){

        }  这俩个形式相同
        if(flag){

        }*/
    }
}

转义字符

public class Main {
    public static void main(String[] args) {
        //  \t  对齐
        System.out.println("北京\t重庆\t西安");
        //  \n 换行
        System.out.println("北京\n重庆\n西安");
        //  \\  一个\
        System.out.println("北京\\重庆\\西安");
        //   \\\\   两个\
        System.out.println("北京\\\\重庆\\\\西安");
        //  \"  一个“
        System.out.println("老师说：\"学习好,努力呀\"");
        //   \'  一个‘
        System.out.println("老师说：\'学习好,努力呀\'");
         System.out.println("abcde\r123");  	//	123de 		1取代a，2取代b，3取代c，de不变
        //  \r\n 回车换行
        System.out.println("我的祖国\r\n中国");
    }
}
 /*  北京 重庆 西安
        北京
        重庆
        西安
      北京\重庆\西安
      北京\\重庆\\西安
      老师说："学习好,努力呀"
      老师说：'学习好,努力呀'
      123de
      我的祖国
      中国
      */

类型转换

1. 由于Java是强类型语言，所以要进行游戏运算的时候的，需要用到类型转换

​ 低-----------------------------------------------------高

​ byte,short,char ->int->long->float->double

2. 运算中，不同类型的数据先转化为用一类型，再进行运算。

public class Demo2 {
    public static void main(String[] args) {
        int i=128;
        byte b=(byte) i;   //内存溢出
        //强制转换   (类型)变量名   高--低
        //自动转换   低--高
        System.out.println(i);
        System.out.println(b);
        /*
        1.不能对布尔值进行转换
        2.不能把对象美学转换为不相干的类型
        3.在把高容量转换到低容量的时候，强制转换
        4.转换的时候可能存在内存溢出，或者精度问题。
         */
        System.out.println("------------");
        System.out.println((int)23.47);
        System.out.println((int)45.86f);

        System.out.println("------------");
        char c='a';
        int d =c+1;
        System.out.println(d);
        System.out.println((char)d);
/*  运行结果  
128
-128
------------
23
45
------------
98
b
*/

        
        //操作比较大的数的时候，注意溢出问题
        //JDK新特性，数字之间可以用下划线分割
        int money =10_0000_0000;
        int years =20;
        int total =money*years;  //-1474836480，计算的时候存在溢出了
        System.out.println(total);

        long total1 = money*years;

        System.out.println(total1);//默认是int，转换之前已经存在问题
        long total12 = money*(long)years;  //先把一个数转换为long
        System.out.println(total12);
        //运行结果 
       // -1474836480
      //  -1474836480
        //20000000000

    }
}

变量

简单代码

public class Main {
 static int a=0;   //类变量
 String str ="hello world";  //实例变量
 public void method(){}
    int i=0; //局部变量
}

复杂代码

public class Demo4 {
    //类变量 static
    static  double   salary =2500;
   //属性：变量
    /*
      实例变量：从属于对象；如果不进行初始化，这个类型的默认值 0   0.0
      布尔值：默认是false
      除了基本类型，其余的默认都是null
     */
    String name;
    int age;
    //main方法
    public static void main(String[] args) {
           //局部变量:必须声明和初始化值
         int i=10;
        System.out.println(i);
         //变量类型  变量名字 = new  Demo04();
        Demo4 demo=new Demo4();
        System.out.println(demo.age);
        System.out.println(demo.name);
        System.out.println(salary);
    }
    //其他方法
    public  void add(){}

}

/*运行结果
10
        0
        null
        2500.0*/

变量的命名规范

1. ◆所有变量、方法、类名:见名知意

2. 类成员变量:首字母小写和驼峰原则: monthSalary除了第一个单词以外,后面的单词首字母大写 lastname lastName

   局部变量:首字母小写和驼峰原则

3. 常量:大写字母和下划线: MAX_ _VALUE

4. 类名:首字母大写和驼峰原则: Man, GoodMan

5. 方法名:首字母小写和驼峰原则: run(), runRun()

常量

public class Demo5 {
    /*
    常量：初始化后不能再改变值，不会变动的值；
    所谓常量可以理解成一种特殊的变量，它的值被设定后，再程序运行过程中不允许被改变
    final  常量名=值；
    final double  pi=3.14；
     */
    //修饰符，不存在先后顺序
    static  final  double pi=3.14;
    final  static  double p1=3.14;

    public static void main(String[] args) {
        System.out.println(pi);
        System.out.println(p1);
    }
}
/*
3.14
3.14
*/

运算符

基本运算符

package operator;
public class Demo1 {
    public static void main(String[] args) {
        // 二元运算符
        int a = 10;
        int b = 20;
        int c = 10;
        int d = 10;
        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/(float)b);

        long e=1231231231231231232L;
        int f =123;
        short g=10;
        byte l = 8;
        System.out.println(e+f+g+l);//long
        System.out.println(f+g+l);//int
        System.out.println(g+l);//int

        //关系运算符返回的结果：正确，错误
        int aa =10;
        int bb =10;
        int cc =10;
        //取余，模运算
        System.out.println(cc%aa);// c/a 21/10=2...1

        System.out.println(aa>bb);
        System.out.println(aa<bb);
        System.out.println(aa==bb);
        System.out.println(aa!=bb);
    }
}
/*
        30
        -10
        200
        0.5
        1231231231231231373
        141
        18
        false
        false
        true
        false
        */

自增自减运算符

package operator;
public class Demo2 {
    public static void main(String[] args) {
        //++ -- 自增，自减  一元运算符
        int a=3;
        int b=a++;//执行完这行代码后，先给b赋值，然后自增
       //a=a+1;
        System.out.println(a);
        //a=a+1;

        int c =++a;//执行完这行代码前，先自增，然后给b赋值
        System.out.println(c);

        //幂运算 2^3  2*2*2  =8   
      double pow=  Math.pow(2,3);
        System.out.println(pow);

    }
}

/*4
5
8.0*/

逻辑运算符

package operator;
public class Demo3 {
    public static void main(String[] args) {
        boolean a =true;
        boolean b =false;

        System.out.println("a&&b:"+(a&&b));//逻辑与运算，两个变量都为真，结果才为true
        System.out.println("a||b:"+(a||b));//逻辑与运算，两个变量有一个为真，结果为true
        System.out.println("!(a&&b):"+(!(a&&b)));//如果是真，则结果为假，如果是假，则结果为真

        //短路运算
        int c =5;
        boolean d=(c<4)&&(c++<4);//c>4 条件一为假，不会运行后面条件
        System.out.println(d);
        System.out.println(c);
    }
}
/*
a&&b:false
a||b:true
!(a&&b):true
false
5
 */

位运算符（>> << )

package operator;

public class Demo4 {
    public static void main(String[] args) {
        /*
        2*8  =16 2*2*2*2
        效率极高！！！
      左移  <<  *2
      右移 >>  /2
        0000  0000     0
        0000  0001     1
        0000  0010     2
        0000  0011     3
        0000  0100     4
        0000  1000     8
        0001  0000     16
         */
        System.out.println(2<<3);
    }
}

扩展赋值运算符

package operator;
public class Demo5 {
    public static void main(String[] args) {
        int a=19;
        int b=19;
        a+=b;
        System.out.println(a);
        a-=b;
        System.out.println(a);
        //字符串连接符  +，String (面试题）
        System.out.println(""+a+b); //字符串在前面 后面会拼接
        System.out.println(a+b+"");   //字符串在后边 不影响前边数字
    }
}
/*
38
19
1919
38
 */

三元运算符

package operator;

public class Demo6 {
    public static void main(String[] args) {
        //x ? y : z
        //如果x==true，则结果为y，否则结果为z

        int s =50;
        String type = s<60 ?"不及格":"及格";//必须掌握
        System.out.println(type);
        int sc =80;
        String type1 = sc<60 ?"不及格":"及格";//必须掌握
        System.out.println(type1);

    }
}
/*
不及格
及格
 */

运算符的优先级