📖 earlier posts 📖

JAVA 条件语句

2022-04-21
java java 基础

if…else

if ( i == 10) {
// 满足条件执行	
} else {
// 不满足条件执行
}

实例

public class Demo {
	public static void main (String args[]) {
		int i = 10;
		
		if (i == 10) {
			System.out.println("满足条件");
		} else {
			System.out.println("不满足条件");
		}
	}
}

if…else if…else

if (i == 1) {
// 如果满足 1 执行
} else if (i ==2) {
// 如果满足 2 执行
} else {
// 如果都不满足执行
}

实例

public class Demo {
	public static void main (String args[]) {
		int i = 10;
		
		if (i == 1) {
			System.out.println("=1 ");
		} else if (i == 2) {
			System.out.println("=2 ");
		} else if (i == 3) {
			System.out.println("=3 ");
		} else if (i == 4) {
			System.out.println("=4 ");
		} else if (i == 5) {
			System.out.println("=5 ");
		} else {
			System.out.println("NO ");
		}
	}
}

if .. if

if (i == 10) {
	if (n == 20) {
		if (t == 30) {	
		}
	}
}

实例

public class Demo {
	public static void main (String args[]) {
		int i = 10;
		int n = 20;
		int t = 30;
		
		if (i == 10) {
			System.out.println("=10");
			if (n == 20) {
				System.out.println("=20");
				if (t == 10) {
					System.out.println("=30");
				} else {
					System.out.println("No");
				}
			} else {
				System.out.println("NO");
			}
		} else {
			System.out.println("NO");
		}
	}
}

if .. if .. else ..else

if (i == 10) {
	if (n == 20) {
		if (t == 30) {
			
		} else {
			// 30
		}
	} else {
		// 20
	}
} else {
	// 10
}

if .. if .. else if else ..if

if (i == 10) {
	// 10
	if (n == 20) {
		// 20
	} else if (n == 10) {
		// 20
	} else {
		// 20
	}
} else if (i == 2) {
	// 10
} else {
	// 10
}

实例

if (i == 10) {
	// 10
	if (n == 20) {
		// 20
		if (t == 30) {
			// 30
		} else if (t == 10) {
			// 30
		} else {
			// 30
		}
	} else if (n == 20) {
		// 20
	} else {
		// 20
	}
} else if (i == 10) {
	// 10
} else {
	// 10
}

JAVA 循环结构

2022-04-21
java java 基础

在JAVA循环结构之中,如果想要同样的操作执行多次,就需要使用循环结构来使用,而JAVA中主要有三种循环结构分别为while\do\for

while

代码

1 2	while ( x < 10) { }

实例

public class Demo {
	public static void main (String args[]) {
		int i = 0;
		while (i < 10) {
			
			// 自增且防止一直循环
			i++;
			System.out.println("value =" + i);
		}
	}
}

输出结果为:

value =1
value =2
value =3
value =4
value =5
value =6
value =7
value =8
value =9
value =10

while… do

1 2	do { } while (x > 10);

do……while语句是如果不满足条件，则不嫩进入循环状态,有时候不满足条件的时候,也将最少执行一次

实例

public class Demo {
	public static void main (String args[]) {
		int i = 1;
		
		do {
			i++;
			System.out.println("value = " + i);
		} while(i < 10);
	}
}

for

1 2	for (int i = 10; x < 10; i = i+1) { }

实例

public class Demo {
	public static void main (String args[]) {
		for(int i = 1;i < 10;i++) {
			System.out.println("value = " + i);
		}
	}
}

for…if

public class Demo {
	public static void main (String args[]) {
		int [] i= {10,30,40,50};
		
		for(int x:i) {
			if (x==50) {
				break;
			}
			System.out.print(x);
			System.out.print("\n");
 		}
	}
}

JAVA 运算符

2022-04-21
java java 基础

JAVA运算符可用于计算一些数学晕眩,主要分为算数运算符\关系运算符\位运算符\逻辑运算符\赋值运算符\其他运算符等.

一算数运算符

符	描述
+	加法
-	减法
*	乘法
/	除法
++	自增:数值增加1
–	子减:数值减少1

1.实例

public class Demo {
	public static void main (String args[]) {
		int a = 1;
		int b = 3;
		
		// 加法
		System.out.println("1+1 = " + (a+a));

		// 减法
		System.out.println("1-1 = " + (a-a));
		
		// 乘法
		System.out.println("1x1 = " + (a*a));
		
		// 除法
		System.out.println("1/1 = " + (a/a));
		
		// 自增
		System.out.println("a++ = " + (++a));
		
		// 自减
		System.out.println("b-- = " + (--b));
	}
}

2.自增/自减

2.1 子增

// 自曾
int a = 1;
int b = ++a;
System.out.println("1+1? = " + b);

2.2 子减

// 自减
int c = 3;
int d = --c;
System.out.println("3-1? = " + d);

自检的保底数为”1”

二关系运算符

符	描述
==	是否相等
!=	是否为不相等
>	左是否大于右
<	右是否后大于左
>=	左是否等于/小于右
<=	右是否等于/小于左

1.实例

public class Demo {
	public static void main (String args[]) {
		int a = 1;
		int b = 2;
		
		// 相等
		System.out.println("a = b = " + (a==b));
		
		// 不相等
		System.out.println("a != b = " + (a!=b));
		
		// 左大于右
		System.out.println("a > b = " + (a>b));
		
		// 右大于左
		System.out.println("a < b = " + (a<b));
		
		// 左大于小于右?
		System.out.println("a >= b = " + (a>=b));
		
		// 右大于小于左?
		System.out.println("a <= b = " + (a<=b));
	}
}

三位运算符

符	如果	否则
&	都是1为1	0
\|	都会是0为0	1
^	相同为0	1
~	翻转运算	1=-2 \| -1 = 0
<<	按位左移运算符	左移右
>>	按位右移运算符	右移左
>>>	按位右移补零操作符	左操作数的值按右操作数指定的位数右移

1.实例

public class Demo {
	public static void main (String args[]) {
		int a = 10;
		int b = 20;
		int c;
		
		c = a&b;
		System.out.println("c&b = " + c);
		
		c = a|b;
		System.out.println("c|b = " + c);
		
		c = a^b;
		System.out.println("c^b = " + c);
		
		c = ~a;
		System.out.println("c~  = " + c);
		
		c = a<<1;
		System.out.println("a<< = " + c);
		
		c = a>>1;
		System.out.println("a>> = " + c);
		
		c = a>>>1;
		System.out.println("a>>>1 = " + c);
		
	}
}

四逻辑运算符

符	描述
&&	逻辑运算符	仅当两个参数为真,条件才为真
\| \|	逻辑或操作符	任何两个操作为真,条件为才
!	逻辑非运算符	用于反转操作数的逻辑状态,如果条件为真,则逻辑非运算符为false

1.实例

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

五赋值运算符

符	名称	描述
=	简单赋值运算符	右赋左
+=	加和赋值操作符	左和右相加赋值给左
-=	减和赋值操作符	左和右相减赋值给左
*=	乘和赋值操作符	左和右相乘赋值给左
/=	除和赋值操作符	左和右相除赋值给左
(%) =	取模和赋值操作符	左和右取摸赋值给左
<<=	左移位赋值运算符
>>=	右移位赋值运算符
&=	按位与复制赋值操作符
^=	按位移或赋值运算符
\|=	按位或赋值运算符

JAVA 修饰符

2022-04-21
java java 基础

JAVA主要分为访问修饰符和非访问修饰符,而修饰符主要用于定义类\方法或变量\通常放在语句的最前端

一访问控制修饰符

JAVA中可以使用访问控制符用于保护对类\变量\方法和构造方法的访问

修饰符	描述	对象
default	在同一包内可见不使用修饰符	类\接口\变量\方法
private	在同一类内可见	变量\方法
public	对所有类可见	类\接口\变量\方法
protected	对同一包内的类和所有子类可见	变量\方法

1.默认访问修饰符

对统一包内的类是可见的.接口里的变量都隐式生命为public stati final 而接口里的默认方法权限为public

2.private (私有访问修饰符)

public class Demo {
    // 私有变量
   private String format;
    
    // 为了其他类可以访问定义public变脸
   	public String getFormat() {
      	return this.format;
   }
   	public void setFormat(String format) {
      	this.format = format;
   }
}

私有访问修饰符是最严格的的访问级别,声明方法为private,变量和构造方法只能被所属类访问, 并且类和接口不能声明为private

3.public (公有访问修饰符)

public class Demo {
	public static void main (String args[]) {
		System.out.println("Hello,world");
	}
}

使用public声明的类\方法\构造放噶和接口能被任何其他类访问

4.protected (受保护的访问修饰符)

package demo;

class Demo {
    
    // 如果将openSpeaker声明为private则只能Demo访问
    // private boolean openSpeaker(Demo1 sp) {}
   protected boolean openSpeaker(Demo1 sp) {
	return false;
      // 实现细节
   }
}
 
class StreamingAudioPlayer extends Demo {
    // 如果将 openSpeaker声明为"public"则所有类都可以访问
    // public boolean openSpeaker(Demo1 sp){}
   protected boolean openSpeaker(Demo1 sp) {
	return false;
      // 实现细节
   }
}

1.基类的protected成员是包内可见的,对子类也可见

2.诺子类与基类不再同一包中那么子类实例可以访问其他从基类来继承而来的protected方法,而不能访问基类实例的protected方法

3.也就是说protected 之可以同一包中的类或自身可以访问

主要的作用就是用于保护子类,他的含义在于子类可以用他修饰的成员,其他的不可以,相当与传递给子类继承的东西

如果只想让该方法对其所在的子类中可见,那么则声明为”protected”

二非访问修饰符

在JAVA修饰符中,提供了非访问修饰符.主要分为:

ID	描述
static	用于修饰类方法和类变量
final	用于修饰类\方法和变量	不能被集成,修饰方法不能被继承类重新定义,修饰的变量为常量是不可被修改的
abstrace	用于创建抽象类和抽象方法
synchronized	用于多线程
volatile	用于多线程

1.Static (类变量)

public class Demo {
	// 变量
	public static int i = 0;
	
	// 方法
	public static int getDemo() {
		return i;
		
	}
}

static主要分为静态变量 or 静态方法:

1.static关键字用来声明独立的对象和静态变量,无论多少个对象,静态变量只能有一分复制而局部变量不能被声明为static变量

2.static关键字用来声明独立于对象的静态方法.静态方法不能使用非静态方法 静态方法从参数列表得到这些数据而计算这些数据

2.Final

2.1 声明变量

public class Demo {
   // 声明一个变量
    final int v = 10;
		public static final int V = 1;
    	static final String ID =  "Final";
}

2.2 方法体

public class Demo {
	public final void idFinal() {
		
	}
}

2.3 类

1
2
3

public final class Demo {

}

final主要用于表述最后的含义,变量一旦赋值以后,不能被重新赋值,被final修饰的实例变量必须制定初始值

3.Abstract

public abstract class Demo {
	// 抽象方法
	abstract void a();
}

抽象类不能用于实例化对象,唯一的目是将对未来该类进行扩充.final类不能同时与abstact类一起声明.而抽象类一共包含了两种方法分别为”抽象方法 or 非抽象方法”

抽象方法的声明需以分号进行结尾

4.synchronized

public class Demo {
	public synchronized void thrEad() {		
	}
}

synchronized方法的特点就是可以同一时间内只能被一个线程所访问,而synchronized修饰符可以~~应用与四个访问修饰符,也就是说他可以同时被4个线程访问~~

5.transient

public class Demo {
    // 不会对此进行序列化
	public transient static int t = 10;
	
    // 会对此进行序列化
    public int i;
}

在实际的开发过程中,比如一个银行系统他会涉及很多的问题需要序列化,就比如一些用户敏感信息(如身份证,银行卡密码等),为了安全期间,我们不希望对此进行序列化操作,而此时就会需要transient关键字

6.volatile

volatile修饰的成员变量的时候在每次被线程访问时,都其强制从共享内存中读取该成员变量的值.当成员变量发生变化的时候,都会强制线程将变化值回写到共享内存中.

引用菜鸟教程为例子:

public class MyRunnable implements Runnable {
    private volatile boolean active;
    public void run()
    {
        active = true;
        while (active) // 第一行
        {
            // 代码
        }
    }
    public void stop()
    {
        active = false; // 第二行
    }
}

在通常的情况之下,在一个线程调用了**run()**方法后,在另一个

线程调用了stop()方法,如果 第一行缓冲区的active值被使用,那么 第二行的值为false时循环不会停止.

但是如果哟感到了 volatile修饰active,所以循环会停止

JAVA 变量类型

2022-04-21
java java 基础

在JAVA编程语言中，所有变量使用前必须经过声明，其格式一般为：

1 2	类型变量名 [=值][,identifier[=值]......]; type identifier [=value][,identifier[=value].....]

而一般Type为JAVA的数据类型,而identifier为变量名,多个逗号可以用于声明多个同类变量.而JAVA语言支持的变量类型一共有三类,分别为:

类型	描述	修饰
类变量	独立与方法之外	static
实例变量	独立与方法之外	String
局部变量	类方法中的变量

一类变量

类变量也称之为静态变量在类中以static关键字声明,遵守变量类型规则在方法之外声明该变量

1 2	// 类变量 static int Hell=0;

静态变量在第一次被使用的时候创建使用后销毁

二实例变量

实例变量也是独立与方法之外的变量,其关键字声明是String进行修饰.和类变量一样,在使用的时候创建.使用后销毁

1 2	// 局部变量 String str "Hello";

实例变量具有默认值:

类型	默认值
数值型	0
布尔型	false
引用型	null

三局部变量

局部变量在声明方法或构造方法\语句块中,与上面一样局部变量在声明方法或构造方法\语句块中使用.使用后删除

由于局部变量没有默认值,所以局部变量被声明后必须经过初始化才可以使用.

1.错误

public class Demo {
	public void myAge() {
		int age = 7 ;
		System.out.println(age);
	}
}

1.1 错误原因

需要对Demo进行初始化还必须对myAge实例化

public static void main (String args[]) {
    // 初始化Demo
	Demo demo = Demo();
    
    // 实例化myAge
	Demo.myAge();
}

2.正确

public class Demo {
	public void myAge() {
		int age = 7;
		System.out.println(age);
	}
	public static void main (String args[]) {
		// 初始化Demo
		Demo demo = new Demo();
		
		// 实例化myAge()
		demo.myAge();
	}
}

JAVA 重写与重载

2022-04-21
java java 面向对象

多态

多态指的是在继承中子类继承父类的行为，在JAVA中多态是通过重写（Override）和重载（Overload）来实现的。

重写（Overriding）

是父类与子类，之间多态性的表现，如果子类中，某个方法类，具有相同名称和参数就被称之为方法重写（Override）。

class A {
	public void Overriding_A() {
		// Overriding_A
	}
}

class B extends A {
	public void Overriding_B() {
		// Overriding_B
	}
	public static void Overrding_A() {
		// Overriding_A
	}
}

重载（Overload）

一个类中多态性的一种表现，如果在一个类中，定义了多个同名的放方法，但是他们的“参数列表”不同，则称方法为重载（Overload）

class A {
	public void Overloading_A() {
		// Overloading_A
	}
	
	public void Overloading_A(int num) {
		// Overloading_A (int num )
	}
}

重写（Override） or 重载（Overload）之间的区别就是：

ID	De
重写	方法和参数都需要相同
重载	方法相同，参数可不相同

重写（Override）方法和参数都需要相同，但重载（Overload）方法名相同，但参数不同

Java 序列化

2022-04-21
java java 进阶

Java序列化主要分为序列化和饭序列化，其中详细介绍信息如下：

序列化是什么

序列化就是可以将Java对象转换成字节序列（二进制），而而简直可以写入到硬盘或者在网络中传输而不破坏其结构，在Java远程方法调用中必须使用对对象进行序列化。

什么是反序列化

饭需梨花就是将字节序列转换为Java对象，也就是通过序列化后的字段还原成这个对象的本身（可以使用关键字让这个标识不被序列化）。

在一般的开发过程之中，如果是密码信息等，需要标识不被序列化，以防止网络传输被窃取。

JAVA 基本数据类型

2022-04-21
java java 基础

变量就是申请内存来的存储值,当创建变量的时候,需要在内存中申请空间,而内存管理系统还会根据变量的类型分配存储空间而分配的空间只能用于存储该类型数据 > 也就是说这个就和身份证一样,你的身份证只能用于证明自己身份,但不能用于付钱.

一八种基本类型

1.byte

数据类型8位且有符号以二进制补码表示整数

1 2	byte a = 100 byte b = 50

最大值	最小值	默认值
127	128	0

System.out.println("java.lang.Byte");
System.out.println("byte 01:" + Byte.SIZE);
System.out.println("byte MAX:" + Byte.MAX_VALUE);
System.out.println("Byte MIN:" + Byte.MIN_VALUE);

2.short

数据类型为16位,有符号的二进制补码表示整数

1 2	short s = 1000 short r = 20000

最大值	最小值	默认值
32767	-32768	0

System.out.println("java.lang.Short");
System.out.println("Short 01" + Short.SIZE);
System.out.println("Short MAX" + Short.MAX_VALUE);
System.out.println("Short MIN" + Short.MIN_VALUE);

3.integer (int)

int数据类型为32位有符号的以表示二进制补码整数

1 2	int a = 100000 int b = 200000

最大值	最小值	默认值
2,147,483,647	-2,147,483,647	0

System.out.println("java.lang.Integer");
System.out.println("Integer 01" + Integer.SIZE);
System.out.println("Integer MAX" + Integer.MAX_VALUE);
System.out.println("Integer MIN" + Integer.MIN_VALUE);

4.long

整数类型64位有符号的以表示二进制补码整数

1 2	long a = 100000L long b = 200000L

“L”是不区分大小写的,为了避免与”1”混淆,本文使用大写”L”

最大值	最小值	默认值
9,223,372,036,854,775,807	-9,223,372,036,854,775,807	0L

System.out.println("java.lang.Long");
System.out.println("Long 01" + Long.SIZE);
System.out.println("Long MAX" + Long.MAX_VALUE);
System.out.println("Long MIN" + Long.MIN_VALUE);

5.float

单精度数据类型,32位,符合IEEE 754 浮点数

1	float f1 = 234.5f

System.out.println("java.lang.Float");
System.out.println("Float 01" + Float.SIZE);
System.out.println("Float MAX" + Float.MAX_VALUE);
System.out.println("Float MIN" + Float.MIN_VALUE);

优点: 在存储大型浮点数组时候可以节省内存空间

**缺点:**浮点数不能用于表示精确的值,比如$

**默认值:**0.0f

6.double

是双精度类型,64位,符合IEEE 745 的浮点数,浮点数默认类型都将为double类型

1	double d1 = 123.4

System.out.println("java.lang.Double");
System.out.println("Double 01" + Double.SIZE);
System.out.println("Double MAX" + Double.MAX_VALUE);
System.out.println("Double MIN" + Double.MIN_VALUE);

缺点: 不能表示精确的值,如$

**默认值:**0.0d

7.boolean

数据类型表示一位的信息,通常只有两个取值”true or flase“

1	beelean one = false

**默认值:**flase

**用途:**主要用于标记 true and flase 情况;

8.character (char)

类型是一个单一的Unicode字符 [^16位]

1	char letter = 'A'

**特点:**可用于存储任何一个字符(如ABCDEFD)

最大值	最小值	默认值
\uffff	\u0000	\u0000

System.out.println("java.lang.Character");
System.out.println("Character 01" + Character.SIZE);
System.out.println("Character MAX" + (int) Character.MAX_VALUE);
System.out.println("Character MIN" + (int) Character.MIN_VALUE);

二常量

常量在计算机中欧就那个运行时不能被修改的,主要使用 final作为关键字来修饰常量;

1.double

public class Demo {
	public static void main (String args[]) {
		final double d1 = 3;
			System.out.println(d1);
	}
}

其输出结果为: 3.0

2.byte

数据类型8位且有符号以二进制补码表示整数

public class Demo {
	public static void main (String args[]) {
		byte b = 11;
			System.out.println(b);
	}
}

其输出结果为: 11

3.char (Character)

类型是一个单一的Unicode字符 [^16位]

public class Demo {
	public static void main (String args[]) {
		char c = 'A';
			System.out.println(c);
	}
}

其输出结果为:A

三字符串与常量

字符串和常量都长都可以包含任何Unicode字符

1.字符串

public class Demo {
	public static void main (String args[]) {
		String s = "\u0001";
			System.out.println(s);
		
	}
}

2.常量

public class Demo {
	public static void main (String args[]) {
		char a = '\u0001';
			System.out.println(a);
	}
}

四自动类型转换与强制类型转换

自动类型转换需要满足从低到高的等级转换

1
2
3

<- 低 高->

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

还必须满足以下条件

1.不能对boolean进行转换

2.不能将对象类型转换成不相关类的对象

3.在容量大的类型转换为容量小的时候必须使用强制类型转换

1.自动类型转换

public class Demo {
	public static void main (String args[]) {
		// 定义Char类型
		char c = 'a';
		
		// Char 转换为 Int 类型
		int i1 = c;
		System.out.println("Char类型值= " + c);
		System.out.println("Char自动转换类型为Int后= " + i1);
	}
}

ASCII = a ,查 ASCII 码表对应的 int 类型值为 97

2.强制类型转换

在容量大的类型转换为容量小的时候必须使用强制类型转换**

public class Demo {
	public static void main (String args[]) {
		int i = 12311111;
		byte b = (byte)i;
		System.out.println("Int转换为byte后值为= " + b);
	}
}

int 强制转换因为需要遵守强制转换原则,所以输出结果为**”Int转换为byte后值为= 71”**

JAVA IO

2022-04-21
java java 基础

I/O即input/output 输入/输出,通常指数据在内部存储器和外部存储器或其他周边设备内进行输出.

字节流

程序使用字节流执行8位的输入(input)和输出(output).而所有字节流最小的单元为字节

1 2	java.io.FileInputStream java.io.FileOutpuStream

将1.txt文件内容写入\覆盖到2.txt之中

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo {
	public static void main (String args[]) throws IOException {
		FileInputStream in = null;
		FileOutputStream out = null;		
			try {
				in = new FileInputStream("/home/sunli/1.txt");
				out = new FileOutputStream("/home/sunli/2.txt");
				int i;
				 // in.read从此输入流中读取一个字节数据据
					while((i = in.read()) !=-1) {
						// 将指定的字节写入此文件输出流。  
						out.write(i);
					}
			} finally {
				// finally 将处理收尾工作
				if (in != null) {
					in.close();
				}
				if (out != null) {
					out.close();
				}
			}
	}
}

字符流

字符流是以16位作为数据单元数据流中的最小数据单元就是单元字符,也就是Unicode每位即占2位字符

Writer

writer是所有输出字符流的父类.是一个抽象的类;

CharArrayWriter\StringWriter是两种基本介质流,分别想char\String中写入数据.

// 写单个字符
public void write(int c) throws IOException;

// 将字符数组cbuf[] 写到输出流
public void write(char cbuf[]) throws IOException

// 将字符数组cbuf[]中的从索引为off的位置处开始的len字符写入输出流
public abstract void write(char cbuf[],int off,int len) throws IOException

// 将字符串str中的字符写入输出流
public void write(String str) throws IOException;

// 将字符串str中从索引off处的len字符写入输出流中
public void write(String str,int off,int len) throws IOException

读取文件内信息

import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class Demo {
	public static void main (String args[]) throws IOException {
		FileReader reader = null;
		try {
			File readFile = new File("/home/sunli/1.txt");
			reader = new FileReader(readFile);
            
            // length 返回由该抽象路径名表示的文件长度。如果该路径名表示目录，则				返回值未指定。
			char [] byteArray = new char[(int) readFile.length()];
			int size = reader.read(byteArray);
			System.out.println(new String(byteArray));
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			reader.close();
		}
	}
}

非流式部分

非流式部分主要包含一些辅助流式部分的类,如:SerializablePermission\File\RandomAccessFile\FileDescriptor

读取目录

import java.io.*;

public class Demo {
	public static void main (String args[]) {
		String dir = "/home/";
		File f = new File(dir);
		if(f.isDirectory()) {
			String s[] = f.list();
		for (int i = 0; i <s.length;i++) {
			if(f.isDirectory()) {
				System.out.println("/" + s[i]);
			}
		}
		}
	}
}

JAVA try

2022-04-21
java java 基础

异常处理是程序中出现的一些错误,比如说每个错误都是不一样的.如我这段语句少了个**(),之后又报错说我少了;**.这类错误被成为异常处理

try…catch

try {
// 正常代码
} catch (Name e) {
// 检查是否出发错误?
}

try…catch也称之为**”捕获异常”,而try…catch代码快中的代码一般被称之为保护代码**通常用于异常可能发生的地方.

try…catch…catch

try {

} catch (类型 变量) {

} catch (类型1 变量1) {

} catch (类型2 变量2) {

}

try…catch…catch也可以称之为多重捕获块,可在try中添加多个异常错误触发的代码

try…catch…finally

try {
    
} catch (类型 变量) {
    
} catch (类型1 变量1) {
    
} finally {
    // 程序代码
}

try…catch…finall中的finally也就是无论是否发生一场,都会执行finally块内的代码

📖 more posts 📖

if…else

if…else if…else

if .. if

if .. if .. else ..else

if .. if .. else if else ..if

while

while… do

for

for…if

一 算数运算符

1.实例

2.自增/自减

2.1 子增

2.2 子减

二 关系运算符

1.实例

三 位运算符

1.实例

四 逻辑运算符

1.实例

五 赋值运算符

一 访问控制修饰符

1.默认访问修饰符

2.private (私有访问修饰符)

3.public (公有访问修饰符)

4.protected (受保护的访问修饰符)

二 非访问修饰符

1.Static (类变量)

2.Final

2.1 声明变量

2.2 方法体

2.3 类

3.Abstract

4.synchronized

5.transient

6.volatile

一 类变量

二 实例变量

三 局部变量

1.错误

1.1 错误原因

2.正确

多态

重写（Overriding）

重载（Overload）

序列化是什么

什么是反序列化

一 八种基本类型

1.byte

2.short

3.integer (int)

4.long

5.float

6.double

7.boolean

8.character (char)

二 常量

1.double

2.byte

3.char (Character)

三 字符串与常量

1.字符串

2.常量

四 自动类型转换与强制类型转换

1.自动类型转换

2.强制类型转换

字节流

将1.txt文件内容写入\覆盖到2.txt之中

字符流

Writer

读取文件内信息

非流式部分

读取目录

try…catch

try…catch…catch

try…catch…finally

一算数运算符

二关系运算符

三位运算符

四逻辑运算符

五赋值运算符

一访问控制修饰符

二非访问修饰符

一类变量

二实例变量

三局部变量

一八种基本类型

二常量

三字符串与常量

四自动类型转换与强制类型转换