[北海以北]
[北海以北]

JAVASE笔记总结

运算符

算术运算符

+(正号)、-(负号)、+(加)、-(减)、*(乘)、/(除)、%(取模)、++(自增)、–(自减)

赋值运算符

=、+=、-=、*=、/=、%=

比较运算符（关系运算符）

==、!=、<、>、<=、>=

逻辑运算符

&、|、^(异或)、！、&&(短路与)、||(短路或)

位运算符

位运算符是针对二进制数的每一位进行运算的符号，是专门针对数字0和1进行操作的

&(按位与)、|(按位或)、~(取反)、^(按位异或)、<<(左移)、>>(右移)、>>>(无符号右移)

运算符优先级

（大概）：

算数运算符>关系运算符>逻辑运算符>赋值运算符

逻辑非>逻辑与>逻辑或

赋值<三目<逻辑<关系<算术<单目

二元运算符的运算规则

整数运算

1.如果两个操作数有一个是long，则结果也为long。

2.没有long时，结果为int。即使操作数全为short、byte，结果也是int。

浮点运算

1.如果两个操作数有一个为double，则结果为double。

2.只有两个操作数都是float，则结果才是float。

取模运算

1.其操作数可以为浮点数，一般使用整数，结果是“余数”，“余数”符号和左边操作数相同，如：7%3=1，-7%3=-1，7%-3=1。

算术运算符中++，–属于一元运算符，该类运算符只需要一个操作数。

  • ++在前（b=++a）：先运算，再赋值 结果：a=a+1，b=a+1
  • ++在后（b=a++）：先赋值，再运算 结果：b=a，a=a+1
  • –在前（b=–a）：先运算，再赋值 结果：a=a-1，b=a-1
  • –在后（b=a–）：先赋值，再运算 结果：b=a，a=a-1

例题：

//测试自增,自减与之相同
		int a = 3;
		int b = a++;//执行完毕后，b=3，先给b赋值，再自增
		System.out.println("a="+a+"\nb="+b);
		a = 3;
		b = ++a;    //执行完毕后，b=4，a先自增，再给b赋值
		System.out.println("a="+a+"\nb="+b);

选择结构语句

三元运算

判断条件？表达式1：表达式2

通常用于对某一个变量进行赋值，当判断条件成立时，运算结果为表达式1的值，否则结果为表达式2的值

int max = x>y?x:y;

如果x>y结果为true，则输出x，否则输出y

switch语句

遇到多值判断的时候，使用switch，当然，switch完全可以使用if-else if-else代替

	char c = 'a';
		int rand = (int)(26*Math.random());
		char c2 = (char)(c + rand);
		System.out.print(c2 + ":");
		
		switch(c2) {
		case 'a':
		case 'e':
		case 'i':
		case 'o':
		case 'u':
			System.out.println("元音字母");
			break;
		case 'y':
		case 'w':
			System.out.println("半元音字母");
			break;
		default:
			System.out.println("辅音字母");
		}


注：  /*char c = 'a';
		int rand = (int)(26*Math.random());
		char c2 = (char)(c + rand);*/

	   'a'+1==>b
       'a'+2==>c
          ...
       'a'+25==>z

循环结构语句

do…while循环

和while循环不同的是：将循环条件放在循环体后面

循环体会无条件执行一次，然后再根据循环条件决定是否继续执行

for循环

for(初始化表达式;循环条件;操作表达式){

​ 执行语句…

}

循环嵌套

使用“*”打印直角三角形

int i;
		int j;
		for (i=1;i<=6;i++) {		//控制行数	
			for (j=1;j<=i;j++) {    //控制列数
				System.out.print("*");				
			}
			System.out.print("\n");
		}

	}

跳转语句(break、continue)

break语句

  • 在switch条件语句中：用于中止某个case并跳出switch结构

  • 在循环语句中：跳出循环语句，执行后面的代码

  • 当break语句出现在嵌套循环的内层循环时，它只能跳出内层循环，如果想使用break语句跳出外层循环需添加标记：

    		//1.用while输入1-4的自然数，在值为3时跳出循环
		int x = 1;
		while(x<=4) {
			System.out.println("x="+x);
			
			if (x == 3) {
				break;
			}
			
			x++;
		}
		
		//2.控制程序只打印4行“*”（跳出外层循环需标记）
		int i;
		int j;
		stamp:for (i=1;i<=6;i++) {//stamp:标记;标记外层循环			
			for (j=1;j<=i;j++) {
				if (i>4) {
					break stamp; //跳出所标记的外层循环
				}
				System.out.print("*");				
			}
			System.out.print("\n");
		}

continue语句

用于循环语句中，终止本次循环，执行下一次循环

continue也可以使用标记，结束本次外层循环，使用方法和break类似

//对1-100之内的奇数求和
		int sum = 0;
		for(int i=1;i<=100;i++) {
			if (i % 2 == 0) {   //i是偶数，i为偶数时不累加
				continue;      //结束本次循环，执行下一次
			}
			sum += i;
		}
		System.out.println("sum="+sum);


//打印101-150之间所有的质数（跳出外层循环需标记）
		outer:for(int i=101;i<=150;i++) {
			for(int j=2;j<i/2;j++) {
				if (i%j==0) {
					continue outer;
				}
			}
			System.out.println(i+"");

方法

形参、实参

形参：定义方法时使用；实参：调用时使用

修饰符 返回值类型 方法名([参数类型 参数名1，参数类型 参数名2]){

执行语句

...

return返回值;

}

返回值类型：用于限定方法返回值的数据类型

参数类型：用于限定调用方法时传入参数的数据类型

return的作用：1、结束方法的运行；2、返回值

”参数类型 参数名1，参数类型 参数名2“是形式参数列表，可以为空

public static void main(String[] args) {
		int area = getArea(3, 5);			//调用getArea()方法、参数为实参
		System.out.println("面积是："+area); //15
	}
	//下面定义了求矩形面积的方法，接收两个参数，其中x为高，y为宽
	public static int getArea(int x,int y) {参数为形参
		int temp = x*y;
		return temp;
	}

实参的数目、数据类型和次序必须和所调用的方法声明的形式参数列表匹配

方法的重载（overload）

独立的、完全不同的方法，只是名称相同而已

构成重载的条件：

/*求和的方法*/
	public int add(int n1,int n2) {
		int sum = n1+n2;
		return sum;
	}

  1. ​ 不同的含义：形参类型、个数、顺序不同

  2. ​ 只有返回值不同，不构成方法的重载

    //编译错误：只有返回值不同，不构成方法的重载
	public double add(int n1,int n2) {
		int sum = n1+n2;
		return sum;
	}

  3. ​ 只有形参名称不同，不构成方法的重载

    //编译错误：只有参数名称不同，不构成方法的重载
	public int add(int n2,int n1) {
		double sum = n1+n2;
		return sum;
	}

方法的递归（recursion）

递归：递推、回归

1.定义递归头：递归的结束条件

2.递归体：什么时候需要调用自身方法

递归非常消耗资源，尽量不要使用

数组

定义：

int[] x=new int[100];

赋值方式：

//1.无赋值
int[] arr;           //声明变量
arr=new int[3];      //创建数组对象，结果0，0，0

//2.部分赋值
int[] arr=new int[3];//定义可以存储3个整数的数组
arr[0]=1;            //为数组第一个元素赋值1
arr[1]=2;            //为数组第二个元素赋值2，结果1，2，0

//3.数组赋值
int[] arr={1,2,3,4};  //直接赋值，结果1，2，3，4
int[] arr=new int[]{1,2,3,4} //建议用上面的直接赋值

可以通过“数组名.length”的方式来获取数组的长度（元素的个数）

每个数组的下标都有范围：0——length-1

int[] arr= {1,2,3,4};   //静态初始化
		
//每个数组的下标都有范围：0——length-1
System.out.println("数组的第一个元素是："+arr[0]);//1
System.out.println("数组的第二个元素是："+arr[1]);//2
System.out.println("数组的第三个元素是："+arr[2]);//3
System.out.println("数组的第四个元素是："+arr[3]);//4

System.out.println("数组的长度是："+arr.length);//4

数组的遍历

	int[] arr01= {1,2,3,4,5,6,7,8,9,10};
	for(int i=0;i<arr01.length;i++) {
		System.out.print(arr01[i]);
	}

增强for循环

**for-each（JDK1.5新增功能）：**专门用于读取数组或集合中的所有元素

public class TestArray_foreach {
	public static void main(String[] args) {
		int[] a = {3,5,9,6,7};
		//for-each循环：用于读取数组元素的值，不能修改元素的值
		for(int m:a) {
			System.out.println(m);
		}
	}
}

数组的最值

/**定义一个求数组最大值的方法*/
static int getMax(int[] arr02) {
		int max = arr02[0];//定义数组arr02的第一个元素为最大值
		for(int x=1;x<arr02.length;x++) {
			if (arr02[x]>max) {
				max = arr02[x];
			}
		}
		return max;
	}
public static void main(String[] args) {
		/**调用求数组最大值的方法*/
		int[] arr02= {4,1,3,9};
		int max = getMax(arr02);
		System.out.println("最大值:"+max);
	}

数组的排序（冒泡排序法）

/**
 * 测试冒泡法及其优化
 * @author 李宇辉
 *
 */
public class TestBubbleSort {
	public static void main(String[] args) {
		int[] values = {9,8,6,4,3,5,6,0,1};
		for(int i=0;i<values.length-1;i++) {
			boolean flag = true;
			for(int j=0;j<values.length-1-i;j++) {
				if (values[j]>values[j+1]) {
					int temp = values[j];
					values[j] = values[j+1];
					values[j+1] = temp;
					flag=false;
				}
				System.out.println(Arrays.toString(values));
			}
			if (flag) {
				System.out.println("循环结束！！！");
				break;
			}
			System.out.println("本轮循环结束");
		}
	}
}



/**
 * 冒泡法
 */
public static void main(String[] args) {
	int[] arr={5,7,9,8,6,2,4};
	System.out.println("冒泡排序前：");
	printArray(arr);  //打印数组元素
	bubbleSort(arr);  //调用排序方法
		
	System.out.println("冒泡排序后：");
	printArray(arr);  //打印数组元素
}

/**定义一个打印数组的方法*/
public static void printArray(int[] arr) {
	//遍历
	for(int i=0;i<arr.length;i++) {
		System.out.print(arr[i]+" ");
	}
	System.out.print("\n");
}
	
/**定义数组排序的方法*/
public static void bubbleSort(int[] arr) {
	//外层循环
	for(int i=0;i<arr.length-1;i++) {
		//内层循环
		for(int j=0;j<arr.length-i-1;j++) {
			if (arr[j]>arr[j+1]) {//相邻对比
				int a=arr[j];
				arr[j]=arr[j+1];
				arr[j+1]=a;
			}
		}
		System.err.println("第"+(i+1)+"轮排序后：");
		printArray(arr);//每轮比较结束后打印数组元素
	}
}

二分法查找（前提：排过序的数组）

/**二分法查找(折半索引)*/
public class TestBinarySearch {
	public static void main(String[] args) {
		int arr[] = {20,15,36,45,99,77,35,66,54,100,22,7,97};
		Arrays.sort(arr);
		System.out.println(Arrays.toString(arr));
		/**下方()里面第二个是要查找的元素*/
		System.out.println(myBinarySearch(arr,35));
	}
	public static int myBinarySearch(int[] arr,int value) {
		int low = 0;              //定义最左端的元素
		int high = arr.length-1;  //定义最右端的元素
		while(low<=high) {
			int mid=(low+high)/2; //定义一个中间数
			if (value==arr[mid]) {
				return mid;
			}else if (value<arr[mid]) {
				high = mid-1;     //中间数左边的元素到mid-1结束
			}
			else {
				low = mid+1;      //中间数右边的元素从mid+1开始
			}
		}
		return -1;                //没有找到该元素
	}
}

多维数组

//第一种
int[][] arr=new int[3][4];  //3*4的二维数组
//第二种
int[][] arr=new int[3][];  //每个元素长度不确定
//第三种
int[][] arr={{1,2},{3,4,5,6},{7,8,9}};//包含三个数组

面向对象（object）

面向对象的特征

封装、继承、多态

面向对象和面向过程的总结

  1. 都是解决问题的思维方式，都是代码组织的方式
  2. 解决简单问题可以使用面向过程
  3. 解决复杂问题：宏观上使用面向对象把握，微观处理上仍然是面向过程

类和对象

类：class

对象：object，instance(实例)

类是对象的抽象，用于描述一组对象的共同特征和行为

对象是类的实例

• 定义类（类的组成）

  • 属性 field
  • 方法 method
  • 构造方法 construtor
  • 其他：代码块 静态代码块 内部类

成员变量

定义在类中的变量称为成员变量

局部变量

定义在方法内部的变量称为局部变量

• 创建对象

  • 类名 对象名 = new 类名();
  • Person p1=new Person();

• 调用类的属性和方法

  • 对象名.成员变量
  • 对象名.成员方法

一个java程序可以有多个类，但只能有一个public修饰的类

public class Stu {  //学生类
	//属性fields
	int id;
	int age;
	String name;
	Computer comp; //计算机
	//方法
	void study() {
		System.out.println("我在认真学习"+"使用："+comp.brand+"学java");
	}	
	void play() {
		System.out.println("打游戏");
	}
	//构造方法，用于创建这个类的对象，无参的构造方法可以由系统自动创建
	Stu(){	
	}	
	public static void main(String[] args) {
		Stu stu = new Stu();     //创建一个对象
		stu.id = 138439;
		stu.age = 22;
		stu.name = "李宇辉";	
		Computer c1 = new Computer();
		c1.brand = "惠普";
		stu.comp = c1;	
		stu.play();
		stu.study();
	}
}
class Computer{
	String brand;
}

内存分析

java虚拟机的内存可以分为三个区域：栈stack、堆heap、方法区method area

• 栈

  • 存放：局部变量
  • 先进后出，自下而上存储
  • 方法执行完毕，自动释放空间

• 堆

  • 存放new出来的对象
  • 需要垃圾回收器来回收

• 方法区

​ 存放永远不变或唯一的内容：类的信息(代码)、 static变量、字符串常量等.

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2qwjGslm-1597227817631)(D:\workspace\Test\src\com\lyh\the_third_chapter\Stu.java.png)]

构造器/构造方法（constructor）

构造器，又叫构造方法，用于对象的初始化

要点

  1. 通过new关键字调用(创建对象时)
  2. 构造器虽然有返回值，但是不能定义返回值类型（返回值的类型肯定是本类），不能在构造器里使用return返回某个值
  3. 如果没有定义构造器，则编译器会自动定义一个无参的构造函数；如果已定义则编译器不会自动添加
  4. 构造器的方法名必须和类名一致
/*定义一个“点”（Point）类用来表示二维空间中的点（有二个坐标）。要求如下： 
	• 可以生成具有特定坐标的点对象。 
	• 提供可以设置二个坐标的方法。 
	• 提供可以计算该“点”距另外点距离的方法。
*/
class Point{
	double x,y;	
	//构造器的方法名必须和类名一致
	public Point(double _x,double _y) {
		x = _x;
		y = _y;
	}	
	public double getDistance(Point p) { //测量距离s
		return Math.sqrt((x-p.x)*(x-p.x)+(y-p.y)*(y-p.y));//两点间距离公式：根号下（x2-x1）的平方+（y2-y1）的平方
	}
}
public class TestConstructor {
	public static void main(String[] args) {
		Point p = new Point(3.0, 4.0);
		Point origin = new Point(0.0, 0.0);//原点：origin
		System.out.println(p.getDistance(origin));
	}
}

构造方法的重载

与方法重载相同

public class User {
	int id;     //id
	String name;//账户名
	String pwd; //密码
	public User() {	
	}
	public User(int id,String name) {
		super();
		this.id = id;
		this.name = name;
	}
	public User(int id,String name,String pwd) {
		this.id = id;
		this.name = name;
		this.pwd = pwd;
	}
	public static void main(String[] args) {
		User u1 = new User();
		User u2 = new User(101,"李宇辉");
		User u3 = new User(100,"李宇飞","123456");
	}
}

垃圾回收机制（Garbage Collection）

  1. 发现无用的对象
  2. 回收无用的对象占用的空间

垃圾回收相关算法：

  1. 引用计数法
  2. 引用可达法（根搜索算法）

开发中容易造成内存泄露的操作

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rsEj4RiL-1597227817638)(D:\workspace\Test\src\com\lyh\the_third_chapter\开发中容易造成内存泄露的操作.png)]

this关键字

this的本质就是”创建好的对象的地址“，由于在构造方法调用前，对象已经创建，因此，在构造方法中也可以使用this代表”当前对象“

this的常用方法：

  1. 在程序中产生二义性处，应使用this来指明当前的对象。普通方法中，this总是指向调用该方法的对象；构造方法中，this总是指向正要初始化的对象
  2. 使用this关键字调用重载的构造方法，避免相同的初始化代码。但只能在构造方法中用，并且必须位于构造方法的第一句
  3. this不能用于static方法中

static关键字

可以使用static关键字来修饰的成员变量成为静态变量，静态变量被所有实例所共享。可以使用**“类名.变量名”**的形式来访问。

注：只能用于修饰成员变量，不能用于修饰局部变量

不能调用非静态成员

public class User02 {
	int id;     //id
	String name;//账户名
	String pwd; //密码
	static String company = "李氏集团";
	public User02(int id,String name) {
		this.id=id;
		this.name=name;
	}
	public void login() {
		System.out.println("登录："+name);
	}
	public static void printCompany() {
		//login();//调用非静态成员，编译会报错
		System.out.println(company);
	}
	public static void main(String[] args) {
		User02 u = new User02(101,"李宇辉");
		User02.printCompany();
		User02.company="西安李氏";
		User02.printCompany();
	}

}

静态代码块

当类被加载时，静态代码块会执行，由于类只加载一次，因此静态代码块也只执行一次。

静态代码块执行顺序：

  1. 上溯到Object类，先执行Object的静态初始化块，再向下执行子类的静态初始化块，直到我们类的静态初始化块为止。
  2. 构造方法执行顺序和上面顺序一样。

单例模式

单例模式是指在设计一个类时，需要保证在整个程序运行期间针对该类只存在一个实例对象

public class TestSingle {//测试单例模式
	public static void main(String[] args) {
		Single s1 = Single.getInstance();
		Single s2 = Single.getInstance();
		System.out.println(s1 == s2);
	}
}
class Single{//单例
	private static Single INSTANCE = new Single();   //创建一个对象
	private Single() {                               //私有构造方法
		
	}
	public static Single getInstance() {             //提供返回该对象的静态方法
		return INSTANCE;
	}
}

内部类

成员内部类

一个类中除了可以定义成员变量、成员方法、还可以定义类，这样的类被称为成员内部类

在成员内部类中可以访问外部类的所有成员：

public class InnerMember {
	public static void main(String[] args) {
		Outer outer = new Outer();//创建外部类对象
		outer.test();             //调用test方法
	}
}
class Outer{               //定义外部类
	private int num=4;     //定义外部类的成员变量
	/**下面的代码定义了一个成员方法，方法中访问内部类*/
	public void test() {
		Inner inner = new Inner();
		inner.show();
	}	
	class Inner{           //定义内部类
		void show() {
			System.out.println("num="+num);//在成员内部类的方法中访问外部类的变量num
		}
	}
}

通过外部类访问内部类：

外部类名.内部类名 变量名=new 外部类名().内部类名();

public class TestOuter{  //接上一例题
    public static void main(String[] args){
        Outer.Inner inner = new Outer().Inner(); //创建内部类对象
        inner.show();                            //调用show()方法
    }
}

静态内部类

用static修饰的类，可以在不创建外部类对象的情况下被实例化

外部类名。内部类名 变量名=new 外部类名.内部类名();

public class InnerStatic {
	public static void main(String[] args) {
		Outer02.Inner02 inner02 = new Outer02.Inner02();//创建内部类对象
		inner02.show();//调用内部类方法
	}
}
class Outer02{
	private static int num=6;
	/**下面的代码定义了一个静态内部类*/
	static class Inner02{
		void show() {
			System.out.println("num="+num);
		}
	}
}

方法内部类

在成员方法中定义的类，只能在当前方法中被使用

public class InnerMethod {
	public static void main(String[] args) {
		Outer03 ou = new Outer03();
		ou.test();
	}
}
class Outer03{
	private int num =10;
	/**下面是在方法中定义的内部类*/
	void test() {
		class Inner03{
			void show() {
				System.out.println("num="+num);
			}
		}
		Inner03 in = new Inner03();
		in.show();
	}
}

import

package com.lyh.the_third_chapter;
import com.lyh.test.Constant;
public class TestImport {
	public static void main(String[] args) {
//		com.lyh.test.Constant c = new com.lyh.test.Constant();//这样子写特别繁琐
		Constant c = new Constant();
	}
}


//注：Constant在com.lyh.test包下

静态导入(JDK1.5新功能)

import static java.lang.Math.*;     //导入Math下的静态属性
public class TestStaticImport {
	public static void main(String[] args) {
		System.out.println(Math.PI); //静态导入前
		
		System.out.println(PI);      //静态导入后
	}
}

继承

  • 父类也称为派生类、超类、基类等
  • java中只有单继承，接口有多继承
  • 子类继承父类，可以得到父类的全部属性和方法（构造方法除外），但不见得可以直接访问（如：父类私有的属性和方法）
  • 如果定义一个类时，没有调用extands，则它的父类是：java.lang.Object

eclipse中可以使用crtl+t查看类的继承结构

instanceof运算符

instanceof是二元运算符，左边是对象，右边是类；当对象是右边类或子类所创建的对象时，返回true，否则false，如：

public class Test{
    public static void main(String[] args){
        Student s = new Student("罗小黑",155，“java);
        System.out.println(s instanceof Person); //true
        System.out.println(s instanceof Student);//true
    }
}

方法的重写（override）

子类通过重写父类的方法，可以用自身的行为替换父类的行为

重写的三个要点：

  1. ”==“：方法名、形参列表相同
  2. “<=”：返回值类型和声明异常类型，子类小于等于父类
  3. “>=”：访问权限，子类大于等于父类

封装

  • 提高代码安全性
  • 提高代码的复用性
  • “高内聚”：封装细节，便于修改内部代码，提高可维护性
  • “低耦合”：简化外部调用，便于调用者使用，便于扩展和协作

访问控制符

private：表示私有，只有自己类能访问

default：表示没有修饰符修饰，只有同一个包的类能访问

protected：表示可以被同一个包中的类以及其他包的子类访问

public：表示可以被该项目中的所有包中的类访问

修饰符 同一个类 同一个包中 子类(不同包) 所有类
private *
default * *
protected * * *
public * * * *

封装使用细节

  • 一般使用private访问权限
  • 提供相应的get/set方法来访问相关属性，这些方法通常是public修饰的，以提供对属性的赋值与读取操作（注意：boolean变量的get方法是以is开头）
  • 一些只用于本类的辅助性方法可以用private修饰，希望其他类调用的方法使用public修饰

多态

  1. 多态是方法的多态，不是属性的多态（与属性无关）
  2. 多态的存在要有3个必要条件：继承、方法重写、父类引用指向子类对象（向上转型）
  3. 父类引用指向子类对象后，用该父类引用调用子类重写的方法时，此时多态就出现了
public class TestPolym {
	public static void main(String[] args) {
		Animal a = new Animal();
		animalCry(a);        //输出：	叫了一声
		
//		Dog dog = new Dog();
        Animal dog = new Dog();   /**自动向上转型*/
		animalCry(dog);      //输出：汪汪汪，叫了三声
		
        Dog d2 = (Dog)dog;        /**强制向下转型*/
		d2.seeDoor();
        
		animalCry(new Cat());//输出：喵喵，叫了两声
	}
	
	static void animalCry(Animal a) {
		a.shout();
	}
}
class Animal{
	public void shout() {
		System.out.println("叫了一声");
	}
}
class Dog extends Animal{
	public void shout() {
		System.out.println("汪汪汪，叫了三声");
	}
	public void seeDoor() {
		System.out.println("看门！");
	}
}
class Cat extends Animal{
	public void shout() {
		System.out.println("喵喵，叫了两声");
	}
}

final关键字

  1. 修饰变量：被它修饰的变量不可变（常量）。一旦赋了初值，就不能重新赋值

    final int MAX_SPEED = 120;

  2. 修饰方法：该方法不可被子类重写，但是可以被重载

    final void study(){}

  3. 修饰类：修饰的类不能被继承。比如：Math、Sting等。

    final class A{}

抽象类

  1. 抽象类不能被实例化
  2. 如果有一个类有抽象方法，那么这个类称为抽象类
  3. 继承抽象类的子类必须对抽象类的方法做实现

抽象方法

  1. 不包含方法体的方法称为抽象方法，必须使用abstract关键字来修饰,使用abstract修饰的类称为抽象类；
  2. 包含抽象方法的类一定是抽象类，但抽象类可以不包含任何抽象方法；
  3. 抽象类不可以被实例化；
  4. 若想要实现抽象类中定义的方法，需要创建一个子类，在子类中将抽象类中的抽象方法进行实例
abstract class TestAbstract{
	public static void main(String[] args) {
		Dog02 dog = new Dog02();     //创建Dog02类的实例对象
		dog.shout();                 //调用dog对象的shout()方法
	}
}
abstract class Animal02{            //定义抽象类Animal02
    abstract void shout();          //定义抽象方法shout()
}
class Dog02 extends Animal02{       //定义Dog02继承抽象类Animal02
	void shout() {                   //实现抽象方法shout()
		System.out.println("汪汪。。。");
	}
}

接口（interface）

  • 接口中定义的方法默认用“public abstract”来修饰，即抽象方法
  • 接口中的变量默认用“public static final”来修饰，即全局常量

接口用implenment实现:

public class TestInterface {
	public static void main(String[] args) {
	/*	Volant volant = new Angle();
		volant.fly();
		Honest honest = new GoodMan();
		honest.helpOther();*/
		Angle angle = new Angle();
		angle.fly();
		angle.helpOther();
		GoodMan goodMan = new GoodMan();
		goodMan.helpOther();
		BirdMan birdMan = new BirdMan();
		birdMan.fly();
	}
}
/**
 * 飞行接口
 * @author 李宇辉
 *
 */
interface Volant{
	int FLY_HEIGHT = 1000;
	void fly();
}
//善良接口
interface Honest{
	void helpOther();
}
class Angle implements Volant,Honest{//实现类可以实现多个父接口
	@Override
	public void fly() {
		System.out.println("Angle.Fly()");
	}
	@Override
	public void helpOther() {
		System.out.println("Angle.helpOther()");
	}
}
class GoodMan implements Honest{
	public void helpOther() {
		System.out.println("GoodMan.helpOther()");
	}
}
class BirdMan implements Volant{
	public void fly() {
		System.out.println("BirdMan.Fly()");
	}
}

异常

数组越界异常：ArryIndexOutOfBoundsException
空指针异常：NullPointerException
类型转换异常：ClassCastException
不能加载所需的类:ClassNotFoundException
欲得到数据类型与实际输入类型不匹配:InputMismatchException
方法接收到非法参数:IllegalArgumentExceptio
数字格式转换异常，如把"ab"转换成数字:NumberFormatException
算术错误情形(如以零作除数):ArithmeticException

try-catch处理异常

public class Test01 {
	public static void main(String[] args) {
		readMyFile();
	}
	public static void readMyFile() {
		FileReader reader = null;
		try {
			reader = new FileReader("D:/JAVA基础视频/java300/06_异常机制/测试文档.txt");
			System.out.println("1");
			char c1 = (char)reader.read();
			System.out.println(c1);
			
		} catch (FileNotFoundException e) {//子类异常要在父类异常前面
			System.out.println("2");
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			System.out.println("3");
			try {
				reader.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

throws声明异常（谁调给谁抛）

public class Test02 {
	public static void main(String[] args) throws IOException {
		readMyFile();
	}
	public static void readMyFile() throws IOException {
		FileReader reader = null;
		reader = new FileReader("D:/测试文档.txt");
		System.out.println("1");
		char c1 = (char)reader.read();
		System.out.println(c1);
		if (reader!=null) {
			reader.close();
		}
	}
}

容器(集合类)

泛型

泛型的本质就是“数据类型的参数化”。

可以把“泛型”理解为数据类型的一个占位符(形参)，即告诉编译器，在调用泛型时必须传入实际类型。

public class TestGeneric {
	public static void main(String[] args) {		
		MyCollection<String> mc = new MyCollection<String>();
		mc.set("罗小黑战记", 0);
		mc.set("某某某战机", 1);
		String a = mc.get(0);
	}
}
class MyCollection<E>{
	Object[] o = new Object[5];
	public void set(E e,int index) {//设置内容，索引
		o[index] = e;
	}
	public E get(int index) {       //获取索引
		return (E)o[index];
	}
}

List

有序、可重复的集合

List接口常用的实现类：ArrayList（数组）、LinkedList（链表）、Vector

数组：占用空间连续，寻址容易，查询速度快，但是增删效率低

链表：占用空间不连续，寻址困难，查询速度慢，但是增删效率高

Set

无序、不可重复

HashSet、TreeSet等

List的方法（Collection的方法）

/**
 * 测试Collection接口中的方法
 * @author 李宇辉
 */
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

public class TestList {
	public static void main(String[] args) {	
		test01();
		test02();
	}
	public static void test01() {
		Collection<String> c = new ArrayList<String>();
		System.out.println(c.size());//该方法用于判断集合长度
		System.out.println(c.isEmpty());//该方法用于判断是否为空
		c.add("罗小黑");
		c.add("罗小白");
		System.out.println(c);
		System.out.println(c.size());
		System.out.println(c.contains("洛伊"));//该方法用于判断这个元素是否包含在此集合中
		
		Object[] object = c.toArray();//该方法用于转换为Object数组
		System.out.println(object);
		
		c.remove("罗小白");//该方法仅用于移除集合内的地址，对象仍然存在
		System.out.println(c);
		c.clear();//该方法用于清空集合
		System.out.println(c.size());
	}
	
	public static void test02() {
		List<String> list01 = new ArrayList<String>();
		list01.add("aa");
		list01.add("bb");
		list01.add("cc");
		List<String> list02 = new ArrayList<String>();
		list02.add("aa");
		list02.add("dd");
		list02.add("ee");
		
		System.out.println("list01:"+list01);
//		list01.addAll(list02);//该方法用于将另一个集合的所有元素加进来
//		list01.removeAll(list02);//该方法用于删除两个集合中相同的元素
		list01.retainAll(list02);//该方法用于删除两个集合中不相同的元素（保留交集）
		System.out.println("list01:"+list01);
		System.out.println(list01.containsAll(list02));//该方法用于判断是否包含另一个集合的所有元素		
	}
}

索引位置的方法

public static void test03() {
	List<String> list = new ArrayList<>();
	list.add("A");
	list.add("B");
	list.add("C");
	list.add("D");
	System.out.println(list);
	list.add(2, "张三");//在索引为2处添加一个元素：张三
	System.out.println(list);
	list.remove(2);//移除索引为2处的元素
	System.out.println(list);
	list.set(2, "李四");//在索引为2处设置(修改)元素为：李四
	System.out.println(list);
	System.out.println(list.get(2));//获取索引为2处的元素		
	list.add("C");
	list.add("B");
	list.add("A");
	System.out.println(list);		
	System.out.println(list.indexOf("B"));//indexOf返回指定元素第一次出现的位置，没有则返回-1
  System.out.println(list.lastIndexOf("B"));//lastIndexOf返回指定元素最后一次出现的位置，没有则返回-1	
}

Map

Map就是用来存储"键(key)值(value)对 "的，Map类中的"键值对"通过键来标识，所以"键对象"不能重复

Map接口的实现类有HashMap、TreeMap、HashTable、Propertise等

HashMap与HashTable的区别：

HashMap：线程不安全，效率高，允许key或value为空

HashTable：线程安全，效率低，不允许key或value为空

Map接口中常用的方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RPrOVHdm-1597227817649)(D:\JAVA基础视频\java300\07_容器和数据结构\资料\Map接口中常用的方法.png)]

public class TestMap {
	public static void main(String[] args) {
		Map<Integer,String> m1 = new HashMap<Integer, String>();
		m1.put(1, "one");
		m1.put(2, "two");
		m1.put(3, "three");
		
		System.out.println(m1.get(1));
		
		System.out.println(m1.size());//长度
		System.out.println(m1.isEmpty());//是否为空
		System.out.println(m1.containsKey(2));//是否包含键2
		System.out.println(m1.containsValue("four"));//是否包含值"four"
		
		Map<Integer,String> m2 = new HashMap<>();
		m2.put(4, "四");
		m2.put(5, "五");
		
		m1.putAll(m2);
		System.out.println(m1);
		
		//Map中键不能重复如果重复(是否重复是根据equals方法)，则新的覆盖旧的
		m1.put(3, "三");
		System.out.println(m1);
	}
}

迭代器（Iterator）

迭代器一般写在for循环中

迭代器遍历List：

public class TestIterator {
	public static void main(String[] args) {
		testIteratorList();
	}
	
	public static void testIteratorList() {
		List<String> list = new ArrayList<>();
		list.add("aa");
		list.add("bb");
		list.add("cc");	
		/**使用Iterator遍历List*/
		for(Iterator<String> it = list.iterator();it.hasNext();) {//获得迭代器。list.iterator()相当于初始化
			String temp = it.next();
			System.out.println(temp);
		}
	}
}

迭代器遍历Set：

public class TestIterator {
	public static void main(String[] args) {
		testIteratorSet();
	}
	public static void testIteratorSet() {
		Set<String> set = new HashSet<>();
		set.add("aa");
		set.add("bb");
		set.add("cc");	
		/**使用Iterator遍历Set*/
		for(Iterator<String> it2 = set.iterator();it2.hasNext();) {//获得迭代器，list.iterator()相当于初始化
			String temp = it2.next();
			System.out.println(temp);
		}
	}
}

迭代器遍历Map：

public class TestIterator {
	public static void main(String[] args) {
		testIteratorMap();
	}
	public static void testIteratorMap() {
		Map<Integer, String> map1 = new 		HashMap<Integer, String>();
		map1.put(100,"aa");
		map1.put(200,"bb");
		map1.put(300,"cc");
		/**使用Iterator遍历Map*/
		//第一种遍历Map的方式
		Set<Entry<Integer, String>> ss = map1.entrySet();
		for(Iterator<Entry<Integer, String>> iter = ss.iterator();iter.hasNext();) {//获取迭代器
			Entry<Integer, String> temp = iter.next();
			System.out.println(temp.getKey()+"---"+temp.getValue());
		}	
		//第二种遍历Map的方式
		Set<Integer> keySet = map1.keySet();
		for(Iterator<Integer> iter=keySet.iterator();iter.hasNext();) {
			Integer key = iter.next();
			System.out.println(key+"---"+map1.get(key));
		}
	}
}

遍历各种集合的方法汇总

遍历List的方法汇总：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rd477aNx-1597227817654)(D:\JAVA基础视频\java300\07_容器和数据结构\资料\遍历List的方法汇总.png)]

遍历Set的方法汇总：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-L63giWAi-1597227817655)(D:\JAVA基础视频\java300\07_容器和数据结构\资料\遍历Set的方法汇总.png)]

遍历Map的方法汇总：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6qfLV23s-1597227817656)(D:\JAVA基础视频\java300\07_容器和数据结构\资料\遍历Map的方法汇总.png)]

Collections工具类

Collection是接口，Collections是工具类

public class TestCollections {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		for(int i=0;i<10;i++) {
			list.add("李："+i);
		}
		System.out.println(list);
		
		Collections.shuffle(list);//随机排列list中的元素
		System.out.println(list);
		
		Collections.reverse(list);//逆序排列
		System.out.println(list);
		
		Collections.sort(list);   //按照递增的方式排序，自定义的类使用：Collection接口
		System.out.println(list);
		
		System.out.println(Collections.binarySearch(list, "李：3"));//二分法查找（折半查找）
	}
}

多线程

程序、进程、线程

在操作系统中运行中的程序就是进程，如看视频

一个进程可以有多个线程，如视频中同时听声音、看图像、显示字幕

如何进行多线程

  • 继承Thread类

    ​ 1.重写run方法

    ​ 2.调用start方法

    package cn.lyh.thread;
/**
 * 创建线程方式一
 * 1.创建：继承Threda类+重写run方法
 * 2.启动：创建子类对象+调用start方法
 * @author 李宇辉
 *
 */
public class StartThread extends Thread{//继承Threda类
	/**
	 * 线程入口点
	 */
	@Override //重写run方法
	public void run() {
		for(int i=0;i<20;i++) {
			System.out.println("听歌");
		}
	}
	public static void main(String[] args) {
		//创建子类对象
		StartThread st = new StartThread();
		//启动
		st.start();//不保证会立即运行，由cpu调用，多线程
		//st.run();//普通方法调用，单线程
		for(int i=0;i<20;i++) {
			System.out.println("写作业");
		}
	}
}

  • 实现Runnable接口（常用）

    ​ 1.重写run方法

    ​ 2.new 一个Thread对象，调用start方法（new Thread().start()）

    package cn.lyh.thread;
/**
 * 创建线程方式二
 * 1、创建：实现Runnable+重写run
 * 2、启动: 创建实现类对象 +Thread对象+ start
 * 
 * 推荐: 避免单继承的局限性，优先使用接口
 * 方便共享资源
 * @author 李宇辉
 *
 */
public class StartRun implements Runnable{
	/**
	 * 线程入口点
	 */
	@Override
	public void run() {
		for(int i=0;i<20;i++) {
			System.out.println("一边听歌");
		}
	}
	public static void main(String[] args) {			
		/*//创建实现类对象
		StartRun sr =new StartRun();
		//创建代理类对象
		Thread t =new Thread(sr);
		//启动 
		t.start(); //不保证立即运行 cpu调用
*/		
		new Thread(new StartRun()).start();
		//st.run(); //普通方法调用
		for(int i=0;i<20;i++) {
			System.out.println("一边coding");
		}
	}
}

  • 实现Callable接口（juc）

线程方法

  • sleep()
    • 使线程停止运行一段时间，将处于阻塞状态
    • 如果调用了sleep方法后，没有其他等待执行的线程，这个时候当前线程不会马上恢复执行！
  • join()
    • 阻塞指定线程等到另一个线程完成以后再执继续行
  • yield()
    • 让当前正在执行的线程暂停，不是阻塞线程，而是将线程转入就绪状态
    • 调用了yield方法后，如果没有其他等待执行的线程，此时当前线程就会马上恢复执行
  • setDaemon()
    • 可以将指定的线程设置为后台线程，守护线程
    • 创建用户线程的线程结束时，后台线程也随之消亡
    • 只能在线程启动之前把它设为后台线程
  • setPriority(int newPriority) getPriority()
    • 线程的优先级代表的是概率
    • 范围从1到10，默认为5
  • stop()停止线程（不推荐使用）

网络编程

InetAddress类：有多个静态方法

1、getLocalHost：本机

2、getByName：根据域名DNS|IP地址—>IP

两个成员方法：

1、getHostAddress：返回地址

2、getHostName：返回计算机名

端口

cmd命令下：

  • 查看所有端口：netstat-ano
  • 查看指定端口：netstat-ano|findstr"808"
  • 查看指定进程：tasklist|findstr"2676"（2676–>PID）
  • 查看具体程序：使用任务管理器查看PID

InetSocketAddress类

  • 该类实现了IP套接字地址（IP地址+端口号）它也可以是一对（主机名+端口号），在这种情况下，将尝试解析主机名。如果解决失败然后地址说是未解决的但仍可以使用在某些情况下，如通过代理连接。
  • 它提供了一个不可变的对象，用于绑定、连接或作为返回值的套接字使用。
  • 通配符是一种特殊的IP地址。这通常意味着“任何”只能用于bind操作。

InetSocketAddress类：父类为SocketAddress

1、构造器

​ new InetSocketAddress(地址|域名,端口)；

2、方法

​ getAddress()

​ getPort()

​ getHostName()

URL

Universal Resource Locator 统一资源定位符，一种定位资源的主要访问机制的字符串，一个标准的URL必须包括：

protocol、host、port、path、parameter、anchor

import java.net.MalformedURLException;
import java.net.URL;
/**
 * 测试URL
 * 1、协议
 * 2、域名、计算机
 * 3、端口：默认80
 * 4、请求资源：
 * http://www.baidu.com:80/index.html?uname=shsxt&age=18#a
 * @author 李宇辉
 */
public class TestURL {
	public static void main(String[] args)throws MalformedURLException{
	    URL url = new URL("http://www.baidu.com:80/index.html?uname=shsxt&age=18#a");
	    //获取四个值
	    System.out.println("协议:"+url.getProtocol());//"http"
	    System.out.println("域名|ip:"+url.getHost());//"www.baidu.com"
	    System.out.println("端口:"+url.getPort());//"80"
	    System.out.println("请求资源1:"+url.getFile());//"/index.html?uname=shsxt&age=18"
	    System.out.println("请求资源2:"+url.getPath());//"/index.html"

	    //参数
	    System.out.println("参数:"+url.getQuery());//"uname=shsxt&age=18"
	    //锚点
	    System.out.println("锚点:"+url.getRef());//"a"
	}
}

Web Spider(爬虫)

/**
 * 测试爬虫
 * @author 李宇辉
 *
 */
public class TestWebSpider {
	public static void main(String[] args) throws Exception {
		//获取URL
		URL url = new URL("https://www.jd.com");
		//下载资源
		InputStream is = url.openStream();
		BufferedReader br = new BufferedReader(new InputStreamReader(is,"UTF-8"));
		String msg=null;
		while(null!=(msg=br.readLine())) {
			System.out.println(msg);
		}
		br.close();
		//分析
		//处理
	}
}

接字使用。

  • 通配符是一种特殊的IP地址。这通常意味着“任何”只能用于bind操作。

InetSocketAddress类：父类为SocketAddress

1、构造器

​ new InetSocketAddress(地址|域名,端口)；

2、方法

​ getAddress()

​ getPort()

​ getHostName()

URL

Universal Resource Locator 统一资源定位符，一种定位资源的主要访问机制的字符串，一个标准的URL必须包括：

protocol、host、port、path、parameter、anchor

import java.net.MalformedURLException;
import java.net.URL;
/**
 * 测试URL
 * 1、协议
 * 2、域名、计算机
 * 3、端口：默认80
 * 4、请求资源：
 * http://www.baidu.com:80/index.html?uname=shsxt&age=18#a
 * @author 李宇辉
 */
public class TestURL {
	public static void main(String[] args)throws MalformedURLException{
	    URL url = new URL("http://www.baidu.com:80/index.html?uname=shsxt&age=18#a");
	    //获取四个值
	    System.out.println("协议:"+url.getProtocol());//"http"
	    System.out.println("域名|ip:"+url.getHost());//"www.baidu.com"
	    System.out.println("端口:"+url.getPort());//"80"
	    System.out.println("请求资源1:"+url.getFile());//"/index.html?uname=shsxt&age=18"
	    System.out.println("请求资源2:"+url.getPath());//"/index.html"

	    //参数
	    System.out.println("参数:"+url.getQuery());//"uname=shsxt&age=18"
	    //锚点
	    System.out.println("锚点:"+url.getRef());//"a"
	}
}

Web Spider(爬虫)

/**
 * 测试爬虫
 * @author 李宇辉
 *
 */
public class TestWebSpider {
	public static void main(String[] args) throws Exception {
		//获取URL
		URL url = new URL("https://www.jd.com");
		//下载资源
		InputStream is = url.openStream();
		BufferedReader br = new BufferedReader(new InputStreamReader(is,"UTF-8"));
		String msg=null;
		while(null!=(msg=br.readLine())) {
			System.out.println(msg);
		}
		br.close();
		//分析
		//处理
	}
}

你可能感兴趣的:(笔记,java)

  • 伯克利 CS61A 课堂笔记 01 —— Computer Science 东方芷兰 CS61A笔记笔记python
    01WhatisComputerScience?02WhatisThisCourseAbout?Acourseaboutmanagingcomplexity管理复杂度MasteringabstractionProgrammingparadigmsAnintroductiontoprogramming编程介绍FullunderstandingofPythonfundamentalsCombining
  • 使用 Axios 获取用户数据并渲染——个人信息设置 还是鼠鼠 javascriptbootstrapajax前端vscode前端框架html5
    目录1.HTML部分（前端页面结构）HTML结构解析：2.JavaScript部分（信息渲染逻辑）JavaScript解析：3.完整流程4.总结5.适用场景本文将介绍如何通过Axios从服务器获取用户信息，并将这些信息动态渲染到个人信息设置页面。用户可以通过表单来查看和更新他们的资料，如邮箱、昵称、性别、个人简介等。为了更直观地理解，本文提供了完整的HTML和JavaScript示例代码，用户可以
  • Linux基础 ——tmux vim 以及基本的shell语法 Krifood linux
    Linux基础ACWINGy总的Linux基础课，看讲义作作笔记。tmuxtmux可以干嘛？tmux可以分屏多开窗口，可以进行多个任务，断线，不会自动杀掉正在进行的进程。tmux–session(会话，多个)–window(多个)–pane(最小单位shell对话框)ps:原本tmux默认操作的（前缀键）是ctrl+bY总的ACterminal里面改成了默认ctrl+a，下面的代码里特意加以区分特
  • 基于Java+MySQL+SSMNBA周边商城管理系统 浅夏淡过，微光凉 JAVA项目javamysql开发语言tomcatmybatis数据库
    系列文章目录项目介绍开发环境系统实现论文参考项目介绍随着科学技术的飞速发展，各行各业都在努力与现代先进技术接轨，通过科技手段提高自身的优势；对于NBA周边商城管理系统当然也不能排除在外，随着网络技术的不断成熟，带动了NBA周边商城管理系统，它彻底改变了过去传统的管理方式，不仅使服务管理难度变低了，还提升了管理的灵活性。这种个性化的平台特别注重交互协调与管理的相互配合，激发了管理人员的创造性与主动性
  • 【Java基础-42.2】Java 基本数据类型与包装类之间的转换：深入理解自动装箱与拆箱 AllenBright #Java基础java开发语言
    在Java中，数据类型分为基本数据类型（PrimitiveTypes）和引用数据类型（ReferenceTypes）。为了在面向对象的编程中使用基本数据类型，Java提供了对应的包装类（WrapperClasses）。本文将深入探讨Java中基本数据类型与包装类之间的转换，包括自动装箱（Autoboxing）和拆箱（Unboxing），以及它们在实际开发中的应用。1.基本数据类型与包装类概述Jav
  • Flink提交任务命令执行错误NoSuchMethodError 500佰 Flink线上问题处理方案flink大数据云计算运维
    #Flink常见故障#大数据#生产环境真实案例#Flink#流式计算#流批一体#整理#经验总结说明：此篇总结Flink常见故障案例处理方案结合自身经历总结不易+关注+收藏欢迎留言更多Flink案例汇总方案解决方案：Flink业务常见故障多案例解决方案Flink提交任务命令执行错误NoSuchMethodError问题使用flinkrun命令提交任务时报错，报错如下：java.lang.NoSuch
  • 从单体到微服务：导购返利系统的架构转型与Java技术栈的挑战与机遇 wx_tangjinjinwx java微服务架构
    从单体到微服务：导购返利系统的架构转型与Java技术栈的挑战与机遇大家好，我是阿可，微赚淘客系统及省赚客APP创始人，是个冬天不穿秋裤，天冷也要风度的程序猿！导购返利系统在传统的单体架构中，随着用户和业务的增长，逐渐暴露出扩展性和维护性的不足。本文将探讨从单体架构转型到微服务架构过程中遇到的挑战与机遇，并结合Java技术栈的应用进行详细说明。一、单体架构的瓶颈单体架构将所有功能模块打包在一个进程中
  • 04树 + 堆 + 优先队列 + 图（D1_树（D10_决策树）） Java丨成神之路 06数据结构与算法数据结构算法
    目录一、引言二、算法原理三、算法实现四、知识小结一、引言决策树算法是一种常用的机器学习算法，可用于分类和回归问题。它基于特征之间的条件判断来构建一棵树，树的每个节点代表一个特征，每个叶节点代表一个类别或回归值。决策树算法具有简单、易于理解和解释的特点，且在处理大规模数据时具有较高的效率。本文将介绍决策树算法的基本原理，并提供了Java代码示例来说明其实现过程。二、算法原理决策树算法基于“分而治之”
  • 7.2 jmu-Java-06异常-02-使用异常机制处理异常输入 包小包. java开发语言
    目录main方法：输入样例：输出样例：代码实现：对处理异常的理解总结：异常处理的核心思想是以下几点：异常处理的五个关键字Last使用异常处理输入机制，让程序变得更健壮。main方法：输入n，创建大小为n的int数组。输入n个整数，放入数组。输入时，有可能输入的是非整型字符串，这时候需要输出异常信息，然后重新输入。使用Arrays.toString输出数组中的内容。输入样例：512ab453输出样例
  • JAVA8新特性 纠结哥_Shrek java开发语言
    例子代码：纠结哥/java-learn-Gitee.comJDK8（Java8）是Java语言的一次重要更新，带来了许多新特性，主要包括以下几个方面1.Lambda表达式Lambda表达式（λ表达式）是Java8最重要的特性之一，使得Java具备了类似于函数式编程的能力，能够简化代码，提高可读性和可维护性。示例：//传统方式newThread(newRunnable(){@Overridepubl
  • 浅谈java并发编程 纠结哥_Shrek java开发语言
    例子代码：纠结哥/java-learn-Gitee.comJava并发编程是指在Java中通过多线程技术让程序能够同时执行多个任务。通过并发编程，Java程序可以提高性能，尤其是在需要处理大量数据或多个任务时。Java并发编程有多种方式，可以通过直接使用Thread类、Runnable接口、以及Executor框架来实现。以下是一些关键概念和技术：1.线程和线程池Thread:Java中的线程是通
  • 现代OpenGL学习笔记五：变换 不想不努力的菜菜 OpenGL
    上篇笔记中学习了给图形添加纹理，并且第一次接触到3D物体，并且应用一定的图形旋转，本篇将继续学习变换，从而将静态的物体可以移动，并将不懂的地方进行说明记录。推荐参考原文：https://learnopengl-cn.github.io/https://learnopengl-cn.github.io/01Gettingstarted/07Transformations/变换尽管我们现在已经知道了如
  • 在群晖上搭建基于 PostgreSQL 的 Joplin Server Ox119O1 postgresqldocker数据库
    前言笔者一直想找一款能代替MWeb的跨平台工具，由于工作的变更，很多Mac上好用的软件在Windows平台直接无法使用……反正探索了一圈感觉Joplin看起来是不错的，笔记功能和MWeb很像，跨平台，并且笔记数据可以本地保存。恰好笔者近日购买了一台群晖的NAS，一切刚刚好，如同量身定制美滋滋。JoplinServer介绍既然决定将笔记存在本地自己的NAS上面，Joplin提供的JoplinClou
  • 教妹学 Java：异常处理机制 沉默王二 Java程序员进阶之路java异常处理机制
    “二哥，今天就要学习异常了吗？”三妹问。“是的。只有正确地处理好异常，才能保证程序的可靠性，所以异常的学习还是很有必要的。”我说。“那到底什么是异常呢？”三妹问。“异常是指中断程序正常执行的一个不确定的事件。当异常发生时，程序的正常执行流程就会被打断。一般情况下，程序都会有很多条语句，如果没有异常处理机制，前面的语句一旦出现了异常，后面的语句就没办法继续执行了。”“有了异常处理机制后，程序在发生异
  • OpenGL学习笔记8——变换 lxbhahaha #OpenGLopenglglslcpp图形学
    OpenGL学习笔记8——变换1概念2应用变换2.1GLM2.2给四边形应用变换1概念基本上都是线性代数的知识，矩阵的运算、向量的运算。就不多写了，挑几个关键点的记一下。点乘，向量和向量之间做点乘，结果是一个标量。点乘是通过将对应分量逐个相乘，然后再把所得积相加。相当于求投影。用来计算角度很方便，可能用在光照的计算。叉乘，向量和向量之间做叉乘，结果还是一个向量，并且这个向量会垂直于两个向量所在的平
  • 对于CompletableFuture，如果有一个任务阻塞超时了，你如何让其他任务直接返回？ LUCIAZZZ javaspringboot并发异步超时
    我们要使用内部方法里的超时机制1.使用timeout配合completeExceptionally你可以使用CompletableFuture的completeExceptionally方法在超时后主动让任务失败，并让其他任务继续执行。可以结合CompletableFuture的orTimeout或completeOnTimeout方法来设置超时。示例：java复制代码importjava.uti
  • 深度优先搜索（DFS) 某个默默无闻奋斗的人 深度优先算法
    深度优先搜索（DFS）：Java实现与原理解析深度优先搜索（Depth-FirstSearch，简称DFS）是一种用于遍历或搜索树或图的算法。它从起始节点出发，沿着图的一个分支一路向下探索，直到到达最深的节点（即没有未访问的邻居节点为止），然后回溯到上一个节点，继续探索其他未被访问的分支，直到所有节点都被访问过为止。在本文中，我们将详细解析如何在Java中实现DFS，并讨论相关的原理。1.深度优先
  • redis 过期策略都有哪些？LRU 算法知道吗？写一下 java 代码实现？ 晚夜微雨问海棠呀 redisjava数据库
    Redis的过期策略Redis提供了多种数据过期策略，以确保内存的有效利用和数据的及时清理。以下是主要的过期策略：定时删除：在设置键的过期时间时，创建一个定时器（timer），在键过期时立即删除。优点：键过期后立即释放内存。缺点：每个键都需要一个定时器，会消耗大量的系统资源。惰性删除：只有在访问一个键时，才会检查该键是否已过期，如果已过期则删除。优点：不会浪费系统资源，只有在需要时才进行检查。缺点
  • JavaScript中new Object()是什么？ 芝麻团坚果 Node.js自学笔记
    问题引入：写请假系统的时候，看到同学用了很多varxx=newObject()，不知道什么用处。于是寻找Object()的用法。js中vara=newObject()和vara={}有什么区别吗？应该是没有区别的，两者都是生成一个默认的Object对象。js和其它语言一样，一切对象的基类都是Object，所以，newObject()和简易的{}是同样的空对象，就是默认的对象。本来我以为{}应该是一
  • Python随笔 scorecardpy笔记 Cairne493 Python学习python机器学习数据分析
    目录scorecardpy笔记简介运行示例详细分析各函数sc.germancredit()sc.var_fillter(...)sc.split_df(...)woebin(...)woebin_ply(...)sc.perf_eva(...)sc.scorecard(...)sc.scorecard_ply(...)sc.perf_psi()问题解决matplotlib.pyplot未安装[^3
  • Java多线程——线程安全性 松仔log #java多线程java开发语言android
    线程安全性当多个线程访问某个类时，这个类始终都能表现出正确的行为，那么就称这个类是线程安全的publicclassA{publicvoidtest(){//....}}无状态对象是线程安全的，其不包含任何域，也不包含任何对其他类中域的引用，调用过程产生的临时状态也仅存在于线程栈上的局部变量中竞态条件publicclassA{privatelongcount;publiclonggetCount()
  • Java多线程——对象的共享 松仔log #java多线程java开发语言
    可见性一个线程修改了对象状态后，其他线程能够看到发生的状态变化publicclassNoVisibility{privatestaticbooleanready;privatestaticintnumber;privatestaticclassReaderThreadextendsThread{@Overridepublicvoidrun(){while(!ready)Thread.yield()
  • 基于SSM的在线作业管理系统 -octopus-master（源码+调试） 程序猿麦小七 毕业设计Java后台JavaWeb服务器linux数据库在线作业
    项目描述临近学期结束，还是毕业设计，你还在做java程序网络编程，期末作业，老师的作业要求觉得大了吗?不知道毕业设计该怎么办?网页功能的数量是否太多?没有合适的类型或系统?等等。你想解决的问题，今天给大家介绍一篇基于SSM的在线作业管理系统设计与实现。功能需求本在线作业管理系统通过分析和确定系统的角色和功能划分，按照业务合理区分为不同的菜单功能模块。从用户角度出发，对每个功能的需求实现点进行人性化
  • 陆面过程中辐射的定义-总辐射辐照度、向下短波辐射、向下长波辐射 永康李 CESMMODIS遥感笔记
    文章目录一、这个帖子的内容可能不正确，其实我也没找到正确的答案，然后就自己搜，然后根据自己的认知写的。我这里写这个笔记的目的就是把我使用的辐射记录下来，以防后面自己不知道自己是怎样下的定义；而不是让别人作为参考。如果后续有错误，或者我认知到我是错的，将会更新。同时也希望懂的人给我提建议，我愿意接受。二、概述三、向下短波辐射四、向下长短波辐射五、最后，如果有错，真心希望有人给我提意见。一、这个帖子的
  • #Java 与 C++ 核心差异详解：从语法到实战的代码对比 新宿椎名琳擒 java开发语言
    ##一、语言定位差异||Java|C++|设计目标|"Writeonce,runanywhere"|"高性能系统级开发"|运行方式|JVM解释执行字节码|直接编译为机器码|典型场景|企业应用/Android/大数据|游戏引擎/操作系统/高频交易系统---###二、基础语法对比####1.HelloWorld程序```java//Java:严格面向对象publicclassHelloWorld{  
  • Java多线程——对象的组合 松仔log #java多线程java开发语言jvm
    设计线程安全的类找出构成对象状态的所有变量找出约束状态变量的不变性条件建立对象状态的并发访问管理策略实例封闭当一个对象被封装到另一个对象中，能够访问被封装对象的所有代码路径都是已知的。通过封闭和加锁，可以确保以线程安全的方式使用非线程安全的对象classMutablePoint{publicintx,y;publicMutablePoint(){x=0;y=0;}publicMutablePoin
  • Java集合之Collection知识总结 皮蛋不吃粥 基础知识java集合
    一、前言java集合是一个较为基础的框架，本次主要是整理积累的知识，供复习使用，同时也感谢Guide大佬提供的参考文献。目录一、前言二、整体概览三、List结构差异性ArrayList和Vector区别Arraylist与LinkedList区别什么是Stack？四、Set无序性和不可重复性比较器Comparable和Comparator区别HashSetLinkedHashSetTreeSet区
  • xmind使用教程 神秘剑客_CN xmindxmind
    xmind使用教程前言xmind版本信息“xmind使用教程”的xmind思维导图前言首先xmind是什么？XMind是一款思维导图和头脑风暴工具，用于帮助用户组织和可视化思维、创意和信息。它允许用户通过图形化的方式来创建、整理和分享思维导图，可以用于项目管理、学习笔记、计划制定等。XMind提供了多种不同的模板和布局，帮助用户清晰地展示复杂的想法和关系。之前一直对这种类似的思维导图的软件不太感兴
  • 基于SSM的亲子活动平台的搭建与实现（源码+数据脚本+论文+技术文档） 程序猿麦小七 毕业设计Java后台JavaWeb亲子活动商家入驻SSM
    项目描述临近学期结束，还是毕业设计，你还在做java程序网络编程，期末作业，老师的作业要求觉得大了吗?不知道毕业设计该怎么办?网页功能的数量是否太多?没有合适的类型或系统?等等。这里根据疫情当下，你想解决的问题，今天给大家介绍一篇基于SSM的亲子活动平台的搭建与实现。功能需求本文研究基于javaWeb的亲子活动平台的搭建与实现，通过分析现在大部分的家庭对孩子影响以及陪伴的情况，对亲子活动平台的项目
  • Java程序设计（三十九）：基于SSM框架的每日健康管理系统的实现与数据分析 人工智能_SYBH 2025年java程序设计java数据分析开发语言微信小程序notepad++程序设计数据挖掘
    目录引言系统需求分析2.1功能需求2.2非功能需求系统架构设计3.1技术栈3.2系统架构图数据库设计系统实现5.1后端实现5.1.1Spring配置5.1.2控制器实现5.1.3服务层与DAO层实现5.2前端实现5.2.1页面设计5.2.2AJAX请求实现数据分析与可视化创新点与未来展望总结引言随着社会的进步与人们健康意识的提升，健康管理成为了越来越重要的主题。本文介绍了一种基于SSM框架的每日健
  • 二分查找排序算法 周凡杨 java二分查找排序算法折半
    一：概念 二分查找又称 折半查找（ 折半搜索/ 二分搜索），优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插入删除困难。因此，折半查找方法适用于不经常变动而 查找频繁的有序列表。首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表 分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步
  • java中的BigDecimal bijian1013 javaBigDecimal
            在项目开发过程中出现精度丢失问题，查资料用BigDecimal解决，并发现如下这篇BigDecimal的解决问题的思路和方法很值得学习，特转载。         原文地址：http://blog.csdn.net/ugg/article/de
  • Shell echo命令详解 daizj echoshell
    Shell echo命令 Shell 的 echo 指令与 PHP 的 echo 指令类似，都是用于字符串的输出。命令格式： echo string 您可以使用echo实现更复杂的输出格式控制。 1.显示普通字符串: echo "It is a test" 这里的双引号完全可以省略，以下命令与上面实例效果一致： echo Itis a test 2.显示转义
  • Oracle DBA 简单操作 周凡杨 oracle dba sql
    --执行次数多的SQL select sql_text,executions from (      select sql_text,executions from v$sqlarea order by executions desc      ) where rownum<81;  &nb
  • 画图重绘 朱辉辉33 游戏
      我第一次接触重绘是编写五子棋小游戏的时候，因为游戏里的棋盘是用线绘制的，而这些东西并不在系统自带的重绘里，所以在移动窗体时，棋盘并不会重绘出来。所以我们要重写系统的重绘方法。   在重写系统重绘方法时，我们要注意一定要调用父类的重绘方法，即加上super.paint(g)，因为如果不调用父类的重绘方式，重写后会把父类的重绘覆盖掉，而父类的重绘方法是绘制画布，这样就导致我们
  • 线程之初体验 西蜀石兰 线程
    一直觉得多线程是学Java的一个分水岭，懂多线程才算入门。 之前看《编程思想》的多线程章节，看的云里雾里，知道线程类有哪几个方法，却依旧不知道线程到底是什么？书上都写线程是进程的模块，共享线程的资源，可是这跟多线程编程有毛线的关系，呜呜。。。 线程其实也是用户自定义的任务，不要过多的强调线程的属性，而忽略了线程最基本的属性。 你可以在线程类的run()方法中定义自己的任务，就跟正常的Ja
  • linux集群互相免登陆配置 林鹤霄 linux
    配置ssh免登陆 1、生成秘钥和公钥    ssh-keygen -t rsa 2、提示让你输入，什么都不输，三次回车之后会在~下面的.ssh文件夹中多出两个文件id_rsa 和 id_rsa.pub    其中id_rsa为秘钥，id_rsa.pub为公钥，使用公钥加密的数据只有私钥才能对这些数据解密    c
  • mysql : Lock wait timeout exceeded; try restarting transaction aigo mysql
    原文：http://www.cnblogs.com/freeliver54/archive/2010/09/30/1839042.html   原因是你使用的InnoDB   表类型的时候, 默认参数:innodb_lock_wait_timeout设置锁等待的时间是50s, 因为有的锁等待超过了这个时间,所以抱错.   你可以把这个时间加长,或者优化存储
  • Socket编程 基本的聊天实现。 alleni123 socket
    public class Server { //用来存储所有连接上来的客户 private List<ServerThread> clients; public static void main(String[] args) { Server s = new Server(); s.startServer(9988); } publi
  • 多线程监听器事件模式(一个简单的例子) 百合不是茶 线程监听模式
        多线程的事件监听器模式   监听器时间模式经常与多线程使用,在多线程中如何知道我的线程正在执行那什么内容,可以通过时间监听器模式得到        创建多线程的事件监听器模式 思路:    1, 创建线程并启动,在创建线程的位置设置一个标记     2,创建队
  • spring InitializingBean接口 bijian1013 javaspring
    spring的事务的TransactionTemplate，其源码如下： public class TransactionTemplate extends DefaultTransactionDefinition implements TransactionOperations, InitializingBean{ ... } TransactionTemplate继承了DefaultT
  • Oracle中询表的权限被授予给了哪些用户 bijian1013 oracle数据库权限
            Oracle查询表将权限赋给了哪些用户的SQL，以备查用。 select t.table_name as "表名", t.grantee as "被授权的属组", t.owner as "对象所在的属组"
  • 【Struts2五】Struts2 参数传值 bit1129 struts2
    Struts2中参数传值的3种情况 1.请求参数绑定到Action的实例字段上 2.Action将值传递到转发的视图上 3.Action将值传递到重定向的视图上   一、请求参数绑定到Action的实例字段上以及Action将值传递到转发的视图上 Struts可以自动将请求URL中的请求参数或者表单提交的参数绑定到Action定义的实例字段上，绑定的规则使用ognl表达式语言
  • 【Kafka十四】关于auto.offset.reset[Q/A] bit1129 kafka
    I got serveral questions about  auto.offset.reset. This configuration parameter governs how  consumer read the message from  Kafka when  there is no initial offset in ZooKeeper or
  • nginx gzip压缩配置 ronin47 nginx gzip 压缩范例
    nginx gzip压缩配置 更多 0 nginx gzip 配置   随着nginx的发展，越来越多的网站使用nginx，因此nginx的优化变得越来越重要，今天我们来看看nginx的gzip压缩到底是怎么压缩的呢？ gzip(GNU-ZIP)是一种压缩技术。经过gzip压缩后页面大小可以变为原来的30%甚至更小，这样，用
  • java-13.输入一个单向链表，输出该链表中倒数第 k 个节点 bylijinnan java
    two cursors. Make the first cursor go K steps first. /* * 第 13 题：题目：输入一个单向链表，输出该链表中倒数第 k 个节点 */ public void displayKthItemsBackWard(ListNode head,int k){ ListNode p1=head,p2=head;
  • Spring源码学习-JdbcTemplate queryForObject bylijinnan javaspring
    JdbcTemplate中有两个可能会混淆的queryForObject方法： 1. Object queryForObject(String sql, Object[] args, Class requiredType) 2. Object queryForObject(String sql, Object[] args, RowMapper rowMapper) 第1个方法是只查
  • [冰川时代]在冰川时代,我们需要什么样的技术? comsci 技术
         看美国那边的气候情况....我有个感觉...是不是要进入小冰期了?      那么在小冰期里面...我们的户外活动肯定会出现很多问题...在室内呆着的情况会非常多...怎么在室内呆着而不发闷...怎么用最低的电力保证室内的温度.....这都需要技术手段...   &nb
  • js 获取浏览器型号 cuityang js浏览器
    根据浏览器获取iphone和apk的下载地址 <!DOCTYPE html> <html> <head>     <meta charset="utf-8" content="text/html"/>     <meta name=
  • C# socks5详解 转 dalan_123 socketC#
    http://www.cnblogs.com/zhujiechang/archive/2008/10/21/1316308.html  这里主要讲的是用.NET实现基于Socket5下面的代理协议进行客户端的通讯，Socket4的实现是类似的，注意的事，这里不是讲用C#实现一个代理服务器，因为实现一个代理服务器需要实现很多协议，头大，而且现在市面上有很多现成的代理服务器用，性能又好，
  • 运维 Centos问题汇总 dcj3sjt126com 云主机
    一、sh 脚本不执行的原因 sh脚本不执行的原因 只有2个 1.权限不够 2.sh脚本里路径没写完整。   二、解决You have new mail in /var/spool/mail/root 修改/usr/share/logwatch/default.conf/logwatch.conf配置文件 MailTo = MailFrom   三、查询连接数
  • Yii防注入攻击笔记 dcj3sjt126com sqlWEB安全yii
    网站表单有注入漏洞须对所有用户输入的内容进行个过滤和检查，可以使用正则表达式或者直接输入字符判断，大部分是只允许输入字母和数字的，其它字符度不允许；对于内容复杂表单的内容，应该对html和script的符号进行转义替换：尤其是<,>,',"",&这几个符号 这里有个转义对照表： http://blog.csdn.net/xinzhu1990/articl
  • MongoDB简介[一] eksliang mongodbMongoDB简介
    MongoDB简介 转载请出自出处：http://eksliang.iteye.com/blog/2173288 1.1易于使用        MongoDB是一个面向文档的数据库，而不是关系型数据库。与关系型数据库相比，面向文档的数据库不再有行的概念，取而代之的是更为灵活的“文档”模型。        另外，不
  • zookeeper windows 入门安装和测试 greemranqq zookeeper安装分布式
    一、序言       以下是我对zookeeper 的一些理解：      zookeeper 作为一个服务注册信息存储的管理工具，好吧，这样说得很抽象，我们举个“栗子”。       栗子1号：       假设我是一家KTV的老板，我同时拥有5家KTV，我肯定得时刻监视
  • Spring之使用事务缘由(2-注解实现) ihuning spring
      Spring事务注解实现   1. 依赖包：     1.1 spring包：           spring-beans-4.0.0.RELEASE.jar           spring-context-4.0.0.
  • iOS App Launch Option 啸笑天 option
    iOS 程序启动时总会调用application:didFinishLaunchingWithOptions:，其中第二个参数launchOptions为NSDictionary类型的对象，里面存储有此程序启动的原因。   launchOptions中的可能键值见UIApplication Class Reference的Launch Options Keys节 。 1、若用户直接
  • jdk与jre的区别（_） macroli javajvmjdk
    简单的说JDK是面向开发人员使用的SDK，它提供了Java的开发环境和运行环境。SDK是Software Development Kit 一般指软件开发包，可以包括函数库、编译程序等。  JDK就是Java Development Kit JRE是Java Runtime Enviroment是指Java的运行环境，是面向Java程序的使用者，而不是开发者。 如果安装了JDK，会发同你
  • Updates were rejected because the tip of your current branch is behind qiaolevip 学习永无止境每天进步一点点众观千象git
    $ git push joe prod-2295-1 To [email protected]:joe.le/dr-frontend.git ! [rejected] prod-2295-1 -> prod-2295-1 (non-fast-forward) error: failed to push some refs to '[email protected]
  • [一起学Hive]之十四-Hive的元数据表结构详解 superlxw1234 hivehive元数据结构
    关键字：Hive元数据、Hive元数据表结构   之前在 “[一起学Hive]之一–Hive概述，Hive是什么”中介绍过，Hive自己维护了一套元数据，用户通过HQL查询时候，Hive首先需要结合元数据，将HQL翻译成MapReduce去执行。 本文介绍一下Hive元数据中重要的一些表结构及用途，以Hive0.13为例。   文章最后面，会以一个示例来全面了解一下，
  • Spring 3.2.14，4.1.7，4.2.RC2发布 wiselyman Spring 3
      Spring 3.2.14、4.1.7及4.2.RC2于6月30日发布。   其中Spring 3.2.1是一个维护版本(维护周期到2016-12-31截止)，后续会继续根据需求和bug发布维护版本。此时，Spring官方强烈建议升级Spring框架至4.1.7 或者将要发布的4.2 。   其中Spring 4.1.7主要包含这些更新内容。
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他