Java基础语法

最新推荐文章于 2024-05-02 11:11:16 发布

漂泊老猫

最新推荐文章于 2024-05-02 11:11:16 发布

阅读量50

点赞数

分类专栏： Java后端文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/qq_44799103/article/details/128356606

版权

Java后端专栏收录该内容

24 篇文章 0 订阅

订阅专栏

注释、标识符、关键字

注释

注释不会被执行，是给写代码的人看的
书写注释是一个好的习惯

// 单行注释
/*
多行注释
*/
//JavaDoc:文档注释    /**  */
/**
* @Description HelloWorld
*/

标识符

Java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。
所有的标识符都应该以字母（A-Z或者a-z），美元符（$），下划线（_）或数字的任何字符组合。
不能使用关键字作为变量名或方法名。
标识符是大小写敏感的。
合法标识符举例： age、 $salary、 _value、 _1_value
非法标识符举例：123abc、 -salary、 #abc
可以使用中文命名，但是一般不建议这样使用，也不建议使用拼音，很low。

public class HelloWorld {
	public static void main(String[] args) {
		// 定义变量
		String teacher = "laoshi";
		System.out.println("Hello,World!");
	}
}

数据类型

强类型语言：要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用。【安全性高】
弱类型语言

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

Java的数据类型分为两大类

基本类型（primitive type）
- 数值类型
  - 整数类型
    1. byte占一个字节范围：-128~127
    2. short占两个字节范围：-32768~32767
    3. int占四个字节范围：-2147483648~2147483647
    4. long占八个字节范围：-9223372036854775808~9223372036854775807
  - 浮点类型
    1. float占四个字节
    2. double占八个字节
  - 字符类型
    char占2个字节
- Boolean类型：占1位其值只有true和false两个
引用类（reference type）
- 类
- 接口
- 数组

public class Demo02 {
	public static void main(String[] args) {
		//整数
		int a=10;
		byte num2 = 20;
		short num3 = 4546;
		long num4 = 30L;
		//小数浮点数
		float num5 = 2.5F; // Lfloat类型要在数字后面加个F
		double num6 = 3.141592653579;
		//字符
		char name = 'q';
		//String 不是关键字，是个类
		String namea = "shdahuidha";
		//boolean
		boolean flag = true;
		boolean flag_f = false;
		System.out.println(a);
	}
}

什么是字节

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

类型转换

public class Demo03 {
	public static void main(String [] args) {
		// 整数拓展： 进制  二进制  十进制  八进制  十六进制
		int i = 10;
		int i2 = 010;			// 八进制0
		int i3 = 0x10;		// 十六进制0x     0~9      A~F     16
		System.out.println(i);
		System.out.println(i2);
		System.out.println(i3);
		//浮点数拓展？ 银行业务怎么表示？ 钱
		// BigDecimal   数学工具类
		// float  有限  离散  舍入误差   大约   接近但不等于
		// double
		// 最好完全使用浮点数进行比较
		float f = 0.1f;  // 0.1
		double d = 1.0; // 0.1
		System.out.println(f == d);  // false
		float d1 = 23232448184f;
		float d2 = d1 + 1;
		System.out.println(d1 == d2); // true

		// 字符拓展？
		char c1 = 'a';
		char c2 = '中'；
		System.out.println(c1); 
		System.out.println(int(c1));
		// 所有的字符本质上还是数字
		// 编码 Unicode  表: (97 = a  65 =A) 2字节    0- 65536  Excel    2^16 = 65536
		// 转义字符
		// \t  \n  ...
		String sa = new String(original:"Hello World");
		String sb = new String(original:"Hello World");
		System.out.println(sa == sb); // false
		String sc = "hello world";
		String sd = "hello world";
		System.out.println(sc == sd); // true
		// 对象  从内存分析
		// 布尔值扩展
		boolean flag = true;
		if (flag == true){}
		if (flag) {} 
		// Less is More !  代码要精简易读
	}
}

由于Java是强类型语言，所以要进行有些运算的时候，需要用到类型转换。
低-》高 byte short char int long float double
运算中，不同类型的数据先转化为同一类型，然后进行运算。

public class Demo {
	public static void main(String[] args){
		int i = 128;
		byte b = (byte)i;	// 内存溢出
		System.out.println((int)23.7); // 23
		System.out.println((int)-45.89f);  // -45
		
		char c = 'a';
		int d = c + 1;
		System.out.println(d);			// 98
		System.out.println((char)d);	// b
	}
}

强制类型转换
1. 不能对布尔值进行转换
2. 不能把对象类型转换为不相干的类型
3. 在把高容量转换为低容量的时候，强制转换
4. 转换的时候可能存在内存溢出，或者精度问题。
自动类型转换

public class Demo {
	public static void main(String[] args){
		//操作比较大的数的时候，注意溢出问题
		//JDK7新特性，数字之间可以使用下划线分割
		int money = 10_0000_0000;
		System.out.println(money);   // 1000000000
		int years = 20;
		int total = money*years; // -1474836480 , 计算的时候溢出了
		System.out.println(total);
		long total2 = money*((long)years); 	// 20_0000_0000
		// 先把一个数转换为long
		// 代码中为了以防把小l看成1   常用L
	}
}

变量、常量

变量

变量就是可以变化的量；
Java是一种强类型语言，每个变量都必须声明其类型；
Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作品域。

type varName [=value] [{, varName[=value]}];
// 数据类型  变量名 = 值； 可以使用逗号隔开来声明多个同类型变量

注意事项：

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

public class Demo {
	public static void main(String[] args){
		//int a,b,c;
		//int a=1, b=2, c=3; 程序可读性差
		String name = "laomao";
		char x = 'X';
		double pi = 3.14;
	}
}

变量作用域

类变量
实例变量
局部变量

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

public class Demo{
	
	// 类变量 static
	static double salary = 2500;
	
	//属性: 变量
	
	// 实例变量：从属于对象；如果不自行初始化，会初始化为这个类型的默认值  0   0.0   null
	// 布尔值：默认是false
	// 除了基本类型，其余的默认值都是null
	String name;
	int age;
	
	//main方法
	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 void add(){
		 
	}
}

常量（Constant）

初始化（initialize）后不能再改变值！不会变动的值。
所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。
final 常量名=值；
final double PI=3.14;

public class demo{
	//修饰符， 不存在先后顺序
	static final double PI = 3.14;
	public static void main(String[] args){
		
	}
}

常量一般使用大写字母表示。

变量的命名规范

所有变量、方法、类名：见名知意
类成员变量：首字母小写和驼峰原则：monthSalary
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线：MAX_VALUE
类名：首字母大写和驼峰原则：Man，GoodMan
方法名：首字母小写和驼峰原则：run(), runRun()

运算符

Java语言支持如下运算符：

算术运算符：+，-，*，/，%， ++， –
赋值运算符 =
关系运算符： >, <, >=, <=, ==, != instanceof
逻辑运算符： &&， ||，！
位运算符： &, |, ^, ~，>>, <<, >>>
条件运算符？：
扩展运算符： +=， -=， *=， /=

package operator;

public class Demo{
	public static void main(String[] args){
		long a = 1231L;
		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

		// 幂运算 2^3 = 8   很多运算，我们会使用一些工具类来操作。
		double pow = Math.pow(2, 3); 
		System.out.println(pow);
	}
}

逻辑运算符

public class demo{
	public static void main(String[] args){
		boolean a = true;
		boolean b = false;
		System.out.println("a && b: "+(a&&b));
		System.out.println("a || b: "+(a||b));
		System.out.println("!(a && b): "+!(a && b));

		// 短路运算
		int c = 5;
		boolean d = (c<4)&&(c++<4);
		// d=false, c=5
		
		/*
		A = 0011 1100
		B = 0000 1101
		------------------
		A&B = 0000 1100
		A|B = 0011 1101
		A^B = 0011 0001		异或 相同为0，不同为1
		~B = 1111 0010
		
		2*8 = 16 怎样运算最快
		<< *2
		>> /2
		*/
		System.out.println(2<<3);
		
		int a = 10;
		int b = 20;
		// 字符串连接符  +  ， String
		System.out.println(a+b);   	  //30
		System.out.println(""+a+b);   //1020
		System.out.println(a+b+"");   //30

		// 三元运算
		int score = 80;
		String type = score < 60? "不及格":"及格"；
	}
}

包机制、JavaDoc

包机制

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

JavaDoc

javadoc命令是用来生成自己API文档的
参数信息
1. @author 作者号
2. @version 版本号
3. @since 指明需要最早使用的jdk版本
4. @param 参数名
5. @return 返回值情况
6. @throws 异常抛出情况

/**
* @author laomao
* @version 1.0
* @since 1.8
*/
public class Doc {
	
	String name;

	/**
	* @author laomao
	* @param name
	* @return
	* @throws Exception
	*/
	public String test(String name) throws Exception{
		return name;
	}
}

类文件路径下CMD

javadoc -encoding UTF-8 - charset UTF-8 Doc.java

生成 index.html