注释 标识符 关键字

注释

• 单行注释 // 注释一行文字

• 多行注释 /* */ 注释一段文字

• 文档注释 /** * */

关键字

标识符

java中所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。

注意

• 所有的标识符的首字符都只能以字母，美元符（$），或者下划线 开始

• 首字符之后可以是字母，美元符（$），下划线或数字的任意字符的组合

• 不能使用关键字作为变量名或方法名

• 标识符大小写敏感

• 可以使用中文命名，但一般不建议这样使用，不要用拼音

  public class essentialgrommar {
      public static void main(String[] args) {
          String a="Hello";
          int b= 10;
          System.out.println(a);
          System.out.println(b);
      }
  }
  

数据类型

• 强类型语言：所有变量必须先定义后才能使用

  基本类型（八大）

import java.util.Arrays;

public class essentialgrommar {
    //八大基本数据类型

    //整数类型
    byte num2 = 20;
    short num3 = 30;
    int num1 = 10; //最常用
    long num4 = 40L; //long类型要在数值后面加L 用小写L也可 但容易被视作1 所以统一用L

    //浮点类型(小数)
    float num5 = 50.1F; //float类型要在数值后面加F
    double num6 = 1.2358654455556;

    //字符类型(一个字)
    char num7 = ‘中‘ //如果是‘中国’会报错

    //布尔值
  boolean flag1 = ture;
    boolean flag2 = false;
}

拓展

//整数拓展(  ) 二进制0b 十进制 八进制0 十六进制0x
	//二进制01；十进制0-9；八进制0-7，十六进制0-9 A-F
int i = 100;
int i2 = 0b100; //二
int i3 =0100; //八
int i4 =0x100; //十六
System.out.println(i);
System.out.println(i2);
System.out.println(i3);
System.out.println(i4);
	//结果：100	4	64	256

//浮点拓展（浮点有限 离散 舍入误差 大约）
	//典型
float a = 0.1f;
double b = 0.1;
System.out.println(a==b); //双等号 判断两者是否相等
    //结果错误
float c = 1223544846145616.265165f;
float d = c+1;
System.out.println(c==d);
    //结果正确

//字符拓展（所有的字符本质都是数字）
	//强制转换 字符→数字 Unicode编码表（字符和数字对应表）
 				char c1 = ‘中‘;
        char c2 = ‘国‘;
        char c3 = ‘a‘;  //97
        int c4 = c3+1;   //98
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);
        System.out.println((int)c1);//强制转换 低-->高
      System.out.println((int)c2);
        System.out.println((int)c3);
        System.out.println((char)c4);   //b
	//结果：中 国 a 20013 22269 97
//以上中文及字母对应的数字就是 Unicode编码

转义字符

public class test {
    public static void main(String[] args){
System.out.println("hello\nworld"); //换行
System.out.println("==================");
System.out.println("hello\rworld"); //
System.out.println("==================")
System.out.println("hello\tworld"); //


    }
}
//输出结果：
//hello
//world
//==================
//world
//==================
//hello	world

引用类型

• 类

• 接口

• 数组

类型转换

注意：运算中，不同类型的数据先转化为同一类型，再进行运算。

强制类型转换

• 由高-->低

自动类型转换

• 由低-->高

package Operator;

import java.util.Arrays;

public class test {
    public static void main(String[] args) {
        int a = 186;
        byte b = (byte) a;  //强制转换
        double c = a;   //自动转换
        float d = a;    //自动转换
        float e = (float) c;    //强制转换
        System.out.println(a);
        System.out.println("int-->byte:"+b);    //结果-70 186超过了byte取值范围 内存溢出
        System.out.println("int-->double:"+c);
        System.out.println("int-->float:"+d);
        System.out.println("double-->float:"+e);
        //结果
        /*
       186
       int-->byte:-70
       int-->double:186.0
       int-->float:186.0
       double-->float:186.0
         */
    }
}

注意

• 不能对布尔值转换
• 不能把对象类型转换成不相干的类型
• 高容量转低容量，强制转换
• 转换的时候可能存在内存溢出，或者精度问题

精度问题

• 即小数会四舍五入为整数 出现精度问题

package Operator;

import java.util.Arrays;

public class test {
    public static void main(String[] args) {
        System.out.println((int)35.2F);
        System.out.println((int)55.3);
        //结果 可见精度出现问题
        /*
        35
        55
         */
    }
}

溢出问题

• 操作比较大的数字的时候 要注意。比如 int最多22亿

package Operator;

import java.util.Arrays;

public class test {
    public static void main(String[] args) {
        //JDK新特性，大数字可以用下划线分割
        int money = 1000000000;
        int money1 = 10_0000_0000;  //两种形式结果一致
        int year = 20;
        int total = money*year;
        long total1 = money*year;
        long total2 = (long)money*year;
        System.out.println(money);
        System.out.println(money1);
        System.out.println(total);  //不会得出正确的数据 因为内存溢出
        System.out.println(total1); //结果仍然错误 因为在转为long之前 int已经内存溢出
        System.out.println(total2); //正确
       
    }
}

变量 常量

变量

• 定义变量：数据类型 变量名

• 每个变量都有类型，类型可以是基本类型，也可以是引用类型

• 变量名必须是合法的标识符

• 变量声明是一条完整的语句，，每一个声明必须以分号结束

作用域

• 类变量
  • 必须有static

package Operator;

import java.util.Arrays;

public class test {
    static long salary = 2500;  //去掉static 报错

    public static void main(String[] args) {
        System.out.println(salary);
    }
}

• 实例变量：类里面 方法外面（定义变量）；如果不自行初始化，输出这个类型的默认值

  • 默认值：数值类型（整数型 浮点型）默认值是0 0.0；布尔型false；除了基本类型 其余默认值都是null；

package Operator;

import java.util.Arrays;

public class test {
    //实例变量
    byte a;
    short b;
    int c;
    long d;
    float e;
    double f;
    boolean g;
    char h;
    String i;

    public static void main(String[] args) {
        test variable = new test();	//目前了解即可
        System.out.println("byte:"+variable.a);
        System.out.println("short:"+variable.b);
        System.out.println("int:"+variable.c);
        System.out.println("long:"+variable.d);
        System.out.println("float:"+variable.e);
        System.out.println("double:"+variable.f);
        System.out.println("boolean:"+variable.g);
        System.out.println("char:"+variable.h);
        System.out.println("string:"+variable.i);
      //结果
      /*
      byte:0
			short:0
			int:0
			long:0
			float:0.0
			double:0.0
			boolean:false
			char: 
			string:null
      */
    }

}

• 局部变量
  • 方法里面 必须声明和初始值。前文在方法中所定义的变量 均是局部变量

常量

• 常量可以被理解成一种特殊的变量，它的值被设定后，在程序运行中不会改变
• 常量名一般使用大写字符

package Operator;
import java.util.Arrays;
public class test {

    public static void main(String[] args) {
    final int Code = 3;
    System.out.println(Code);
    }
}

注意

运算符

• 算数运算符：+，-，*，/，%(取余 模运算)，++，--
• 赋值运算符：=
• 关系运算符：>，<，>=，<=，==，!=(不等于)
• 逻辑运算符：&&，||(或)，!(非)
• 位运算符：&，|，^，~，>>，<<，>>>
• 条件运算符：?，:
• 扩展赋值运算符：+=，-=，*=，/=

算数运算符

• 算数运算符：+，-，*，/，%(取余 模运算)，++，--

package Operator;

import java.util.Arrays;

public class test {


    public static void main(String[] args) {
        int a = 20;
        int b = 15;
        int c = a++;
        int d = ++a;
        int e = a--;
        int f = --a;
        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/b);    //取整了 并不是正确的数字
        System.out.println((float)a/b); //输出正确结果
        System.out.println(a%b);    //取余 模运算
        System.out.println("a++:"+ a++);  //++自增 等于它本身 不过该语句结束后a会加1
        System.out.println("a:"+ a);
        System.out.println("++a:"+ ++a);  //等于a+1 由于上一语句结束后a=21 故结果为22
        System.out.println("a:"+ a);
        System.out.println("a--:"+ a--);  //--自减 等于它本身 即22 不够该语句结束后a会减1
        System.out.println("a:"+ a);
        System.out.println("--a:"+ --a);  //等于a-1 由于上一语句结束后a=21 故结果为20
      
      //结果
      /*
      35
			5
			300
			1
			1.3333334
			5
			a++:20
			a:21
			++a:22
			a:22
			a--:22
			a:21
			--a:20
      */



    }
}

关系运算符

• 关系运算符：>，<，>=，<=，==，!=(不等于)

package Operator;

import java.util.Arrays;

public class test {


    public static void main(String[] args) {
       int a = 15;
       int b = 52;
        System.out.println(a>b);
        System.out.println(a>=b);
        System.out.println(a<b);
        System.out.println(a<=b);
        System.out.println(a==b);
        System.out.println(a!=b);
    }
}

逻辑运算符

• boolean类型的变量
• 逻辑运算符：&&，||(或)，!(非)

package Operator;

import java.util.Arrays;

public class test {


    public static void main(String[] args) {
       // && || !
        boolean a = false;
        boolean b = true;
        boolean c = false;
        boolean d = true;
        System.out.println("a&&b:"+(a&&b);
        System.out.println("b&&d:"+(b&&d));   //均为真 结果真；否则结果假
        System.out.println("a||b:"+(a||b));
        System.out.println("(b||d):"+(b||d));
        System.out.println("a||c:"+(a||c));   //至少一个为真 结果真
        System.out.println("!(a&&b):"+(!(a&&b));    //取反
        //注意：
        /*
        && 输出结果时 如果第一个为假，结果直接返回假，不会执行后面的语句
        || 输出结果时 如果第一个为真，结果直接返回真，不会执行后面的语句
         */
        int e = 5;
        boolean f = (e<4)&&(e++<4); //显然第一个假
        boolean g = (e>4)||(e++<4); //显然第一个真
        System.out.println(f);
        System.out.println(e);  //如果执行了后一个语句 e等于6 但结果为5 未执行
        System.out.println(g);
        System.out.println(e);  //如果执行了后一个语句 e等于6 但结果为5 未执行


    }
}

位运算符

• 位运算符：&，|，^，~，>>，<<，>>>

package Operator;

import java.util.Arrays;

public class test {
    public static void main(String[] args) {
     /*
        a = 0011 1100   //60
        b = 0000 1101   //13
        a&b = 0000 1100 都为1 则1；否则是0 //12
        a|b = 0011 1101 都是0 则是0；否则1 //
        a^b = 0011 0001 相同则为0 否则1   //
        ~b = 1111 0010  取反
        << 数字*2
        >> 数字/2
        0000 0001   1
        0000 0010   2
        0000 0100   4
        0000 1000   8
        0001 0000   16
      */
        //验算上述结论
        int a = 60;
        int b = 13;
        System.out.println("a&b:"+ (a&b));
        System.out.println("a|b:"+ (a|b));
        System.out.println("a^b:"+ (a^b));
        System.out.println("~b:"+ (~b));
        System.out.println(2<<1);   //4
        System.out.println(2<<2);   //8
        System.out.println(2<<3);   //16
        System.out.println(2<<4);   //32
        System.out.println(16>>1);  //8
        /*
        a&b:12
        a|b:61
        a^b:49
        ~b:-14
         */
    }
}

条件运算符

• 条件运算符：?，:

package Operator;

import java.util.Arrays;

public class test {


    public static void main(String[] args) {
        //x?y:z
        //如果x真，则为y，否则就是z
        int score = 75;
        String x = score<60 ? "不及格" : "及格";
        System.out.println(x);

        int a = 1;
        int b = 2;
        int c;
        c = (a>b) ? (a+b) : (a-b);
        System.out.println(c);
    }


}

扩展赋值运算符

• 扩展赋值运算符：+=，-=，*=，/=

package Operator;

import java.util.Arrays;

public class test {


    public static void main(String[] args) {
        int a = 21;
        int b = 12;
        int c = 1;
        int d = 2;
        a += b; //a=a+b
        b -= d; //b=b-d
        c *= b; //c=c*b
        System.out.println("a:"+a);
        System.out.println("b:"+b);
        System.out.println("c:"+c);
        /*
        a:33
        b:10
        c:10
         */

    }

}

优先级（）

运算符优先级口诀

包机制

• 包就相当于文件夹
• 一般将公司域名倒置作为包名

java基础

原文：https://www.cnblogs.com/zhanzhiwen/p/14399085.html