基本语法笔记补充

Java基础语法

注释、标识符、关键字

注释

项目结构复杂，需要用到注释
注释不执行，写给写代码的人看
保持写注释的好习惯
平时写代码，注释毕竟要规范
注释的种类：
- 单行注释
- 多行注释
- 文档注释

标识符

关键字:

Java所有的组成部分都需要名字。类名、变量名一级方法名都被成为标识符

注意点：

所有标识符都因该以字母（A-Z或者a-z），美元符（$）、下划线（_）开始
首字符之后可以是字母、美元符、下划线或者数字的任何字符
不能使用关键字作为变量名或使用方法
标识符大小写敏感的
可以使用中文命名，但不建议使用

数据类型

强类型语言

变量的使用严格规定，所有变量必须先定义后才能使用

String：字符串

int：数字

Java 的数据类型两大类

基本类型：
引用类型

reference:引用

什么是字节

（bit）：计算机内部最小的储存单位
字节（byte）：数据处理的基本单位，用B表示。
1B=8bit
字符：计算机使用的字母、数字、字和符号。

数据类型拓展

整数拓展：进制
- 二进制：0b
- 八进制：0
- 十进制
- 十六进制：0x （0~9 A~F）
浮点数拓展
- 银行业务怎么表示：（float&double有问题不能用）BIgDecimal 数学工具类
- ```
float f=0.1f;
double d=1.0/10;
System.out.println(f==d);//比较f&d是否一样
```
- ```
float d1=65623456321f;
float d2=d1+1;
System.out.println(d1==d2);//比d1&d2是否一样
```
- 原因：float 是有限的，离散的，有一个舍入误差，大约，接近但不等于。
- 最好完全使用浮点数进行比较。

3.字符拓展

```
char c1='a';
char c2='中';
```

强制转换：

char c1='a';
char c2='中';
System.out.println(c1);
System.out.println((int)c1);//强制将字符转换成数字
System.out.println(c2);
System.out.println((int)c2);//强制将字符转换成数字

所有的字符本质还是数字
编码 Unicode 表占2字节总共有65536（2的16次方）（Excel也是65536）

例如：a=97 A=65

范围：U0000 UFFFF

char c3='\u0061';
System.out.println(c3);

转义字符
- \t:制表符 \n:换行 很多，需要自学

布尔值扩展

boolean flag = true;
if(flag==true);//新手这样写
if(flag);//老手这样写，两个意思一样。

类型转换

Java是强类型语言，所以进行有些运算需要类型转换

byte，short，char，int，long，float，double

低==================================高

public class Demo04 {
    public static void main(String[] args) {
        int i=128;
        byte b=(byte)i;//内存溢出情况，超出了byte的范围。
        System.out.println(i);
        System.out.println(b);
    }
}

强制类型转换需要（类型）变量名高→低，类似于上面的程序

自动转换低到高。例如：

public class Demo04 {
    public static void main(String[] args) {
        int i=128;
        double b=i;
        System.out.println(i);
        System.out.println(b);
    }
}

注意点

不能对布尔值进行转换
不能把对象类型转换为不相干的类型
不能高容量转换到低容量的时候，强制转换；否则自动转换。

转换的时候可能存在溢出或者精度的问题

public class Demo04 {
    public static void main(String[] args) {
       System.out.println((int)23.7);
        System.out.println((int)-45.89f);
    }
}

5. char字符也可以自动转换，

public class Demo04 {
    public static void main(String[] args) {
        char c='a';
        int d=c+1;
       System.out.println(d);
        System.out.println((char)d);
    }
}

再次强调溢出的问题，

public class Demo05 {
    public static void main(String[] args) {
        //操作比较大的数的时候，注意溢出问题
        //JDK7新特性，数字之间可以用_分割
        int money = 10_0000_0000;
        int years=20;
        int total=money*years;//int的范围是正负21亿，输出结果溢出
        long total2=money*years;//计算结果已经溢出，给total2转换为long也没用
        long total3=(long)money*years;//这才是正确的输出结果
        System.out.println(total);
        System.out.println(total2);
        System.out.println(total3);

    }
}

变量、常量

变量

变量：就是可以变化的量
Java是强类型语言，每个变量都必须声明其类型
Java变量是程序中最基本的储存单元，其要素包括变量名，变量类型和作用域
数据类型变量名=值；可以使用逗号隔开来声明多个同类型变量
注意事项：
- 每个变量都有类型，类型可以是基本类型，也可以是引用类型。
- 变量必须是是合法的标识符
- 变量声明是一条完整的语句，因此每个声明都必须以分号结束。

public class Demo06 {
    public static void main(String[] args) {
        int a=1;
        int b=2;
        int c=3;
        String name="ouronghui";
        char x='X';
        double pi=3.14;
        System.out.println();
    }
}

变量作用域

类变量

public class Demo08 {
    static  double salary=2500;
    //实例变量：从属于对象；如果不进行初始化，这个类型的默认值
    //所有的数值类型初始化值是0或0.0，字符串初始化是u0000 布尔值默认是false
    //除了基本类型其余的默认值都null
    String name;
    int age;

    public static void main(String[] args) {
        int i=10;
        System.out.println(i);
        //变量类型 变量名字=new Demo08;
     Demo08 demo08= new Demo08();
        System.out.println(demo08.age);
        System.out.println(demo08.name);
        //类变量 static
        System.out.println(salary);

    }

实例变量

public class Demo08 {
    //实例变量：从属于对象；如果不进行初始化，这个类型的默认值
    //所有的数值类型初始化值是0或0.0，字符串初始化是u0000 布尔值默认是false
    //除了基本类型其余的默认值都null
    String name;
    int age;

    public static void main(String[] args) {
        int i=10;
        System.out.println(i);
        //变量类型 变量名字=new Demo08;
     Demo08 demo08= new Demo08();
        System.out.println(demo08.age);
        System.out.println(demo08.name);
        
    }

}

局部变量
```
public class Demo07 {
    //属性“：变量
    //main 方法
    public static void main(String[] args) {
//局部变量；必须声明和初始化值
        int i=10;
        System.out.println(i);
    }//局部变量只在当个括号内有效
    //其他方法
    public viod add(){

    }
}
```
常量

用 final 关键词来定常量/

Constant 初始化（initialize）后不能再改变值！不会变动的值。

常量可以理解成特殊的变量，他的值被设定后，程序运行中不能被改变。

常量名一般使用大写字符。
```
public class Demo09 {
    //修饰符，不存在先后顺序
    static final double PI=3.14;
    public static void main(String[] args) {

        System.out.println(PI);
    }
}
```
变量的命名规范
- 所有的变量、方法、类名：见名知意
- 类成员变量：除了第一个单词意外首字母大写，（驼峰原则）
- 局部变量：除了第一个单词意外首字母大写，（驼峰原则）
- 常量：全部大写
- 类名：首字母大写和驼峰原则
- 方法名：首字母小写和驼峰原则

运算符

算数运算符：+，-，*，/，%，++，--

赋值运算符： =

关系运算符：<,>,>=,>=,==,!=,instanceof

逻辑运算符：与（&&），非(!)，或（||），

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

条件运算符 ? :

扩展运算符:+=,-=,*=,/=

package operator;

public class Demo01 {
    public static void main(String[] args) {
        //二元运算符
        //ctrl+D:复制当前行到下一行
        int a=10;
        int b=20;
        int c=25;
        int d=30;
        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/(double)b);

package operator;

public class Demo02 {
    public static void main(String[] args) {
        long a=121321345454545L;
        int b=123;
        short c=10;
        byte d=8;
        System.out.println(a+b+c+d);//long
        System.out.println(b+c+d);//int
        System.out.println(c+d);//int
    }
}

package operator;

public class Demo03 {
    public static void main(String[] args) {
        //关系运算符返回的结果：正确，错误 布尔值
        //if
        int a=10;
        int b=20;
        int c=21;
        System.out.println(a>b);
        System.out.println(a<b);
        System.out.println(a==b);
        System.out.println(a!=b);
        System.out.println(c%a);//c/a  21/10=2....1
    }
}

运算拓展知识：

package operator;

public class Demo04 {
    public static void main(String[] args) {
        //++ -- 自增 ，自减 一元运算符
        int a=3;
        int b=a++;//a++ a=a+1，执行当前代码后，先给b赋值，再自增
        //相当于在执行这条代码后自增
        System.out.println(a);
        int c=++a;//++a a=a+1 执行时机不同 执行当前代码前，先自增
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        //幂运算 2^3 =2*2*2=8
      double pow= Math.pow(3,3);
        System.out.println(pow);
    }
}

逻辑运算：

package operator;
//逻辑运算符
public class Demo05 {
    public static void main(String[] args) {
        //与（and）或（or）非（取反）
        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);
        System.out.println(d);
        System.out.println(c);
    }
}

位运算例子：

package operator;

public class Demo06 {
    public static void main(String[] args) {
        /*
        A=0011 1100
        B=0000 1101
        A&B 0000 1100
        A|B 0011 1101
        A^B 0011 0001
        ~B  1111 0010

        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(16>>2);//运算效率极高

    }
}

扩展运算符：

package operator;

public class Demo07 {
    public static void main(String[] args) {
        int a=10;
        int b=20;
        a+=b;//a=a+b
        a-=b;//a=a-b
        System.out.println(a);
        //字符串连接符  +
        System.out.println(a+b);
        System.out.println(""+a+b);
        System.out.println(a+b+""+a+b);
    }
}

条件运算符：

package operator;

public class Demo08 {
    public static void main(String[] args) {
        //x ? y : z
        //如果x==true,则结果为y,否则为z
        int score=80;
       String type= score<60?"不及格":"及格";
        System.out.println(type);
    }
}

posted @ 2020-08-07 16:01 欧荣辉阅读(83) 评论(0) 收藏举报

刷新页面返回顶部

欧荣辉