java基础知识(2)

最新推荐文章于 2024-07-13 13:55:40 发布

zw_code_java

最新推荐文章于 2024-07-13 13:55:40 发布

阅读量105

点赞数

文章标签： java

本文链接：https://blog.csdn.net/zw_code_java/article/details/109500345

版权

1.注释、标识符、关键字

1、注释：不会被执行，就是便于理解程序

//这是单行注释

/*
	这是多行注释
 */

/**
 *   这是文档注释
 */

2.标识符、关键字

【标识符】： Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符。

凡是自己可以起名字的地方都叫标识符

命名规则：（一定要遵守，不遵守就会报编译的错误）

由26个英文字母大小写，0-9 ，_或 $ 组成

数字不可以开头。

不可以使用关键字和保留字，但能包含关键字和保留字。

Java中严格区分大小写，长度无限制。

标识符不能包含空格。

注意：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。

Java****中的名称命名规范：（不遵守，也不会出现编译的错误）

包名：多单词组成时所有字母都小写：xxxyyyzzz

类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz

变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz

常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ

【关键字】：

被Java语言赋予了特殊含义，用做专门用途的字符串（单词），关键字中所有字母都为小写。

用于定义数据类型的关键字：

class interface enum byte short int long float double char boolean void

用于定义数据类型值的关键字：true false null

用于定义流程控制的关键字：

If else switch case default while do for break continue return

用于定义访问权限修饰符的关键字：**private protected public **

用于定义类，函数，变量修饰符的关键字：**abstract final static synchronized **

用于定义类与类之间关系的关键字：extends implements

用于定义建立实例及引用实例，判断实例的关键字：**new this super instanceof **

用于异常处理的关键字：try catch finally throw throws

用于包的关键字：package import

其他修饰符关键字：native strictfp transient volatile assert

2. 数据类型

[外链图片转存失败,源站在这里插入图片描述
整数拓展

//进制  二进制0b  十进制  八进制0   十六进制0x
int i1 = 0b10;	System.out.println(i1); 2
int i2 = 010;	System.out.println(i2); 8
int i3 = 10;	System.out.println(i3); 10
int i4 = 0x10;	System.out.println(i4); 16

浮点数拓展

//最好完全避免使用浮点数进行比较和计算
//最好完全避免使用浮点数进行比较和计算
//最好完全避免使用浮点数进行比较和计算

//BidDecimal

字符拓展

//所有的字符本质都是数字
//编码问题 Unicode  2字节  0 - 65536    U0000 - UFFFF
//转义字符
// \t  制表符
// \n  换行符
// ...

3.类型转换

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

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

运算中，不同类型的数据优先转换为同一类型，然后进行运算

1、强制类型转换高------>低如： int i = 124; short s = (short) i;

2、自动类型转换低------>高

注意：

1.不能对布尔值进行转换。

2.不能把对象类型转换为不相干的类型。

3.在把高容量转换为低容量时，需要强制转换。

4.转换的时候可能会存在内存溢出，或者精度的问题。

5.操作比较大的数值时，注意溢出问题。

4.变量、常量

1.常量

1.常量分类

字符串常量用双引号括起来的内容(“HelloWorld”)

整数常量所有整数(12,-23)

小数常量所有小数(12.34)

字符常量用单引号括起来的内容(‘a’,’A’,’0’)

布尔常量较为特有，只有true和false

空常量 null

2.代码案例

/*
	常量：在程序执行的过程中，其值不可以发生改变的量
	
	常量分类：
		A:字符串常量	"HelloWorld"
		B:整数常量		12,-23
		C:小数常量		12.34
		D:字符常量		'a','0'
		E:布尔常量		true,false
		F:空常量		null
*/
public class ChangLiang {
	public static void main(String[] args) {
		//字符串常量
		System.out.println("HelloWorld");
		
		//整数常量
		System.out.println(12);
		System.out.println(-23);
		
		//小数常量
		System.out.println(12.34);
		
		//字符常量
		System.out.println('a');
		System.out.println('0');
		
		//布尔常量
		System.out.println(true);
		System.out.println(false);
	}
}

2 变量

1.变量概述

在程序执行的过程中，在某个范围内其值可以发生改变的量

从本质上讲，变量其实是内存中的一小块区域

– 从本质上讲，变量其实是内存中的一小块区域

2.变量定义格式

数据类型变量名 = 初始化值;

3.变量定义

/*
 * 变量的定义格式：
 * 		数据类型 变量名 = 初始化值;
 * 
 * 基本数据类型：
 * 		byte,short,int,long,float,double,char,boolean
 * 
 * 注意事项：
 * 		A:整数默认是int类型，定义long类型变量的时候，建议加L或l。
 * 		B:浮点数默认是double类型，定义float类型变量的时候，建议加F或f。
 */
public class VariableDemo {
	public static void main(String[] args) {
		//byte类型的变量
		byte b = 10;
		System.out.println(10);
		System.out.println(b);
		
		//short类型的变量
		short s = 100;
		System.out.println(s);
		
		//int类型的变量
		int i = 1000;
		System.out.println(i);
		
		//long类型的变量
		//long l = 10000;
		//System.out.println(l);
		long l = 10000000000L;
		System.out.println(l);
		
		//float类型的变量
		float f = 12.34F;
		System.out.println(f);
		
		//double类型的变量
		double d = 12.34;
		System.out.println(d);
		
		//char类型的变量
		char ch = 'a';
		System.out.println(ch);
		
		//boolean类型的变量
		boolean bb = true;
		System.out.println(bb);
	}
}		//定义boolean类型的变量
		boolean bb = false;
		System.out.println(bb);
	}
}

4.变量定义的注意事项

变量未赋值,不能直接使用

引出变量的第二种使用格式

变量只在它所属的范围内有效

变量在哪对大括号内，变量就属于哪对大括号

一行上可以定义多个变量，但是不建议

public class VariableDemo2 {
	public static void main(String[] args) {
		//定义一个变量
		int a = 10;
		System.out.println(a);
		
		int b;
		b = 20;
		System.out.println(b);
		
		{
			//代码块
			int c = 30;
			System.out.println(c);
		}
		//System.out.println(c);
		System.out.println(b);
		
		
		/*
		int aa,bb;
		aa = 10;
		bb = 20;
		System.out.println(aa);
		System.out.println(bb);
		*/
		int aa = 10;
		int bb = 20;
		System.out.println(aa);
		System.out.println(bb);
	}
}

5.运算符

1.运算符的概述和用法

运算符

对常量和变量进行操作的符号称为运算符

表达式

用运算符吧常量或者变量连接起来的符号java语法的式子就可以称为表达式。

不同的运算符连接的式子体现的是不同类型的表达式

常用的运算符

算数运算符

赋值运算符

关系运算符

2.常用运算符

/*
 * 常用的运算符：
 * 		算术运算符
 * 		自增自减运算符
 * 		赋值运算符
 * 		关系运算符
 * 		逻辑运算符
 * 		三元运算符
 * 
 * 算术运算符：
 * 		+,-,*,/,%
 * 
 * 		/和%的区别
 * 			/：获取两个数据相除的商
 * 			%：获取两个数据相除的余数
 * 
 * 注意：
 * 		整数相除只能得到整数。要想得到小数，就必须有浮点数参与运算。
 */
public class OperatorDemo {
	public static void main(String[] args) {
		//定义两个int类型的变量
		int a = 5;
		int b = 3;
		
		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("------------");
		
		System.out.println(5/4);
		System.out.println(5.0/4);
		System.out.println(5/4.0);
	}
}

3.自增自减运算符的概述用法

++,–运算符：对变量做加1或者减1的操作。

++或者–既可以放在变量的后面，也可以放在变量的前面。

单独使用的时候，++或者–无论是放在变量的前面还是后面，结果是一样的。

参与操作的时候：

	如果++或者--在变量的后面，先拿变量参与操作，后变量做++或者--

如果++或者–在变量的前面，先变量做++或者–，后拿变量参与操作

3.1代码案例

/*
 * 自增自减运算符：++,--
 * 
 * 作用：就是自己+1或者-1
 * 
 * ++和--可以放在变量的前面，也可以放在变量的后面。
 * 单独使用一个变量的时候，放在变量的前面或者后面，效果一样。
 * 参与其他操作的时候：
 * 		++在变量的后面，先把变量做操作，然后变量再++
 * 		++在变量的前面，先变量++，然后在做操作
 */
public class OperatorDemo {
	public static void main(String[] args) {
		//定义一个int类型的变量
		int a = 10;
		System.out.println("a:"+a);
		
		//a++;
		//a--;
		//++a;
		//--a;
		//System.out.println("a:"+a);
		
		//int b = a++;
		int b = ++a;
		System.out.println("a:"+a);
		System.out.println("b:"+b);
	}
}

4.赋值用算符的概述和用法

4.1赋值运算符分类

基本的赋值运算符：=

扩展的赋值运算符：+=,-=,*=,/=,%=

+=: a+=20;相当于a = (a的数据类型)(a + 20);

4.2代码案例

/*
 * 赋值运算符：
 * 		基本的赋值运算符：=
 * 		扩展的赋值运算符：+=,-=,...
 */
public class OperatorDemo {
	public static void main(String[] args) {
		//定义变量
		int a = 10; //把10赋值给int类型的变量a
		System.out.println("a:"+a);
		
		//扩展的赋值运算符：+=
		//把运算符左边的数据和右边的数据进行运算，然后把结果赋值给左边
		//a = a + 20;
		a += 20;
		System.out.println("a:"+a);
		
		//short s = 1;
		//s = s + 1;
		
		//扩展的赋值运算符隐含了强制类型转换。
		//a+=20
		//等价于
		//a =(a的数据类型)(a+20);
		short s = 1;
		s += 1;
		System.out.println("s:"+s);
	}
}

5.关系运算符的概述和使用

5.1基本使用及注意事项

关系运算符包含以下内容:

==,!=,>,>=,<,<=

关系运算符的结果都是boolean型，也就是要么是true，要么是false。

注意事项:

关系运算符“==”不能误写成“=”。

5.2代码案例

public class OperatorDemo {
	public static void main(String[] args) {
		//定义三个变量
		int a = 10;
		int b = 20;
		int c = 10;
	
		//==
		System.out.println(a == b);
		System.out.println(a == c);
		System.out.println("------------");
		
		//!=
		System.out.println(a != b);
		System.out.println(a != c);
		System.out.println("------------");
		
		//>
		System.out.println(a > b);
		System.out.println(a > c);
		System.out.println("------------");
		
		//>=
		System.out.println(a >= b);
		System.out.println(a >= c);
		System.out.println("------------");
		
		System.out.println(a == b);
		System.out.println(a = b);//20,把b的值赋值给了a，并把a作为结果输出了
	}
}

6.逻辑运算符

6.1逻辑运算符概述

逻辑运算符用于连接关系表达式，在Java中不可以写成3<x<6，应该写成x>3 && x<6 。

A:逻辑运算符有哪些

&&,|| ！

B:结论：

&&:有false则false。

||:有true则true。

!:非false则true，非true则false。

特点：偶数个不改变本身。

6.2代码案例

public class OperatorDemo {
	public static void main(String[] args) {
		//定义变量
		int a = 3;
		int b = 4;
		int c = 5;
		
		//&&逻辑与
		System.out.println((a>b) && (a>c)); //false && false
		System.out.println((a<b) && (a>c)); //true && false
		System.out.println((a>b) && (a<c)); //false && true
		System.out.println((a<b) && (a<c)); //true && true
		System.out.println("------------");
		
		//||逻辑或
		System.out.println((a>b) || (a>c)); //false || false
		System.out.println((a<b) || (a>c)); //true || false
		System.out.println((a>b) || (a<c)); //false || true
		System.out.println((a<b) || (a<c)); //true || true
		System.out.println("------------");
		
		//!逻辑非
		System.out.println((a>b));
		System.out.println(!(a>b));
		System.out.println(!!(a>b));
	}
}

7.三元运算符

7.1三元运算符概述

格式

(关系表达式)?表达式1：表达式2；

如果条件为true，运算后的结果是表达式1；

如果条件为false，运算后的结果是表达式2；

7.2代码案例

/*
 * 三元运算符：
 * 		关系表达式?表达式1:表达式2;
 * 
 * 执行流程：
 * 		A:计算关系表达式的值，看结果是true还是false
 * 		B:如果是true，表达式1就是结果
 *        如果是false，表达式2就是结果
 */
public class OperatorDemo {
	public static void main(String[] args) {
		//定义两个变量
		int a = 10;
		int b = 20;
		
		int c = (a>b)?a:b;
		System.out.println("c:"+c);
	} 
}


/*
 * 需求：比较两个整数是否相同
 */
public class OperatorTest {
	public static void main(String[] args) {
		//定义两个int类型的变量
		int a = 10;
		//int b = 20;
		int b = 10;
		
		boolean flag = (a==b)?true:false;
		System.out.println(flag);
	}
}

为false，运算后的结果是表达式2；

7.2代码案例

/*
 * 三元运算符：
 * 		关系表达式?表达式1:表达式2;
 * 
 * 执行流程：
 * 		A:计算关系表达式的值，看结果是true还是false
 * 		B:如果是true，表达式1就是结果
 *        如果是false，表达式2就是结果
 */
public class OperatorDemo {
	public static void main(String[] args) {
		//定义两个变量
		int a = 10;
		int b = 20;
		
		int c = (a>b)?a:b;
		System.out.println("c:"+c);
	} 
}


/*
 * 需求：比较两个整数是否相同
 */
public class OperatorTest {
	public static void main(String[] args) {
		//定义两个int类型的变量
		int a = 10;
		//int b = 20;
		int b = 10;
		
		boolean flag = (a==b)?true:false;
		System.out.println(flag);
	}
}

8.位运算符
位运算符主要针对二进制，它包括了：“与”、“非”、“或”、“异或”。从表面上看似乎有点像逻辑运算符，但逻辑运算符是针对两个关系运算符来进行逻辑运算，而位运算符主要针对两个二进制数的位进行逻辑运算。
8.1代码案例

zw_code_java

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java基础知识(2)

1.注释、标识符、关键字1、注释：不会被执行，就是便于理解程序//这是单行注释/* 这是多行注释 *//** * 这是文档注释 */2.标识符、关键字【标识符】： Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符。凡是自己可以起名字的地方都叫标识符命名规则：（一定要遵守，不遵守就会报编译的错误）由26个英文字母大小写，0-9 ，_或 $ 组成数字不可以开头。不可以使用关键字和保留字，但能包含关键字和保留字。Java中严格区分大小写，长度无限制。标
复制链接

扫一扫