【无标题】Java的基础笔记，记录一下，分享一下。

最新推荐文章于 2024-10-01 18:51:18 发布
最新推荐文章于 2024-10-01 18:51:18 发布
阅读量390 收藏
点赞数
文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_47194818/article/details/121697155
版权

java

\t 制表符

\r 一个回车

\\ \ \:\\

注释（comment）

//单行注释

/*

多行注释

*/

/**

*文档注释

*/

DOS磁盘操作系统

md 创建

rd 删除

dir 查看当前目录

… 表示上一级目录

cls 清屏

tree查看所有指令

copy拷贝

echo输入内容到文件

变量

//gender性别

变量三要素：变量名，变量值，变量类型

+：左右两边有字符时，拼接

数据类型

基本数据类型：

数值byte（1）short（2）int（4）long（8）数值后面要加L

​ float（4）数值后面加f double（8）《浮点数默认》

​ 字符char（2）

​ 布尔true，false（1）//（）表示字节大小

科学计数法： 5.12e3 //5.12X10^3

2.7与8.1/3的比较

2.7 //2.7

8.1/3 //2.69999999998

运算时，若有小数之间的比较，应该以两个数差值的绝对值在一个精度内比较是否相等。

数据转换

多种类型混合运算时，系统往最大精度转

float a a a+1.1//错的

byte，short，char三者参与计算时，先转int。

强制转换forceconvent

精度损失，数据溢出

基本数据类型转字符串
n1 = n1 + "";//转字符串
int num = Interger.parseInt(s3);//转数据
int num2 = Double.parseDouble(s3);//转数据

运算符

位运算符

<< 左移 >>右移 &位与（相同为一） |位或 ^异或 ~取反 >>>无符号右移

算术运算符

/整除

%取模 a%b = a - a/b*b

​ a%b a位小数时，公式 = a- (int)a/b*b

关系运算符

== < > >= <=

逻辑运算符

逻辑 a&b a|b !a

短路 a&&b（左边假，右边直接pass，效率高） a||b（同理，效率高） ^异或

赋值运算符AssignOperator

1，从右向左

2，复合赋值运算会有强转：byte a = 2；a++；// a = byte(a + 1)

三元运算符

？ 表达式1：表达式2

int a = 10;
int b = 99;
return a> b? a++: b--//99
运算符优先级

（） {}

++ ——

算数运算符

位移运算符

比较运算符

逻辑运算符

三元运算符

标识符

字母，数字，- ,$(非数字开头，非保留字，关键字)

标识符命名规则与规范

包名：全部小写

类名\接口名：大驼峰(XxxYyyZzz)

变量名，方法名：小驼峰（aaBbbCcc）

常量名：全大写（CC-XX-YY）

原，反 ，补

正数：0------ 原码，反码，补码都一样

负数：1------ 例题：原1010 反 1101 补 1110

switch分支

switch(c){//c必须符合byte,short,int,char,enum(枚举)String
    case a://a必须时常量
        表达式1；
        break;//若没有break则执行表达式2（即穿透）
    case b: 
        表达式2；
        break;
    default:
        System.out.println("程序结束");
       
}

//60分以下不及格，以上为及格，用switch来做
//思路：score/60
Double score = 79.8;
if(score>=0 && score <=100){
    switch((int)(score/60){
        case 1:
            System.out.println("合格");
            break;
        case 0:
            System.out.println("不合格");
            break;
        default:
            System.out.println("程序结束");
       }
}else{
    System.out.println("输入有误")
}

for循环控制

//for（	；循环条件；	）{}
//化繁为简,先死后活
//100以内9的倍数，求和以及个数
int sum = 0;
int start = 1;
int end = 100;
int number = 0;
for( int i = start;i <=end;i++){
    if(i%9==0){
        System.out.println(i + "\t");
      sum+ = i;
        number++;
    }
}

while循环控制

//初始化
//while(循环条件){
//	循环体
//循环迭代
//}
.//1-100之间被3整除的数
int i= 1;
while（i<=100）{
    if(i%3==0){
        System.out.println(i);
    }
    i++;
}
//**do while**

Scanner myScanner = new Scanner(System.in);//java.util.Scanner
char answer = '';
do{
    System.out.println("还钱吗？ Y/N");//循环体；
    answer = myScanner.next().charAt(0);//循环迭代；
     System.out.println("他的回答时" + answer);
}while(answer !='Y');
多重循环
//九九乘法表
public class HelloWorld {
    public static void main(String []args) {
		for(int i = 1;i<=9;i++){
			for(int j = 1;j<=i;j++){
				System.out.print(j + "*" + i + "=" + i*j + "\t");

			}
			System.out.println("");
		}
	}
}


//金字塔
public class HelloWorld {
    public static void main(String []args) {
		//层数是i
		//每一层有2*i-1个*为j
		//定义totallevel = 5
		//		*
		//     *  *
		//   *     *
		int totallevel = 6;

		
		for(int i = 1;i<=totallevel;i++){
			for( int k = 1;k<=totallevel- i;k++){
				System.out.print(" ");
			}
			for(int j=1;j<=2*i-1;j++){
				if(j ==  1 || j == 2 * i - 1 || i ==totallevel){
					System.out.print("*");
				}else{
					System.out.print(" ");
				}
			}
			System.out.println("");
		}
	}
}

break语句,continue语句，returny语句

//break终止语句块的使用

//continue跳出本次循环

//return用在方法里，退出方法；用在main，退出程序

//for,while,dowhile里面终止退出
//标签label可以指定label退出多重循环中的哪一层
public class HelloWorld {
    public static void main(String []args) {
    label1:
        for(int i = 1;i<= 4;i++){
            label2:
            for(int j = 0;j<=4;j++){
                if(j ==2){
                    break label1;
                }
                System.out.println("j =" + j);
            }
        }
    
    
    }
}

      //1-100之内求和，当大于20的时候，跳出循环
public class HelloWorld {
    public static void main(String []args) {
		int sum = 0;
		for(int i =1;i<=100;i++){
			sum =sum + i;
			if(sum>20){
				break;
				
			}
		}
   System.out.print("sum=" + sum );
	}
}
字符串的比较：equals方法

“林黛玉”.equals(name)

5道练习
//1、100000块钱，每经过一次路口，交一次费用。当现金>50000,交5%。当<=50000时，每次交1000。
//问可以经过几个路口L？
		Double money = 100000.0;
				int sum = 0;
				while(true){
					if(money>50000){
						money = money * 0.95;
					}else if(money>1000){
						money = money - 1000;
					}else{
					break;
					}
					sum++;
				}
			System.out.print("能够经过"+ sum +"次");
			}
//2、水仙花数	
import java.util.Scanner;
public class Demo02 {
	public static void main(String[] args) {
		
	Scanner myScanner = new Scanner(System.in);
	System.out.print("请输入一个数");
	int number = myScanner.nextInt();
	if((number%100%10)*(number%100%10)*(number%100%10) + (number/100)*(number/100)*(number/100) + (number/10%10)*(number/10%10)*(number/10%10) == number) {
		System.out.print(number + "是水仙花数");
	}else {
		System.out.print("该数不是水仙花数");
	}
	
	}
}

//3、输出1-100之间不能被5整除的数，每5个一行
package shiyan;

public class Demo02 {
	public static void main(String[] args) {
		int count = 0;
		//3、输出1-100之间不能被5整除的数，每5个一行
		for(int i = 1;i<=100;i++) {
			
			if(i%5 != 0) {
				System.out.print(i + "\t");
				count++;
				if(count% 5 == 0) {
					System.out.println("");
				}
	
			}
		}
	}
}

//4、输出小写的a-z,以及大写的Z-A
public class Demo02 {
	public static void main(String[] args) {

		char letter = 'a';
		char letter1 = 'Z';
		for(int i = 1;i<=26;i++) {
			System.out.print(letter +"\t");
			letter  =(char) (letter + 1);
		}
		System.out.println();
		for(int i = 1;i<=26;i++) {
			System.out.print(letter1 + "\t");
			letter1  =(char) (letter1 - 1);
		}
	}
}
//5、求1-1/2+1/3-1/4+1/5...-1/100
public class Demo02 {
	public static void main(String[] args) {
		Double sum = 0.0;
		for(int i =1;i<=100;i++) {
			if(i%2!=0) {
				sum += 1.0/i;
			}else {
				sum -= 1.0/i;
		}
	   
	
		}
		 System.out.print("sum=" + sum);
	}	
}

数组（引用类型）

数组的使用

1、动态初始化

​ 数据类型 数组名[] = new 数据类型[大小]

例： int a[] = new int[4]

2,动态初始化

int[] a;/int a[];//声名

a = new int [4];

3、静态初始化

int a[] = {23，43，23，2，35，8，6，3}；

细节
  • 相同数据类型的多个数据
  • 容易数据类型，但不能混用
  • 数组创建后，没有赋值，则有默认值。int（0） double(0.0)
  • 数组里面的数据是对象
数组赋值机制

赋值是赋的地址，方式是引用赋**值 **

值传递和引用传递的区别

一个拷贝数据，一个是拷贝地址。

如何开辟两个数据相同的独立空间
int arr[] = {10,20,30};

int arr2 = new int[arr.length];

for(int i = 0;i<arr.length;i++)}{

	arr2[i] = arr[i];

}



//将数组逆序
int[] arr = {3,14,24,4,5,2,63,42,54};
int temp;
for(int i = 0;i< arr.length/2;i++){
    temp = arr[arr.length-1-i];
    arr[arr.length-1-i] = arr[i];
    arr[i] = temp;
}
for(int i = 0;i<arr.length;i++){
	System.out.print(arr[i] + " ");
}
数组添加

新建一个数组，长度为length +n,将原数组拷贝到新数组，然后在赋值n个新元素，让arr指向arrNew（释放空间）

package shiyan;//
import java.util.Scanner;
public class Demo02 {
	public static void main(String[] args) {
		int arr[] = {2,3,4};
	    Scanner myScanner1  = new Scanner(System.in);
		do{
		    
		    int Newarr[] = new int[arr.length + 1];
		    for(int i = 0;i<arr.length ;i++){
		        Newarr[i] = arr[i];

		    }
		    System.out.println("请输入一个想要添加的数字");
		    Newarr[Newarr.length -1  ] = myScanner1.nextInt();
		    arr = Newarr;
		       System.out.println("========添加完成的结果=======");
		    for(int i = 0; i<arr.length ;i++){
		         System.out.print(arr[i] + "\t");
		    }
		    System.out.println(" 是否继续添加 y/n");

		     char key  = myScanner1.next().charAt(0);
		    
		    if(key != 'y'){
		        break;
		    }
		    }
		}while(true);
		    System.out.print("你退出了添加。。");
		   
	}	
}		

//缩减
package shiyan;
import java.util.Scanner;
public class Demo02 {
	public static void main(String[] args) {
		int arr[] = {1,2,3,4};
	    Scanner myScanner1  = new Scanner(System.in);
		do{
		    
		    int Newarr[] = new int[arr.length - 1];
		    for(int i = 0;i<arr.length -1 ;i++){
		        Newarr[i] = arr[i];

		    }
		  
		    arr = Newarr;
		       System.out.println("========添加完成的结果=======");
		    for(int i = 0; i<arr.length ;i++){
		         System.out.print(arr[i] + "\t");
		    }
		    System.out.println(" 是否继续缩减 y\n");

		     char key  = myScanner1.next().charAt(0);
		    
		    if(key != 'y'){
		        break;
		    }
		    
		}while(arr.length > 2);
		    System.out.print("最后一个了，不能再缩减了");
		   
	}	
}	

//冒泡排序
int arr[] = {21,34,25,25,63,2,6,23,65,34,5,6,45,6};
int temp;
for(int i = 0;i < arr.length -1;i++){
    for(int j = 0;j<arr.length -i-1;j++){
        if(arr[i] > arr[i + 1]){
             temp = arr[i];			//低级错误i
            arr[i] = arr[i+1];		//低级
            arr[i + 1] = temp;	/	//低级
        }
    }
    
  }
 System.out.print("=====升序=====");
  for(int i = 0;i <arr.length;i++){
    System.out.print(arr[i] + "\t");}

二维数组

//遍历
int arr[][] = {{6,2,634,3,23,},{6,65,34,4,345,25,2,6}};
		for(int i = 0; i<arr.length;i++) {
			for(int j = 0;j<arr[i].length;j++) {
				System.out.print(arr[i][j] + "\t");
			}
			System.out.print("\n");
		}
动态初始化

类型[][] 数组名[][] [] [] = new 类型[大小] 大小[]

int arr[] = new int[2] [] //列数可以 不确定

int [] x,y []; //x为一维数组，y为二维数组。

String arr[] = new String[] {“2”,“4”}; //right

String arr[] = new String[2] {“2”,“4”}; //error

boollean bar = new boollean[3]; //bar[0]为false,bar[1]为true

杨辉三角
int arr[][] = new int[10][];
		for(int i =0;i<arr.length;i++) {
			arr[i] = new int[i+1];
		}
		for(int i = 0;i<arr.length;i++) {
			for(int j = 0;j<arr[i].length;j++) {
				if(j == 0 || j == arr[i].length - 1) {//特别注意arr[i].length
					arr[i][j] = 1;
				}else {
					arr[i][j] = arr[i-1][j] + arr[i-1][j-1]  ;
				}
			}

		}
		System.out.print("=====杨辉三角=====\n");
		for(int i = 0;i<arr.length;i++) {
			for(int j = 0;j<arr[i].length;j++) {
				System.out.print(arr[i][j] + "\t");
			}
			System.out.print("\n");
		}
		

//在有序数组里加一个数，其还是有序数组
int arr[] = {24,65,76,85,342};
		int index = -1;
		int Insetnum = 999;
		for(int i = 0;i<arr.length;i++) {
			if(Insetnum<arr[i]) {
				index = i;
				break;
			}else {
				index = arr.length;
			}
		}
		int Newarr[] = new int[arr.length + 1];
		for(int i = 0,  j = 0;i < Newarr.length;i++) {//i表示新数组，j表示老数组
			if(i != index) {
				Newarr[i] =  arr[j];
				j++;
			}else {
				Newarr[i] =Insetnum;
			}
		}
		for(int i = 0;i<Newarr.length;i++) {
			System.out.print(Newarr[i] + "\t");
		}
随机数生成

（int）( Math.random()*100)+ 1 //表示1大到100的随机整数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CAv38cgz-1638511163070)(F:\A\Xmind\数组.png)]

方法重载

多个方法：方法名相同，参数/类型 必须不同。

可变参数
public int sum(int... nums){//参数可变
    int res = 0;
    for(int i ;i<nums.length;i++){
    	res +=nums[i]; 
    }
    return res;
}//可变参数可以是几个，也可以是0个
//可变参数的实参可以是数组
//可变参数有
//可变参数可以与形参放在一起，但是必须放在最后。
//可变参数只能有一个

作用域

  1. 属性（全局变量）与局部变量可以重名，访问时遵循就近原则。
  2. 局部变量不能加修饰符，属性可以。

构造器construstor

  1. 无返回值。//不能写void

  2. 方法名与类名相同。

  3. 完成对对象的属性初始化

  4. 没有定义构造器，系统会自己生成一个默认的构造器（无参）//Javap是反编译class文件

    对象创建的流程
    1. 方法区里加载class类,值加载一次
    2. 堆里面创建对象，分配空间，对象初始化，先默认初始化，再显示初始化，最后构造器初始化，对象的地址赋予对象p（对象的引用）。

this关键字

this.name = name;

//this.name 是指对象的属性

//name是指局部变量

//哪个对象调用，this指哪个对象

只能在构造器里访问另一个构造器，如果有访问构造器，必须放在第一行this(属性1，属性2)

this必须在类定义的方法里使用。

this可以访问属性，方法。

匿名对象

new test（）；//只能使用一次

访问修饰符

public 公开

protect 同包里使用，子类

默认 同类同包

private 同类

面向对象

封装encapsulation

隐藏了实现细节，方便用户使用。

步骤
  1. 属性私有化
  2. public set方法
  3. public get方法
package com.package2;
//包的命名：com.公司名.项目名.项目模块
public class dog {
    public static void main(String[] args) {
     Account a =    new Account();
     a.setAge(12);
     a.setName("fu");
     a.setPassword(235222);
    }
}
class Account{
     private int age;
     private String name;
    private int password;//错误的，改用String

    public Account() {//alt + insert
    }

    public Account(int age, String name, int password) {
        this.age = age;
        this.name = name;
        this.password = password;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age>20) {
            this.age = age;
        }else {
            System.out.println("你的账户约必须大于20！");
        }
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        if(name.length()>1 &&name.length()<5){
            this.name = name;
        }else{
            System.out.println("你的名字必须在2到4之间");

        }
    }

    public int getPassword() {
        return password;
    }

    public void setPassword(int password) {
        this.password = password;
    }
}
继承extends

属性，方法相同，可以复用，

使用细节
  1. 子类可以访问父类的公有属性和方法，无法访问私有属性和方法，可以通过父类方法调用。
  2. 创建子类对象时，不管使用哪个子类构造器时， 会默认调用父类的无参构造器，如果父类没有构造器，必须用super指向父类的一个构造器，否则不予通过。
  3. super必须放在构造器第一行
  4. java所有的类都是object（顶级父类）的子类

方法重写

子类中方法与方法形式（参数，方法名）一样，即重写。

返回类型要小于父类类型

访问权限要小于父类的访问权限

//重载：本类 ，形参至少有一处不同；

快捷键

ctrl + b 方法定位

alt+ insert get set方法，构造器

ctrl+ alt + l 格式化

alt + r 快速运行代码

CTRL + H 查看层级关系

自动分配变量名（）.var

多态 （提高代码的复用性）

对象的多态性：

  1. 编译类型可以u运行类型不一致
  2. 编译类型在定义对象就不变了。
  3. 运行类型可以变化，
  4. =左边的为编译类型，右边的为运行类型
  5. instanceOf 比较操作符：判断对象的运行 类型是不是xx类型或xx类型的子类型

向上转型：父类的引用指向子类的对象

向下转型：只能转父类的引用// 子类类型 引用名 = new （子类类型）父类引用

属性没有重写，直接看编译类型，方法看运行类型

Java动态绑定机制Dynamicbinding

  1. 当调用对象的方法时，该方 的内存地址/运行类型绑定
  2. 当调用对象的属性时，没有动态绑定机制。

断点调试Debug

  1. F7 跳入 F8跳出 F9执行下一个断点

类变量（静态变量）

  1. 可以被所有同一个类实列对象共享
  2. 如何访问：类名.类变量名（推荐使用）/对象名.类变量名
  3. 定义:public static 变量名
  4. 类变量随类的生命周期相同

类方法

同上

无this

只能访问类变量

main方法

虚拟机在调用

代 码 块

[修饰符]{

代码

}；

  • 构造器的补充，优先使用。
  • [static] {}静态代码块（类加载的时候执行），只执行一次
  • 普通代码块在创一次对象就被调用一次
类什么时候被加载？
  1. 创建对象实例
  2. 创建子类对象，父类被加载
  3. 使用类的静态成员（普通代码块不会被调用 ）

创建一个子类对象时，调用顺序如下：

  1. 父类的静态代码块和静态属性
  2. 子类的静态代码块和静态属性
  3. 父类的普通代码块和构造器
  4. 子类的普通代码块和构造器

抽象方法

  1. 同时改为抽象类
  2. abstract修饰符
  3. 没有方法体
  4. 不能实例化
  5. 抽象类可以没有抽象方法
  6. 有抽象方法一定为抽象类
  7. abstract不能修饰方法和类之外的
  8. 如果一个类继承了抽象类，必须实现父类的所有抽象方法，除非自己声明abstract
  9. 抽象方法不能被static,final,private修饰

接口

jdk8之前只允许有抽象方法

jdk8之后可以有default默认方法，static静态方法。

接口不能实例化

接口所有 的方法都是抽象方法，可以不用abstract修饰

普通类实现接口必须实现全部方法，抽象类实现接口可以不用实现接口的方法

一个类可以实现多个接口

接口的属性只能时final

接口可以继承接口

接 口的多态性

接口的继承体现

内部类

  1. 局部内部类：定义在方法/代码块里，，有类名，作用域也在方法/代码块中，本质仍然是一个类， 可直接访问外部的所有成员，不能添加修饰符，外部类可以访问，外部其他类不可以访问。如果外部类与局部类的成员重名时，访问默认遵循就近原则，若访问外部类时，可以使用外部类.this.成员名。

  2. 匿名内部类😕/该类没有名字，同时是一个对象//anony匿名的//只能使用一次//作用域：仅能在方法里和代码块里执行

  3. 成员内部类：作用域：外部类中。

  4. 静态内部类： 使用static修饰， 位置同类成员一样。可以访问外部类的静态成员。

    枚举类

    定义：1.构造器私有化，类内部创建一组对象，2，对外暴露用public修饰符3，可以用get方法，但不要用set方法。

    package com.all;

public class enumeration {//如下语法格式
}
enum season{
    SPRING("春天","温暖"),
    SUMMER("春天","温暖"),//
    AUTUMN("春天","温暖"),//
    WINTER("春天","温暖"),
    what;//调用无参构造器
    private String name;
    private String description;

    season(String name, String description) {
        this.name = name;
        this.description = description;
    }
    season(){}

    public String getName() {
        return name;
    }

    public String getDescription() {
        return description;
    }
}

    enum方法（有的方法反编译才能看到javap）：

    • ordinal（）输出对象枚举的序号
    • values() 含有定义的所有枚举对象
    • valueof（）将字符串转化为对象，该字符串必须已有，没有就报错
    • compareTo()比较两个枚举对象的序号，返回0则相等
    细节
    1. 不能继承
    2. 可以使用接口

    注解

    • override，表示重写父类的方法
    • Deprecated 用来表示某个程序元素（类，方法）过时了。过度使用
    • SuppressWarnings抑制编译警告。 作用域：放在哪，控制哪里。
    • retention元注解
    • documented保留javadoc文档里
    • lnherited具有继承性

    异常

    try{//异常代码ctrl + alt + t

}catch{
//处理
}finally{
//必执行
} 
f1() thorws exception1,exception2,exception3{}
    image-20211107202931963

    String类

    1. 实现serializable接口，可以串行化（实现网络传输）
    2. 实现comparable接口，可以比较大小
    3. 是final类
    4. 有属性private final char value[] ;用于存放字符串内容
    5. [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-x0AOV5dk-1638511163071)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20211108175937359.png)]

    string，stringabuffer,stringBuilder比较

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ydDozP5a-1638511163072)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20211110150841447.png)]

    集合

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Lgum8VW5-1638511163072)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20211110204726044.png)]

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sm5eG70G-1638511163074)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20211110205312483.png)]

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-52FusnW5-1638511163074)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20211115135638482.png)]

    hashtable实现类

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nadcWFue-1638511163075)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20211115203528292.png)]

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-66HFaTVz-1638511163075)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20211110205625024.png)]

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0S04e5Mf-1638511163076)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20211115210238477.png)]

    迭代器itit

    1. 遍历集合
    2. hashnext()判断看是否有元素，有返回true，没有返回False。
    3. nest（）获取集合对象。从
    增强for I

    遍历集合或数组，可代替迭代器

    list方法

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2poJqvYp-1638511163076)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20211117134248843.png)]

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bL2Ktqdr-1638511163077)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20211117165024557.png)]

    junit

    @test +alt Enter

    线程

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DmUHOkzG-1638511163077)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20211119164113422.png)]

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TsZ2bc0E-1638511163078)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20211119164249402.png)]

    1. 当一个类继承了Thred类，并重写了run方法，该类可以当线程使用
    2. 调用start（）方法里的start0（）方法才是开启多线程，
    public class Dog extends Runnable{
  
} 
//启动线程
public class test {
Dog dog = new Dog();
    //dog.start();//错误的，接口没有start方法
    Thread thread = new Thread(dog);
    thread.start();
    //终止线程
     //通过控制变量终止线程
    
}

//常用方法
//yield:礼让，不一定成功
//join：插队

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qiRMJ9Ok-1638511163078)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20211119194812349.png)]

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-evdNBArj-1638511163079)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20211120182938319.png)]

    IO流

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MNkAXy3W-1638511163079)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20211121202825604.png)]

    InputStream字节输入流

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4xZvG6wu-1638511163079)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20211121203521324.png)]

    序列化：保存数据时，保存值和数据类型（必须实现两个接口之一，Serializable（推荐）和Externalizable）。

    反序列化：恢复数据时，恢复数据的值和数据类型。

    自己动手敲

遍历集合或数组，可代替迭代器

list方法

[外链图片转存中…(img-2poJqvYp-1638511163076)]

[外链图片转存中…(img-bL2Ktqdr-1638511163077)]

junit

@test +alt Enter

线程

[外链图片转存中…(img-DmUHOkzG-1638511163077)]

[外链图片转存中…(img-TsZ2bc0E-1638511163078)]

  1. 当一个类继承了Thred类，并重写了run方法，该类可以当线程使用
  2. 调用start（）方法里的start0（）方法才是开启多线程，
public class Dog extends Runnable{
  
} 
//启动线程
public class test {
Dog dog = new Dog();
    //dog.start();//错误的，接口没有start方法
    Thread thread = new Thread(dog);
    thread.start();
    //终止线程
     //通过控制变量终止线程
    
}

//常用方法
//yield:礼让，不一定成功
//join：插队

[外链图片转存中…(img-qiRMJ9Ok-1638511163078)]

[外链图片转存中...(img-evdNBArj-1638511163079)]

IO流

[外链图片转存中…(img-MNkAXy3W-1638511163079)]

InputStream字节输入流

[外链图片转存中…(img-4xZvG6wu-1638511163079)]

序列化：保存数据时，保存值和数据类型（必须实现两个接口之一，Serializable（推荐）和Externalizable）。

反序列化：恢复数据时，恢复数据的值和数据类型。

自己动手敲

java成长之旅
关注
Java学习笔记：进阶语法
坤舆湖畔的万某某的博客
08-03 1781
对于Java的对象内存管理、Debug调试，API文档，String类、正则表达式、Object类常用方法、包装类、file类、FileFilter文件过滤器、RandomAccessfile类、JavaIO（各种流）、异常处理机制进行了相对细致的解释与演示！
java笔记 java笔记 java笔记
03-15
【标题】：“Java笔记”是Java开发语言的学习记录，涵盖了从基础到高级的全面知识体系。这份笔记旨在帮助开发者深入理解和掌握Java编程的核心概念和技术。 【描述】：这份"Java笔记"来源于网络资源...
Java 笔记 01：Java 概述，MarkDown 常用语法整理
默默找寻着，那于世而存的蛛丝马迹。
04-18 1633
本文介绍了计算机和 Java 相关知识，整理了 MarkDown 笔记的常用语法，从零基础开始，走进 Java 的世界。
springboot笔记记录分享网站
平安喜乐
09-05 1093
信息数据从传统到当代，是一直在变革当中，突如其来的互联网让传统的信息管理看到了革命性的曙光，因为传统信息管理从时效性，还是安全性，还是可操作性等各个方面来讲，遇到了互联网时代才发现能补上自古以来的短板，有效的提升管理的效率和业务水平。传统的管理模式，时间越久管理的内容越多，也需要更多的人来对数据进行整理，并且数据的汇总查询方面效率也是极其的低下，并且数据安全方面永远不会保证安全性能。结合数据内容管理的种种缺点，在互联网时代都可以得到有效的补充。
【Java学习笔记】java图形界面编程
diguangxihua的博客
07-02 1381
AWT是抽象窗口工具类（Abstrat Window ToolKit）的缩写，AWT库中有60多个类和接口，几乎涵盖了创建Java图形界面程序的所有工具。利用AWT类库，可以在Applet的显示区域创建标签、按钮、复选框第二部分，还可以针对用户行为进行响应。AWT是jdk的一部分，AWT为图形界面程序提供了所需的丰富的组件，同时还提供了对事件类、监听器类、图形处理工具，2D图形的支持。
Java学习笔记一
qq_56822397的博客
08-19 1482
Java之父：詹姆斯·高斯林1991年诞生，最初叫Oak （橡树），1995年改名为Java，英文翻译为印尼爪哇岛，地名，因盛产咖啡而闻名。package 包名;多级包用" . " 作为分隔符修饰符 返回值类型 方法名(形式参数列表) {方法体语句;修饰符：（final、static 视需求添加）publicprotected默认（不加修饰符）priavte返回值类型：基本数据类型（Java中八种）引用数据类型（String、数组、集合、类，等）void (不需要返回值类型)
java学习笔记
博哥的二进制世界
05-19 3340
java学习笔记
【java笔记工具typora使用学习】
2301_79666615的博客
12-24 391
2、两边1个星号为斜体：hello word。
Java SSM 毕设过程记录笔记(01)
Tattoo的博客
05-07 1547
这里写自定义目录标题mybatis连接mysql8.0 mybatis连接mysql8.0 MySQL8.0数据库配置变更： 1，jdbc_driver=com.mysql.cj.jdbc.Driver，原先的com.mysql.cj.jdbc.Driver已不推荐使用； 2，jdbc.url=jdbc:mysql://localhost:3306/ssmbuild?useSSL=true&amp...
如何高效记录并整理编程学习笔记？
csdn_aspnet的专栏
08-13 3542
在编程学习的过程中，建立一个高效的笔记记录和整理方法确实非常重要。下面是一些方法和建议，帮助你打造自己的编程学习“知识宝库”。1）. 选择合适的工具选择一个适合自己的笔记工具非常重要。可以考虑以下几种：1、Markdown编辑器：如Typora、Obsidian等，支持Markdown语法，便于格式化和结构化内容。2、笔记软件：如Evernote、Notion、OneNote等，具有强大的分类和搜索功能。3、代码管理工具：GitHub、Gist可以用来记录代码片段，便于查找和版本控制。
Java_swing笔记
weixin_53204083的博客
11-29 1209
(GUI)工具包swing中的面板容器类，包含在javax.swing 包中，可以进行嵌套，功能是对窗体中具有相同逻辑功能的组件进行组合。获取文本前 运行结果10 获取文本后。勾选前 运行结果11 勾选后。选择前 运行结果12 选择后。设置按钮是否可以被点击。用来负责窗口界面的构造、以及相关的逻辑。JPanel 是 Java。
全套java笔记数据库部分
10-24
标题中的“全套java笔记数据库部分”表明这是一份关于Java编程语言中数据库操作的全面学习资料，涵盖了从基础到进阶的各种主题。描述提到“最新的全套javaEE开发笔记”，暗示了这些笔记可能针对的是Java企业版（Java...
java读书笔记笔记笔记笔记笔记笔记
10-14
【标题】"java读书笔记笔记笔记笔记笔记笔记" 暗示了这是一份关于Java编程语言的学习笔记，可能包含了作者在阅读Java相关书籍时所做的重要记录和理解。笔记通常涵盖了语言的基础概念、核心特性、类与对象、内存管理...
java学习笔记.docx
05-26
### Java学习笔记知识点详解 #### JDBC (Java Database Connectivity) **加载数据库驱动** - 在使用JDBC之前，首先需要加载对应的数据库驱动。对于SQL Server来说，通常使用的类名为`...
基于Hive和Hadoop的哔哩哔哩网站分析系统
图南的博客
09-27 599
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
JavaScript ArrayBuffer的读写与类型转换
最新发布
白瑕 的博客
10-01 245
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
Lxn2zh的博客
09-30 561
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
「Java开发指南」如何用MyEclipse为iPhone搭建Spring应用程序？
需要界面开发、IDE工具研发中文教程资料的小伙伴，记得私信我~
09-30 541
本教程将介绍如何用MyEclipse为iPhone搭建Spring应用程序，欢迎下载最新版IDE体验！
Java学习全记录：从JDBC到Swing应用
"个人的Java学习笔记，涵盖了Jdbc、分页查询以及Swing界面组件的...这份Java学习笔记详细记录了JDBC的数据库操作，分页查询的实现，以及Swing库中常用组件的使用，对于Java初学者和开发者来说，都是宝贵的参考资料。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值