Java基础学习笔记

Java基础学习笔记

---

---

前言

本文仅以自己理解的方式记录学习笔记

一、Java基本数据类型

byte:最小值是-128,最大值是127
byte a = 127;

short:最小值为-32768，最大值为32767
short b = 32767;

int:最小值是 -2147483648,最大值是2147483647
int c = 2147483647;

long:最小值是 -9223372036854775808	,最大值为9223372036854775807
long d = 9223372036854775807l; // 声明long类型数据时，须在数据后面加‘L’或者‘l’

float：单精度小数，最小值为1.4E-45	最大值为3.4028235E38   
结尾的"E+数字"表示E之前的数字要乘以10的多少次方。比如3.14E3就是3.14 × 103 =3140，3.14E-3 就是 3.14 x 10-3 =0.00314
float e = 1;

double:双精度小数,最小值为4.9E-324  最大值为1.7976931348623157E308
double f = 7.;

boolean:只有false和true两个值
boolean g = true;

char:字符型
char h = 65535; // 存储数字时，最小值为0，最大值为65535
char j = '中'; // 中文只能存储一个字
char k = 'a'; // 英文只能存储一个字母或符号

数据强制类型转换：
int m = 123;
byte n = (byte) m; // 强制转换格式：(type)value type是要强制类型转换后的数据类型
char s = (char) m;

二、Java类，方法以及变量

类的三种变量

1.局部变量：在方法、构造方法或者语句块中定义的变量叫做局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。声明时必须赋值
2.成员变量（实例变量）：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
3.类变量（静态变量）：类变量也声明在类中，方法体之外，但必须声明为static类型。

类的方法详解

构造方法

1.每个类都有构造方法，
2.如果没有显式地为类定义构造方法，Java 编译器将会为该类提供一个默认构造方法.
3.构造方法的名称必须与类同名，无返回值，一个类可以有多个构造方法
4.构造方法仅用于实例化对象，是与创造对象一起执行的操作，创建对象时，必须要调用一个构造方法
public JavaBasics() {
	System.out.println("我是一个构造方法");
}
5.重载构造方法，调用时根据参数值来确定用哪一个	
	public JavaBasics(int ar) {
		System.out.println("我是一个重载的构造方法");
	}

普通方法

1.普通方法是在对象创建之后调用的方法
2.不能和类名一致，首字母小写
3.创建时需声明方法访问控制修饰符，非访问控制修饰符，返回值类型，方法名，参数。返回值类型和方法名时必须的

静态方法

1.非静态方法只能让对象调用，不创建对象就无法调用，而静态方法可以直接调用
2.静态方法只能调用静态成员
3.必须用用static修饰
	public static void test1() {
		System.out.println("我是一个静态方法");
	}

主方法

项目运行的入口，每个项目必须只能有一个主方法，否则无法运行
	public static void main(String[] args) { 	// Java规范主方法必须这么定义，不能修改
			System.out.println("我是主方法，项目运行的入口");
			test1(); // 静态方法可以直接调用
			JavaBasics bbb = new JavaBasics(); // 使用new关键字创建对象，创建对象时必须用构造方法
			bbb.test2(); // 创建对象后，通过对象调用普通方法
	}

方法重载和重写

方法重载:方法名相同，但参数不同,返回值不同
方法重写：
	1.只能应用于子类重写父类的方法，且方法名，参数和返回值必须相同
	2.被private修饰的方法不能重写，子类不能将父类中public的方法重写为private
	3.父类抛出的异常，子类必须一样
	public void chongzai() {	
	
	}
	public void chongzai(int i) {
	
	}
	public int chongzai(int i,int t) {
		return 1;
	}

访问控制修饰符

1.无修饰符：只能在同一个包里面调用，可用于修饰类、接口、变量、方法
2.private : 只能在同一个类里面调用，可用于修饰对象：变量、方法，注意：不能修饰类（外部类）
3.public : 对所有类可见。用于修饰类、接口、变量、方法
4.protected : 对同一包内的类和所有子类可见。用于修饰变量、方法。 注意：不能修饰类（外部类）
	public void test() {
		System.out.println("我是一个普通方法");
	}
	void test2() {
		System.out.println("无修饰符，无传入参数的方法");
	}

非访问控制修饰符

1.static：用于修饰静态方法和静态类变量
2.final：用于修饰类、方法和变量，final修饰的类不能被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，不可修改
3.abstract：用于修饰抽象类和抽象方法
4.synchronized 和 volatile：主要用于线程的编程

三、Java循环和条件语句

1.循环语句

循环语句关键字：
break 关键字：用于循环语句中跳出该循环，继续执行循环下面的语句
continue 关键字：用于循环语句中终止本次循环，跳转到下一次循环

while循环

public void Xunhuan(int x) {
	// 满足括号中的条件时才会执行
	while (x == 20) {
		System.out.println("不满足条件则不执行");
}

do…while 循环

do {
		System.out.println("执行一次后才会判断条件语句，不满足条件则不再循环");
} while (x < 20);

for循环

执行一次后会自动更新变量值，然后再次判断条件执行
for(初始化一个变量为其赋值; 循环判断语句; 变量更新)
for (int y = 1; y < 20; y = y + 1) {
		System.out.println("执行完后y自动+1");
}

增强 for 循环

1.用于数组
2.格式：for(声明语句 : 表达式)，声明语句中的数据类型必须与数组元素的类型一致，表达式为数组名
3.h为数组的元素值，第一次循环的值为数组的第一个元素，该循环将数组的元素遍历出来
int[] nu = { 10, 20, 30, 40, 50 };
for (int h : nu) {
	System.out.println(h);
}

2.条件语句

if语句

格式：
if(布尔表达式){
	如果布尔表达式为true将执行的语句
}

举例：
int a = 5;
if (a == 5) {
		System.out.println("a等于5时执行");
}

if else语句

格式：
if(布尔表达式){
	如果布尔表达式的值为true
}else{
	如果布尔表达式的值为false
}

举例：
int a = 5;
if (a == 6) {
	System.out.println("a等于6时执行");
} else {
	System.out.println("a不等于6时执行");
}

if else if else 语句

格式：
if(布尔表达式 1){
	如果布尔表达式 1的值为true执行代码
}else if(布尔表达式 2){
	如果布尔表达式 2的值为true执行代码
}else if(布尔表达式 3){
	如果布尔表达式 3的值为true执行代码
}else {
	如果以上布尔表达式都不为true执行代码
}
	
举例：
int a = 5;
if (a == 6) {
	System.out.println("a等于6时执行");
} else if (a == 7) {
	System.out.println("a等于7时执行");
} else if (a == 8) {
	System.out.println("a等于8时执行");
} else {
	System.out.println("a不等于以上三个条件时执行");
}

switch case 语句

格式：
switch(expression){
   case value :
   //语句
   break; //可选
case value :
   //语句
   break; //可选
//你可以有任意数量的case语句
default : //可选
   //语句
}

举例说明：
以下代码执行时会先匹配case1-4四个值，匹配到相同的值后执行对应的case语句，匹配不到则执行default语句，没有default语句时则执行swich后面的代码
break关键字：表示当前case执行后不再执行后面的case语句，没有break会继续执行后面的case，执行到后面有break的case时才会结束
int a = 4;
switch (a) {
	case 1:
		System.out.println("a等于1以上三个条件时执行");
	case 2:
		System.out.println("a等于2以上三个条件时执行");
	case 4:
		System.out.println("a等于4以上三个条件时执行");
		break; // 可选
	case 3:
		System.out.println("a等于3以上三个条件时执行");
		break; // 可选
	//可以有任意数量的case语句
	default: // 可选
		System.out.println("a不等于以上四个case时执行");
	}

四、Java数据操作

基本数据类型操作

当我们需要对某一个数据进行操作时，需要把数据声明为一个对象，然后调用Number类中的方法操作
每种数据类型都对应一个Number类下的子操作类
以下为基本数据类型对应的包装类：

基本数据类型								对应操作类
boolean     							Boolean
byte									Byte
short									Short	
int										Integer	
long									Long	
char									Character	
float									Float	
double									Double	

使用方法

int a = 5000; // 声明一个变量并赋值
int t = 500;
Integer g = 12;
Integer b = 5000; // 声明一个int类型的数据对象，Integer为Number的子类，该对象可以直接调用Number类的方法

xxxValue()将 Number 对象转换为xxx数据类型的值并返回
byte c = b.byteValue(); // 将b的值转换为byte类型返回

返回a和t的最小值	
int d = Math.min(a, t);

返回a和t的最大值	
int e = Math.max(a, t);

compareTo()括号中的数据可以是Byte,Double,Integer,Float,Long或Short类型的参数
返回值为int类型；g = 5时返回0，g < 5时返回-1，g > 5时返回1
int f = g.compareTo(5);

equals()括号中的数据类型与g相同，g = 5时返回true，否则返回false	
boolean h = g.equals(5);

valueOf()
返回一个 Number 对象指定的内置数据类型
Integer j = Integer.valueOf(a); // 返回一个表示a的Integer实例
Integer s = Integer.valueOf("1234561");// 返回"1234561"的Integer对象
Integer q = Integer.valueOf("1234561", 10); // 返回一个Integer对象，使用10进制提取"1234561"的值

toString()
以字符串形式返回值。
String r = b.toString(); // 将整数b转换为字符串
String y = Integer.toString(5); // 将整数5转换为字符串

parseInt()
将字符串解析为int类型。
int u = Integer.parseInt(r); // 将字符串转换为整数
int o = Integer.parseInt(r, 10); // 将字符串用10进制解析为整数
double p = Double.parseDouble("5"); // 将字符串"5"转换为double类型

abs()
返回参数的绝对值。
int z = Math.abs(b);
double x = Math.abs(p);

ceil()和floor()：操作的参数只能是double和float类型的数据

round取值： 1.5以下取1，1.5及以上取2   
rint取值：  1.5及以下取1，1.5以上取2
floor取值：去掉小数点向下取值
ceil取值：去掉小数点向上取值

double v = 1.256;
double qt = 2;
ceil方法将数据的小数去掉后+1，返回一个double类型的整数
double qe = Math.ceil(v); // qe的值为2.0

floor方法将数据的小数去掉，返回剩余的整数，同样是double类型
double qr = Math.ceil(v); // qr的值为1.0

没有小数时，返回值不变
double qy = Math.ceil(qt); // qy的值为2.0
double qu = Math.ceil(qt); // qu的值为2.0

rint()
操作的参数只能是double类型，返回与参数最接近的整数，返回的数据类型为double
double qi = Math.rint(v);

round()
操作的参数只能是double类型，将参数四舍五入返回一个最接近的int、long型值，方法会指定返回的数据类型
long qo = Math.round(v); // qo的值为1

min()和max()
min返回两个参数中的最小值,max返回两个参数中的最大值
int qp = Math.min(1, 2); // qp的值为1
int qa = Math.max(1, 2); // qa的值为2
参数类型与返回值类型相同
long qs = Math.max(1, 2);
double qd = Math.max(1, 2);

random()
返回一个0.0至1.0之间的随机数，返回值为double类型，该方法没有参数
double qf = Math.random();

exp()
返回自然数底数e的参数次方。

log()
返回参数的自然数底数的对数值。

pow()
返回第一个参数的第二个参数次方。

sqrt()
求参数的算术平方根。

sin()
求指定double类型参数的正弦值。

cos()
求指定double类型参数的余弦值。

tan()
求指定double类型参数的正切值。

asin()
求指定double类型参数的反正弦值。

acos()
求指定double类型参数的反余弦值。

atan()
求指定double类型参数的反正切值。

atan2()
将笛卡尔坐标转换为极坐标，并返回极坐标的角度值。

toDegrees()
将参数转化为角度。

toRadians()
将角度转换为弧度。

char类型数据处理详解

Character类提供针对char类型数据的处理方法

char s = 'a';
char m = 'A';

isLetter():判断字符是否为字母，是返回true，不是返回false
boolean a = Character.isLetter(s); // 返回结果为true

isDigit():判断字符是否为数字，是返回true，不是返回false
boolean b = Character.isDigit(s); // 返回结果为false

isWhitespace():判断字符是否为空白字符，是返回true，不是返回false
boolean c = Character.isWhitespace(s); // 返回结果为false

isUpperCase():判断字符是否为大写字母，是返回true，不是返回false
boolean d = Character.isUpperCase(s); // 返回结果为false

isLowerCase():判断字符是否为小写字母，是返回true，不是返回false
boolean e = Character.isLowerCase(s); // 返回结果为true

toUpperCase():将字符转换为大写，如果本身就是大写则返回值不变
char f = Character.toUpperCase(s); // f的值为A
char g = Character.toUpperCase(m); // f的值为A

toLowerCase():将字符转换为小写，如果本身就是小写则返回值不变
char h = Character.toLowerCase(s); // f的值为a
char j = Character.toLowerCase(m); // f的值为a

toString():将字符转换为长度为1的字符串
String k = Character.toString(s); // f的值为a,但是变成了String类型

String类型数据处理详解

String为字符串对象

创建字符串的两种方法

1.直接赋值创建,与变量一样存储在公共池
	String str = "Runoob"; 

2.调用String类当作对象创建，与对象一样存储在堆上
	String str2 = new String("abcdefg"); 

String类常用的构造方法

byte[] st = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 0, 5 };
char[] s = { 1, 2, 3, 4, 5, 'a', 'b', 'c', 'd' };

默认构造方法
	String str3 = new String("abcdefg");
	System.out.println(str3);

通过byte数组构造字符串对象
	String str4 = new String(st);
	System.out.println(str4);

从byte数组的第2二位开始，构造一个长度为5的字符串
	String str5 = new String(st, 2, 5);
	System.out.println(str5);

通过char数组构造字符串对象
	String str6 = new String(s);
	System.out.println(str6);

从char数组的第2二位开始，构造一个长度为5的字符串
	String str7 = new String(s, 2, 5);
	System.out.println(str7);

String类常用方法

length()方法：返回字符串的长度，返回值为int类型
	int a = str.length(); // a的值为6
	System.out.println(a);

concat()方法：将两个字符串连接构成新的字符串，返回值为String类型
	String b = str.concat(str2); // b的值为“Runoobabcdefg”
	String c = "ABC".concat(str); // c的值为“ABCRunoob”
	String d = str.concat("abc"); // d的值为“Runoobabc”
	System.out.println(d + b + c);

isEmpty()方法：用于判断字符串是否为空,如果字符串是空格也不为空
	boolean e = str.isEmpty();
	System.out.println(e);

equals()方法：用于比较两个字符串是否相等
	boolean f = str.equals(str2);
	System.out.println(f);

equalsIgnoreCase()方法:用于将字符串与指定的对象比较，不考虑大小写
	boolean g = str.equalsIgnoreCase(str2);
	System.out.println(g);

 matches()方法:用于检测字符串是否匹配给定的正则表达式。
	boolean h = str.matches("正则表达式");
	System.out.println(h);

StringBuffer类和StringBuilder类

用于字符串修改

**区别：**：
String:获取字符串的属性，字符串修改需要创建新的字符串对象

StringBuffer:
	与String的区别：对字符串进行各种修改操作，不需创建新的对象
	与StringBuilder的区别：多线程同步访问
	
StringBuilder:速度快，但不能在多线程中同步访问

**用法：**
创建字符串类型的对象缓冲区，与创建对象的方式一样，但是对象缓冲区是空的
	StringBuffer st = new StringBuffer(10); // 参数指定对象缓冲区的初始大小
	StringBuilder str = new StringBuilder(10);

append(): 将括号中的参数追加到此字符序列
	st = st.append(15); // 参数可以是多种类型数据

insert(int offset, int/String)；将 int 参数的字符串表示形式插入此序列中。 对象缓冲区为空时不可使用
	st = st.insert(2, 15); // 从字符串索引的第2位插入15
	st = st.insert(8, "abcde"); // 从字符串索引的第8位插入”abcde“

	str = str.insert(2, 15);
	str = str.insert(8, "abcde");

delete()：去掉字符串索引的第2到第5位的字符，返回新的字符串
	st = st.delete(2, 5);

reverse()：将字符串的字符顺序反过来
	st = st.reverse();

replace(int start, int end, String str)：
	// 替换字符串中的一小段，第一个参数和第二个参数分别为替换的索引开始和结束位置，第三个参数为要替换的字符串
	st = st.replace(2, 5, "msnsss"); // 将字符串中索引2到5的位置替换为“msnsss”

charAt(int index)：
	char a = st.charAt(5); // 返回字符串索引第5个字符，返回值为char类型
	System.out.println(a);

五、Java数组

数组的声明，创建，初始化

格式1：元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
	int[] ms = new int[2]; // 声明和创建数组 ,这种方式只能在方法体里面声明，否则分号会报错
	ms[0] = 1; // 数组初始化
	ms[1] = 2;

格式2：元素类型[] 数组名 = new 元素类型[]{元素，元素，……};
	int[] ml = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 }; // 声明，创建，初始化一步完成
	int[] mq = { 0, 9, 8, 7, 6, 5, 4, 3, 2, 1 };

数组处理

遍历打印数组元素
	for (int i = 0; i < mq.length; i++) {	//length属性为数组的长度
		System.out.println(mq[i] + " "); 
	}
	
遍历打印数组元素的第二种方法
	for (int h : mq) {			//h的类型与数组元素一致
		System.out.println(h);
	}
	
计算所有元素的总和，只能用于数字类型的数组
	double as = 0;
	for (int i = 0; i < mq.length; i++) {
		as += mq[i]; 
	}		
	System.out.println("元素总和为 " + as);

查找最大元素
	int ma = ml[0]; 		// 创建一个变量初始化为数组的第一个元素值
	for (int i = 1; i < ml.length; i++) { 		// 从数组的第二个元素开始遍历
		if (ml[i] > ma) { 		// 如果当前遍历的元素大于ma
			ma = ml[i]; 		// ma的值变为当前元素
		}
	}
	System.out.println("数组中的最大值为" + ma);

Arrays类中常用的数组操作静态方法

int[] ar = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
int[] aq = new int[] { 1, 1, 2, 4, 5, 6, 5, 3, 9, 0 };

equals(long[] a, long[] a2)方法：比较两个数组，顺序和元素都相等返回true
	boolean a = Arrays.equals(ar, aq);	//括号中的两个参数必须是相同数据类型的数组
	System.out.println(a);
	
sort(Object[] a)方法：按自然顺序升序排列元素值
	Arrays.sort(ar);	//该方法无返回值,因此直接调用
	for (int h : ar) {
		System.out.println(h);
	}
	
binarySearch(Object[] a, Object key)方法：
	数组中查找某个指定的对象，查找成功返回该对象在数组中的索引值，找不到则返回-1
	Integer s = 2;
	int k = Arrays.binarySearch(ar, s);	//ar为数组，s为需要查找的对象（包括数据对象，数组对象等）
	System.out.println(k);
	
fill(int[] a, int val)方法：无返回值
	第一个参数为数组，第二个参数为指定的数组元素值（必须与数组元素类型相同）
	Arrays.fill(ar, 100);	// 将ar中所有的元素值全都修改为100
	for (int h : ar) {
		System.out.println(h);
	}
	
	Arrays.fill(ar,2,5,100);	//将ar中索引2到5之间的元素值修改为100	
	for (int h : ar) {
		System.out.println(h);
	}

数组常见异常

1.NullPointerException空指针异常，原因： 引用类型变量没有指向任何对象，而访问了对象的属性或者是调用了对象的方法
	int[] x = { 1, 2, 3 };
	System.out.println(x[1]);
	x = null;
	System.out.println(x[1]);	//数组是空的，所以访问时产生空指针
		
2.ArrayIndexOutOfBoundsException索引值越界，原因：访问了不存在的索引值
	System.out.println(x[3]);	//数组的索引从0开始，x数组最大索引为x[2]，不存在x[3]，产生错误

六、Java日期时间

日期时间需要导入的相关包

SimpleDateFormat：格式化日期:主要用于日期和字符串两种类中之间的转换
Calendar：日历类，设置和获取日期数据的特定部分
Date：导入时间操作类
GregorianCalendar：公历日历类（此类使用较少，暂未学习，本文不做讲解）

import java.text.SimpleDateFormat; 
import java.util.Calendar;
import java.util.Date; 
import java.util.GregorianCalendar;

Date类用法

Java提供了Date类来操作时间，该类有两个构造方法

创建时间对象
Date timea = new Date(); // 直接获取当前时间
Date timeb = new Date(1528190965484L); // 参数为从1970年01月01日到当前时间的毫秒数，long类型的参数后面加L

常用方法：
	long tim = timea.getTime(); // getTime()获取从1970年01月01日到当前时间的毫秒数
	boolean tim1 = timea.after(timeb); // timea比timeb晚返回true，否则返回false
	boolean tim2 = timea.before(timeb); // timea比timeb早返回true，否则返回false
	boolean tim3 = timea.equals(timeb); // timea比timeb相等返回true，否则返回false

	compareTo方法
	int tim4 = timea.compareTo(timeb);	// timea比timeb早返回负数，比timeb晚返回正数，相同返回0，如果参数不是Date类型会出现报错，抛出ClassCastException异常
	
把Date类型的时间转换为字符串String类型
	String st = timea.toString();

SimpleDateFormat类用法

SimpleDateFormat类格式化日期:主要用于日期和字符串两种类中之间的转换

创建时间格式对象
SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");

调用format()方法格式化日期，参数为日期，返回值为字符串
String sr = ft.format(timea); 

调用parse()方法将字符串转换为日期格式
Date  date = ft.parse(sr);

测量时间：
System.currentTimeMillis( );

Calendar类用法

Calendar类：设置和获取日期数据的特定部分

Calendar c = Calendar.getInstance();// 创建日历对象并初始化,默认是当前日期
c.set(2009, 6 - 1, 12); // set方法指定该对象的日期
c.get(2); // 获取对象指定字段的值

总结

暂时就写这么多吧，还有其他内容以后再陆续加上