Java基础--自我总结（1）

1.java数据类型

1.1 八大基本类型

		--   *八种：**byte  short  int  long  float  double  char  boolean***
		--  整型:  byte   short   int   long
		--  float ->Float    --- 单精度,对小数位不太精确
		--  double -> Double  --- 双精度 ,对小数位狠精确
		-- 取值范围：byte：-128~127
							short: -32768~32767
							int: -2147483648~2147483647
							long:  -9223372036854775808~9223372036854775807
							float:  1.4E-45~3.4028235E38
							doubler :  4.9E-324~1.7976931348623157E308
		--boolean:true真/false假
		--char -- 字符型
		-- char: 可以存一个汉字，char类型允许存放数字,但是,使用时,会去 查找数字对应的字符 ,使用字符本身，
			范围：ascii码表

1.2类型的转换

– 小转大/隐式转换 byte -> long – 可以直接转换
– 大转小/显式转换 float -> int --不可以直接赋值 , 需要强转

int n = (int) m ;

2.运算符

2.1运算符简述

–算术运算符:±*/ %(求余数) ++ –
–比较运算符:结果是boolean类型 == !=
–逻辑运算符:结果是boolean类型 ! +

• & – 表示并且关系/单与

• 1 & 2 ,最终的运算结果想要得到true,要求1 和 2都得是true

• | – 表示或者关系/单或

• 1 | 2 ,最终的运算结果想要得到true,要求1是true或者2是true

• && – 表示并且关系, 效率高/双与/短路与

• 1 && 2 ,当1为false时,运算的结果早就注定了是false,此时,2没必要执行

• || – 表示或者关系, 效率高/双或/短路或

• 1 || 2 ,当1为true时,运算的结果早就注定了是true,此时,2没必要执行

– 三元运算符: 1 ? 2 :3
– 赋值运算符: = += -= *= /=

2.2自增自减

–自增

int a = 1;
//符号在后, 先使用后变化
System.out.println( a++ );//1
int b = 1;
//符号在前, 先变化后使用
System.out.println( ++b );//2
System.out.println( ++a+b+a++ );//3+2+3=8

–自减

int c = 0 ;
//0,符号在后, 先使用后变化
System.out.println( c-- );
int d = 0 ;
//-1,符号在前, 先变化后使用
System.out.println( --d );
System.out.println( --c-d-d-- );//-2-(-1)-(-1)=0

2.3求最大值

– 三元运算符语法 1 ? 2 : 3

int a=1;
int b=2;
//结果可能是2或者3,到底是谁 ? 要看1是否成立,如果成立结果就是2,否则就是3
int max = a > b ?  a : b  ;
System.out.println("a b里的大值是: "+max) ;//2

3.分支结构

– 概述：
– if：如果想要先完成判断,才去执行的需求.使用分支结构…
– switch

3.1 if 分支结构

– 单分支
if( 判断条件 ){ 执行满足了条件的代码 }

– 多分支
f( 判断条件 ){
执行 满足了条件的代码
}else{
执行 不满足 条件的代码
}

– 嵌套分支
if( 判断条件1 ){
代码1
}else if( 判断条件2 ){
代码2
}else if( 判断条件3 ){
代码3
}else if( 判断条件4 ){
代码4
}else{
以上都不满足的 代码5
}

3.2 switch 分支结构

switch(判断条件){
case 1 : System.out.println(1);
case 2 : System.out.println(2);
case 3 : System.out.println(3);
…
default : System.out.println(100);

4.循环结构

– for:重复的执行某个任务
– while:先判断再执行
– do-while:先执行再判断

4.1 for循环结构

– for循环的语法：
for( 开始位置 ; 循环条件 ; 更改条件 ){
重复执行的任务/循环体
}

– 嵌套for循环:
for(开始位置 ; 循环条件 ; 更改条件){ //外循环
for(开始位置 ; 循环条件 ; 更改条件){ //内循环
循环体
}
}
–外循环执行1次,内循环执行多次
–外循环控制行,内循环控制列

4.2 while 循环结构

– while循环语法：
while(循环条件){
循环体
}

4.3 do-while 循环结构

– do-while 语法：
do{
循环体
}while(判断条件) ;

4.4三种循环结构的区别

–相同点: 都是用来做循环的
–for : 知道从哪儿开始,要循环多少次,每次的规律
for(开始位置;循环条件;更改条件){ 循环体 }
–while : 只知道条件 – 先判断再执行
while(循环条件){ 循环体 }
–do…while : 只知道条件 --先执行再判断 – 能保证 循环体最少执行1次
do{ 循环体 }while(循环条件);

5.break和continue关键字

– 是java里的关键字,用来结束循环的结构.只能用在循环里
for循环中

for (int i = 1; i <= 10; i++) {
					//如果是偶数,就结束
					if( i % 2  ==  0 ) {
						System.out.println(i);
						break ; //1, 立刻结束
						continue ;//2, 结束这次循环,但是还能继续下一次的循环
						
					//3, break和continue都是结束,后面不能再出现代码,否则都是Unreachable code
					System.out.println(i);
					}
				}
				
				
			}

whlie循环中

while( true ) {//5, 循环条件: while( true )  叫死循环 !!!一定要设置出口 !!!!break !!!}

//2, 接收用户输入的数字
int x = new Scanner(System.in).nextInt() ;
int y = new Scanner(System.in).nextInt() ;
//3, 比较
if( y > x) {
System.out.println("大了");
}else if( y < x ) {
System.out.println("小了");
}else if( y == x) {
System.out.println("对了");
break ;//4, 是死循环和的出口 !!!!
}

do-while循环中

do {}while（true）;//5, 循环条件: while( true )  叫死循环 !!!一定要设置出口 !!!!break !!!

do {
	//2, 接收用户输入的数字
int x = new Scanner(System.in).nextInt() ;
int y = new Scanner(System.in).nextInt() ;
   //3, 比较
if( y > x) {
	System.out.println("大了");
}else if( y < x ) {
	System.out.println("小了");
}else if( y == x) {
	System.out.println("对了");
	break ;//4, 是死循环和的出口 !!!!
}
} while( x >90 ) ;

6.方法的重载 – overload

– 在同一个类里,出现了 方法名相同 但是 参数列表不同(个数 | 类型) 的多个同名方法
好处: 方便记 + 程序灵活
– 重载: 在一个类里的现象,方法名相同但是参数列表不同

public static void add(int a,int b) {
					System.out.println();
				}
public static void add(int a,int b,int c) {
				}
public static void add(int a,int b,String c) {
				}
public static void add(String c,int a,int b) {
				}

7.数组

– 用来存储 多个 类型相同的 数据 .英文叫Array ,标志[]
– 语法: 数组类型[] 数组名 = new 数组类型[数组长度] ;
- int[] a = new int[5];
– 静态初始化
- int[] b = new int[]{1,2,3,4,5};
- int[] c = {1,2,3,4,5};

//1, 静态初始化
char[] a = new char[] { 'h','e','l','l','o' };
char[] b = { 'h','e','l','l','o' };

//2, 动态初始化
char[] c = new char[5];
c[0] = 'h' ;//修改c数组里0下标处的数据,改成h字符
c[1] = 'e' ;//修改c数组里1下标处的数据,改成e字符
c[2] = 'l' ;//修改c数组里2下标处的数据,改成l字符
c[3] = 'l' ;//修改c数组里3下标处的数据,改成l字符
c[4] = 'o' ;//修改c数组里4下标处的数据,改成o字符

7.1数组的遍历

– 语法：
for(下标为0的位置 ; <= 下标的最大值; 下标++){
循环体
}
– 作用就是用来依次获取数组里的数据

• 给每个元素分配随机数

//1,定义数组
int[] a = new int[10];
//2,遍历数组并改值
for (int i = 0 ; i < a.length ; i++) {
//3, 给每个元素分配随机数
a[i] = new Random().nextInt(100) ;
System.out.print( a[i]+"," );
}

• 打印数组里的所有数据

//1, 定义数组
	String[] a = {"h","e","l","l","o"};
	//2, 遍历数组
			/*
			 * int i = 0 ---- 从下标为0的位置开始  ---- i表示下标
			 * i <= a.length -1 ---- 下标的最大值就是数组的长度-1
			* i++  -----  下标的变化规律就是自增
			 */
	for(int i = 0 ; i <= a.length -1 ; i++) {
		//3, 根据下标获取a数组里的数据
		System.out.println( a[i] );
		}
	//		System.out.println( a[5] );//报错,下标越界异常
		}

• 遍历数组，存入1到10

//1,定义数组
	int[] a = new int[10];
	//2,遍历数组
for( int i = 0 ; i <= a.length-1 ; i++ ) {
		//4,修改 值
		a[i] = i+1 ;
		//3,打印
	System.out.println( a[i] );
}