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

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)

  • 10月|愿你的青春不负梦想-读书笔记-01 Tracy的小书斋
    本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
  • 《投行人生》读书笔记 小蘑菇的树洞
    《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • LocalDateTime 转 String igotyback java开发语言
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数 广龙宇 一起学Rust#Rust设计模式rust设计模式开发语言
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
  • git常用命令笔记 咩酱-小羊 git笔记
    ###用习惯了idea总是不记得git的一些常见命令，需要用到的时候总是担心旁边站了人~~~记个笔记@_@，告诉自己看笔记不丢人初始化初始化一个新的Git仓库gitinit配置配置用户信息gitconfig--globaluser.name"YourName"gitconfig--globaluser.email"[email protected]"基本操作克隆远程仓库gitclone查看
  • 509. 斐波那契数(每日一题) lzyprime
    lzyprime博客(github)创建时间：2021.01.04qq及邮箱：2383518170leetcode笔记题目描述斐波那契数，通常用F(n)表示，形成的序列称为斐波那契数列。该数列由0和1开始，后面的每一项数字都是前面两项数字的和。也就是：F(0)=0，F(1)=1F(n)=F(n-1)+F(n-2)，其中n>1给你n，请计算F(n)。示例1：输入：2输出：1解释：F(2)=F(1)+
  • 拥有断舍离的心态，过精简生活--《断舍离》读书笔记 爱吃丸子的小樱桃
    不知不觉间房间里的东西越来越多，虽然摆放整齐，但也时常会觉得空间逼仄，令人心生烦闷。抱着断舍离的态度，我开始阅读《断舍离》这本书，希望从书中能找到一些有效的方法，帮助我实现空间、物品上的断舍离。《断舍离》是日本作家山下英子通过自己的经历、思考和实践总结而成的，整体内涵也从刚开始的私人生活哲学的“断舍离”升华成了“人生实践哲学”，接着又成为每个人都能实行的“改变人生的断舍离”，从“哲学”逐渐升华成“
  • 四章-32-点要素的聚合 彩云飘过
    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计 网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java算法华为javascript
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
  • 高端密码学院笔记285 柚子_b4b4
    高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业javascripthtmlcss旅游风景
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动 二挡起步 web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
  • Day17笔记-高阶函数 ~在杰难逃~ Python笔记python开发语言pycharm数据分析
    高阶函数【重点掌握】函数的本质：函数是一个变量，函数名是一个变量名，一个函数可以作为另一个函数的参数或返回值使用如果A函数作为B函数的参数，B函数调用完成之后，会得到一个结果，则B函数被称为高阶函数常用的高阶函数：map(),reduce(),filter(),sorted()1.map()map(func,iterable)，返回值是一个iterator【容器，迭代器】func:函数iterab
  • Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Pythonpython开发语言大数据数据分析数据挖掘
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
  • node.js学习 小猿L node.jsnode.js学习vim
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
  • 数据仓库——维度表一致性 墨染丶eye 背诵数据仓库
    数据仓库基础笔记思维导图已经整理完毕，完整连接为：数据仓库基础知识笔记思维导图维度一致性问题从逻辑层面来看，当一系列星型模型共享一组公共维度时，所涉及的维度称为一致性维度。当维度表存在不一致时，短期的成功难以弥补长期的错误。维度时确保不同过程中信息集成起来实现横向钻取货活动的关键。造成横向钻取失败的原因维度结构的差别，因为维度的差别，分析工作涉及的领域从简单到复杂，但是都是通过复杂的报表来弥补设计
  • 【Git】常见命令(仅笔记) 好想有猫猫 GitLinux学习笔记git笔记elasticsearchlinuxc++
    文章目录创建/初始化本地仓库添加本地仓库配置项提交文件查看仓库状态回退仓库查看日志分支删除文件暂存工作区代码远程仓库使用`.gitigore`文件让git不追踪一些文件标签创建/初始化本地仓库gitinit添加本地仓库配置项gitconfig-l#以列表形式显示配置项gitconfiguser.name"ljh"#配置user.namegitconfiguser.email"[email protected]
  • Java 重写(Override)与重载(Overload) 叨唧唧的
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
  • 简单了解 JVM 记得开心一点啊 jvm
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
  • 为什么你总是对下属不满意? ZhaoWu1050
    【ZhaoWu的听课笔记】大多数公司，都存在两种问题。我创业四年，更是体会深切。这两种问题就是：老板经常不满意下属的表现；下属总是不知道老板想要什么；虽然这两种问题普遍存在，其实解决方法并不复杂。这节课，我们再聊聊第一个问题：为什么老板经常不满意下属表现?其实，这背后也是一条管理常识。管理学家德鲁克先生早就说过：管理者的任务，不是去改变人。*来自《卓有成效的管理者》只是大多数老板和我一样，都是一边
  • 母亲节如何做小红书营销 美橙传媒
    小红书的一举一动引起了外界的高度关注。通过爆款笔记和流行话题，我们可以看到“干货”类型的内容在小红书中偏向实用的生活经验共享和生活指南非常受欢迎。根据运营社的分析，这种现象是由小红书用户心智和内容社区背后机制共同决定的。首先，小红书将使用“强搜索”逻辑为用户提供特定的“搜索场景”。在“我必须这样生活”中，大量使用了满足小红书站用户喜好和需求的内容。内容社区自制的高质量内容也吸引了寻找营销新途径的品
  • Java企业面试题3 马龙强_ java
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
  • JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Javajava
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
  • 读书笔记|《遇见孩子，遇见更好的自己》5 抹茶社长
    为人父母意味着放弃自己的过去，不要对以往没有实现的心愿耿耿于怀，只有这样，孩子们才能做回自己。985909803.jpg孩子在与父母保持亲密的同时更需要独立，唯有这样，孩子才会成为孩子，父母才会成其为父母。有耐心的人生往往更幸福，给孩子留点余地。认识到养儿育女是对耐心的考验。为失败做好心理准备，教会孩子控制情绪。了解自己的底线，说到底线，有一点很重要，父母之所以发脾气，真正的原因往往在于他们自己，
  • Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选javakafka
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
  • 基于Python给出的PDF文档转Markdown文档的方法 程序媛了了 pythonpdf开发语言
    注：网上有很多将Markdown文档转为PDF文档的方法，但是却很少有将PDF文档转为Markdown文档的方法。就算有，比如某些网站声称可以将PDF文档转为Markdown文档，尝试过，不太符合自己的要求，而且无法保证文档没有泄露风险。于是本人为了解决这个问题，借助GPT（能使用GPT镜像或者有条件直接使用GPT的，反正能调用GPT接口就行）生成Python代码来完成这个功能。笔记、代码难免存在
  • 二分查找排序算法 周凡杨 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其他