Java基础语法

Chuck Guo

于 2021-02-05 18:22:19 发布

阅读量78

点赞数

本文链接：https://blog.csdn.net/chuckguo/article/details/113701783

版权

Java基础语法

1.注释

养成使用注释，有助于自己或是别人看得懂代码的意思（注释是不会被执行的）
Java中有三种注释,所有注释不能添加到代码的前面，新的一行或是代码后面

单行注释

//注释

多行注释

/*
注释
*/

文档注释//javaDoc

/**
注释
*/

标识符

关键字(不能使用关键字命名)


abstract	assert	boolean	break	byte
case	catch	char	class	const
continue	default	do	double	else
enum	extends	final	finally	float
for	goto	if	implements	import
instanceof	int	interface	long	native
new	package	private	protected	public
return	strictfp	short	static	super
switch	synchronized	this	throw	throws
transient	try	void	volatile	while

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

标识符注意点

关键字不能命名
所有的标识符都应该以字母（A-Z或者a-z）,美元符（$）/或者下划线（_）开始
首字符之后可是字母（A-Z或者a-z）,美元符（$）、下划线（_）或数字任何字符组合
大小写十分敏感
不建议中文或是拼音命名，最好是英文为主

数据类型

强类型语言

要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用（也就是每个东西必须要命名了之后才可以拿来使用）

弱类型语音

可以随便玩，不是很安全

Java的数据类型分为两大类

基本类型（primitive type）

1.数值类型

byte占一个字节范围：-128-127
short占2个字节范围：-32768-32767
int占4个字节范围：-2147483648-2147483647（常用）
long占8个字节范围：-9223372036854775808-9223372036854775807（long后面要加个L）

2.浮点类型（小数点）

float占4个字节 （float后面要加个F）
double占8个字节(常用)

3.字符类型char占2个字节（只能是一个字母、符号、或是文字）

4.boolean类型：占1位其值只有true和false两个

5.String类型

   public class demo03 {
       public static void main(String[] args) {
           //八大基本数据类型
   
           //整数
           byte num2 = 20;//-128-127
           short num3 = 30;//-32768-32767
           int num1 = 10; //最常用 -2147483648-2147483647
           long num4 = 30L;//-9223372036854775808-9223372036854775807(long后面要加个L）
   
           //浮点数（小数）
           float num5 = 50.1F;//float后面需要加个F
           double num6 = 3.141587644446464;//(常用这个)
   
           //字符
           char name ='国';//（只能是一个字母、符号、或是文字）
           String namea = "中国";//这不是一个关键字，是一个class
   
           //布尔值：是与否，二选一
           boolean flag = true;
           //boolean flag = false;
       }
   }

引用类型（reference type）
1. 类
2. 接口
3. 数组

什么是字节
- 位（bit）：是计算机内部数据存储的最小单位，11001100是一个八位二进制数。
- 字节（byte）：是计算机中数据处理的基本单位，习惯上用大写的B来表示。
- 1B（byte，字节）=8（bit，位）
- 字符：是指计算机中使用的字母，数字，字和符号
换算单位
- 1bit表示一位、一个数字
- 1Byte表示一个字节 1B=8b
- 1024B=1KB
- 1024KB=1M
- 1024M=1G

拓展

整数拓展

二进制（开头0b）
八进制（开头0）
十进制
十六进制（开头0x）

public class Demo4 {
    public static void main(String[] args) {
        //整数拓展 进制  二进制0b 八进制0  十进制  十六进制0x
        int i = 10;  //十进制
        int i2 = 010; //八进制0
        int i3 = 0x10; //十六进制0x 0~9 A~F
        System.out.println(i); //结果为10
        System.out.println(i2);//结果为8
        System.out.println(i3);//结果16
    }
}

浮点拓展（银行业务怎么表示）

float 是一个有限的小数点、离散的、会舍入误差、大约、接近但不等于
double 同上
精确的表示数字使用数字工具类BigDecimal
禁止用浮点数进行比较

public class Demo {
    public static void main(String[] args) {
        //银行业务表示钱或是一些精确的数字只能用数字工具类 BigDecimal
        //float 是一个有限的小数点，离散的，会舍入误差的、大约、接近但不等于
        //double
        //表示精确的数字一定不要使用浮点数进行比较
        float f = 0.1f;  //0.1
        double d = 1.0/10;  //0.1
        System.out.println(f==d); //false 否
        float d1 =2322345644567f;
        float d2 = d1 + 1; //d2明显比d1多了1但是结果却是相等的
        System.out.println(d1==d2);  //true 是
    }
}

字符拓展

所有的字符都会在Unicode编码表里代表着相应的数字，也就是所有的字符本质还是数字，一般都是从0-65536，（例如97=a，65=A）
字符是可以强制转换成数字的
Excel表格数值是有限的65536

public class Demo {
    public static void main(String[] args) {
        //所以的字符本质还是数字，每个字符都会对应编码表 Unicode的每一个数字，从0 - 65536 例如（97=a，65=A）U00000-UFFFF
        //所有字符其实可以强制转换成unicode中的对应数字
        char c1 = 'A';
        char c2 = '中';
        System.out.println(c1);
        System.out.println((int)c1);//强制转换 A等于65
        System.out.println(c2);
        System.out.println((int)c2);//强制转换 中等于20013
        char c3 = '\u0061';
        System.out.println(c3);//结果等于a

    }
}

转义字符拓展

转义字符是有个相对应的表格的例如（\t=中间有个tab一样的空格，\n=换行）可以去查询转义字符表

public class Demo {
    public static void main(String[] args) {
        //转义字符表
        // \t  =  tab空格
        // \n  =  换行
        System.out.println("Hello\nWorld");//换行
        System.out.println("Hello\tWorld");//tab空格

    }
}

布尔值拓展

less is more！代码要精简易读

public class Demo {
    public static void main(String[] args) {
        boolean flag = true;
        if (flag==true){执行内容} //如果flag是正确会执行内容，新手书写方式
        if (flag){执行内容}  //如果flag是正确会执行内容，新手书写方式
        //Less is More 代码要精简
    }
}

类型转换

由于java是强类型语言，所以要进行有些运算的时候，需要用到类型转换
优先级byte-short-char-int-long-float-double
运算中，不同类型的数据先转换为同一类型，然后进行运算
强制类型转换（需要转换的类型）变量名。（只有高转低需要）
自动类型转换**（低到高不需要）**
如果强制转换的时候超出类型的设定上限会导致结果出错，也就是内存溢出，或是精度问题！
字符也是可以进行数字转换的，对应着Unicode编码表数字

public class Demo {
    public static void main(String[] args) {
        int i = 128;
        byte b = (byte) i; //高转低需要强制转换
        double v = i;  //低转高不需要强制转换
        System.out.println(v);  //结果128.0没问题
        System.out.println(i);  //结果是128没有问题
        System.out.println(b);  //结果是-128，有问题
        //强制转换的时候超出类型的设定上限会导致结果出错，也就是内存溢出！！
        System.out.println((int)23.7);  //结果是23，已经舍去了后面的小数点
        System.out.println((int)-45.89f);  //结果是23，已经舍去了后面的小数点
        //所以强制转换的时候也会出现精度问题
        char c = 'a'; //在编码表里这也是一个数字
        int d = c+1;  //所以它们可以相加
        System.out.println(d); //结果是等于98
        System.out.println((char)d);  //结果是b
    }
}

注意点

不能对布尔值进行转换
不能把对象类型转换为不相干的类型
在把高容量转换到低容量的时候，需要强制转换，反之不需要
转换的时候可能存在内存溢出，或是精度问题！！！
大数容易溢出！

public class Demo {
    public static void main(String[] args) {
    //JDK7新特性，数字之间可以用下划线分割
    //计算比较大的数字时，注意溢出问题
    int money = 10_0000_0000;
    int years = 20;
    int total = money*years;  //-1474836480，计算的时候已经溢出了int的最大值
    long tatal2 = money*years;  //计算的时候还是按照默认的int来进行计算，然后再转换成long所以还是出错
    long total3 = money*((long)years); //在计算的时候转换成long来计算，所以没有问题
        System.out.println(total); //结果-1474836480
        System.out.println(tatal2);  //结果-1474836480
        System.out.println(total3); //结果20000000000没问题
    }
}

变量

变量就是可以变化的量！方式：数据类型变量名 = 值（int i = 10；）
java是一种强类型语音，每个变量都必须声明其类型
java变量是程序中最基本的储存单元，其要素包括变量名，变量类型和作用域

注意事项

每个变量都有类型，类型可以是基本类型（int、type…），也可以是引用类型（String）
变量名必须是合法的标识符
变量声明是一条完整的语句，因此每个声明都必须以分号结束

        // int a=1,b=2,c=3; 不建议如此定义变量,一定要程序可读性！！！最好是以下面方式定义
        int a = 1 ;
        int b = 2 ;
        int c = 3 ;
        String name = "chuck";
        char x = 'x';
        double pi = 3.14;
	//等等很多种定义变量

变量作用域

类变量

类变量必须在类的里面方法的外面设定
```
static 数据类型 变量名 = 值
```
在方法里面调动起就比较方便一点

实例变量

实例变量必须是在类里面方法外面设定数据类型变量名 =值
在方法里面调动的时候需要赋予给一个局部的变量上，在去使用这个局部的变量 . 啥啥啥

变量类型 变量名字 =new 类的名字();

局部变量

直接在一个方法里面设定好一个变量，数据类型变量名 = 值
但是这个变量只能在设定的方法里面使用，其他方法是无法调动使用的。

//这是一个类
public class Demo05 {
//类变量 static 以下就是一个指定好的类变量，会跟随这类一起存在一起消失
    static int salary = 2000;

//属性变量
//实例变量：从属对象,如果不设定值，就会自动为默认值
//默认值基本数字类型都是0或是0.0 u0000，布尔值是false，其他都是null（string）
    String name;
    int age;
//这是一个main方法
    public static void main(String[] args) {
        //局部变量：必须声明和初始化值
        int i = 10; //这就是一个局部的变量，只能在这个main方法中使用
        System.out.println(i);

        //以下输出一个类变量的代码
        System.out.println(salary); //正常输出2000

        //以下就是一个实例变量，也就是在方法中拿到Demo05外面的设定的变量，然后重新赋予一个新的变量名字来使用
        //变量类型 变量名字 =new Demo08();
        Demo05 gg = new Demo05(); //拿到Demo05设定好的name跟age赋予给gg一个新的变量名
        System.out.println(gg.name);  //输出name的东西，因为只设定，但是没有设定东西，所以结果是null
        System.out.println(gg.age);  //输出age的东西，因为只设定，但是没有设定东西，所以结果是0

    }
//其他方法
    public void add(){
        //在上面main方法中定义的i是无法在这个方法中调用使用的
        //定义的实例变量跟类变量都是可以在这个调用使用的
    }
}

常量

常量（constant）：初始化（initialize）后不能再改变的值！不会变动的值。
所谓常量可以理解为一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。
在设定量之前写上final
常量名一般使用大写字符。

public class Demo06 {
    //修饰符，不存在先后顺序，在基本类型前面都是修饰符
    static final double PI = 3.14;
    public static void main(String[] args) {
        System.out.println(PI);
    }
}

变量的命名规范

所有的变量、方法、类名都要见名知意，也就是说看见名字就知道是什么代码
所有的变量，除了常量，都用首字母小写和驼峰原则，例：monthSalary
常量：大写字母和下划线，例：MAX_VALUE
类名：首字母大写和驼峰原则，例：GoodMan
方法名：首字母小写和驼峰原则,例：runRun()

运算符

算术运算符：+ - * / %（取余也叫模运算） ++ –
赋值运算符：=
关系运算符：> < >= <= == !=
逻辑运算符：&& || ！（与或非）
位运算符：& | ∧ ~ >> << >>>
条件运算符：？：
扩展赋值运算符：+= -= *= /=

public class Demo01 {
    //二次元运算符
    public static void main(String[] args) {
        //ctrl + D 复制当前行到下一行
        int a = 10;
        int b = 20;
        int c = 25;
        int d = 25;
        System.out.println(a+b);  //加法使用
        System.out.println(a-b);  //减法法使用
        System.out.println(a*b);  //乘法法使用
        System.out.println((double)a/b); //因为除出来是个带小数点的数，所以需要转化为douuble！！！
        
        
        //按照优先级来输出类型，如果结果有小数点必须转换其中一个为double或是float
       long a = 1321564613213554L;
       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但是答案却是错的，没有小数点的
        System.out.println(c/(double)d);  //输出的是double答案是正确的
        
        
        //关系运算符返回结果：正确或是错误  布尔值
        int a = 10;
        int b = 20;
        int c = 21;
        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(c%b); //会得出结果是1，21/20 整除剩下1，也叫模运算
    }
}

++ –

++就是自增的意思，–就是自减的意思，一元运算符

public class Demo01 {
    public static void main(String[] args) {
        //++ 就是自增 -- 就是自减 一元运算符
        int a = 3; //原本a=3
        int b = a++; //先把a=3赋予给b，然后a+1=4 （先赋予b在加1）
        int c = ++a; //再把（a=4）+1=5赋予给c  （先加1再赋予c）
        System.out.println(a);  //结果是5
        System.out.println(b);  //结果是3
        System.out.println(c);  //结果是5

        //幂运算2^3  2*2*2 = 8 java没有这个写法
        //会使用Math这个工具类来进行运算
        double pow = Math.pow(3,2);
        System.out.println(pow); //结果9
    }
}

逻辑运算符&& || ！（与、或、非）

&& 是与（and），如果两个变量都为真，结果为true，否则为false
||是或（or），如果两个变量有一个为真，那么结果为true，否则为false
！是非（取反），如果是的true的，则变为false，如果是false的，则变为true
短路运算，一旦计算出来前面是不满足条件的时候，就不会继续运算下面的了

public class Demo01 {
    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);//结果false，结果没有问题
        System.out.println(c);//结果5，因为得知前面（c<4）是false，所以直接不运行后面（c++<4），所以c还是=5 
    }
}

位运算符：& | ∧ ~ >> << >>>

& 与，两个二进制数进行比对，如果两个都为1结果为1，否则为0
| 或，两个二进制数进行比对，如果两个都为0结果为0，否则都为1
^，两个二进制数进行比对，如果两个相同结果为0，否则为1
~ 非，把~的二进制数给相反过来，0结果就是1，1结果就是0
〉〉右移，把十进制数相对应的二进制数右移，再编译成十进制数输出，也就是/2
〈〈左移，把十进制数相对应的二进制数左移，再编译成十进制数输出，也就是*2
如果做乘除2的时候，可以用位运算来进行，速度快！只有乘除2！！！

public class Demo01 {
    public static void main(String[] args) {
        /*
        A = 0011 1100
        B = 0000 1101
        -------------------------
        A&B = 0000 1100 位数对比两个为1结果为1，否则为0
        A|B = 0011 1101 位数对比两个为0结果为0，否则为1
        A^B = 0011 0011 位数对比相同结果为0，否则为1
        ~B = 1111 0010 把B的结果给反过来，1就是0，0就是1


        运算题2*8怎么最快运算？  正常运算为2*2*2*2，但是慢，所以使用<<位运算
        <<  =  *2
        >>  =  /2
        0000 0000         0
        0000 0001         1
        0000 0010         2        二进制的时候2的1是在右边两位
        0000 0011         3
        0000 0100         4
        0000 1000         8
        0001 0000         16       二进制的时候16的1却在左边五位

         */
        System.out.println(2<<3);  //结果16

    }
}

条件运算符：？：(三元运算符)

？：这是一个组合式使用的运算符，相等于if的使用，使用方式是：条件？结果1 ：结果2 （如果符合条件输出结果1，否则输出结果2）这是一个偷懒使用的运算符，但是也必须掌握，代码要精简易读

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

扩展赋值运算符：+= -= *= /=(偷懒运算符，不建议使用)

a+=b,意思是a = a + b
a-=b,意思是a = a - b
a*=b,意思是a = a * b
a/=b,意思是a = a / b

字符串连接注意事项

String在+前面，则后面不会运算，都统一默认为String类型
String在后面，则前面的+都会正常的运算，再加String类型

public class Demo01 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println("w"+a+b);//结果w1020，只要前面有String类型的后面的a跟b都会变成String类型的相加
        System.out.println(a+b+"w");//结果30W，String如果是在后面，前面则会正常的运算在加上String类型
    }
}

包机制

为了更好的组织类，java提供了包机制，用于区别类名的命名空间
包语言的语法格式为：package pkg1[.pkg2[.pkg3…]]；
**一般利用公司域名倒置作为包名
为了能够使用某个包的成员，我们需要在java程序中明确导入该包。使用“import”语句可以完成此功能

import package1[.package2...].(classname|*);

JavaDoc

JavaDoc命令是用来生成自己的API文档的
参数信息
- @author 作者名
- @version 版本号
- @since 指明需要最早使用的JDK版本
- @param 参数名
- @return 返回值情况
- @throws 异常抛出情况
DOC命令输入：javadoc -encoding UTF-8 -charset UTF-8 文件名
使用IDEA生产JavaDoc（百度搜索即可）

Chuck Guo

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java基础语法

Java基础语法1.注释养成使用注释，有助于自己或是别人看得懂代码的意思（注释是不会被执行的）Java中有三种注释,所有注释不能添加到代码的前面，新的一行或是代码后面单行注释//注释多行注释/*注释*/文档注释//javaDoc/**代码以及是作者*/标识符关键字(不能使用关键字命名)abstractassertbooleanbreakbytecasecatchchar
复制链接

扫一扫