JAVA基础知识总结-摩杜云开发者社区

一、变量

1-1、变量

type varName=value

//数据类型变量名 = 值

2-1、常量

当常量被设定后，一般情况下不允许再进行更改，否则会报错

常量名一般使用大写字符。

final 常量名=值;

final double PI=3.14;

public class day05 {
	// final
    final  static  double PI=3.14;
    public static void main(String[] args) {
        System.out.println(PI);
    }
}

public class HelloWorld {
    // 声明静态常量
    public static final double PI = 3.14;
    // 声明成员常量
    final int y = 10;

    public static void main(String[] args) {
        // 声明局部常量
        final double x = 3.3;
    }
}

二、数据类型

2-1、数据类型

2-1-1 字符串类型

public class day04 {
    public static void main(String[] args) {
        String num="sdb大";
        System.out.println(num);
    }
}

2-1-2 整数类型

byte

short

int

long

public class day01 {
    public static void main(String[] args) {
        String a="hell";
        int num=10;
        byte num2=20;
        short num3=30;
        long num4=30L;  //long 类型数字后要加L
        System.out.println(a+num+"\n"+num2+num3+num4);
    }
}

2-1-3 浮点类型

float

double

public class day02 {
    public static void main(String[] args) {
        float num=50.122F;  // fLoat类型要在数字后面加个F
        double num1=3.154515123265;
        System.out.println(num+"\n"+num1);
    }
}

2-1-4 字符型

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

2-1-5 boolean类型

只有true和false

2-2、类型转换

在把高容量转换到低容量的时候，强制转换

转换的时候可能存在内存溢出，或者精度问题!

底------------->高

byte,short,char,int,long,float,double

public class day05 {
    public static void main(String[] args) {
        int a=125;
        double b=a;
        System.out.println(a);
        System.out.println(b);
    }
}

三、运算符

3-1、运算符

3-1-1 算术运算符

运算符	含义
+	求和
-	相减
*	乘积
/	商
%	求余数（求模）

3-1-2 递增和递减运算符

如果需要反复给数字变量添加或减去1，可以使用递增(++)和递减(--)运算符来完成。

++num先加1，在运算

Num++先运算,后加1。

注意∶递增和递减运算符必须和变量配合使用。

3-1-3 关系运算符

运算符	含义
>	大于
>=	大于等于
<	小于
<=	小于等于
==	等于
!=	不等于

3-1-4 逻辑运算符

运算符	含义	结果
&	逻辑与	两边都是true，结果才是true
│	逻辑或	有一边是true，结果就是true
!	逻辑非（取反）	!true = false、!false = true
&&	短路与	两边都是true，结果才是true
││	短路或	有一边是true，结果就是true

3-1-5 赋值运算符

运算符	含义
=	赋值
+=	a=a+3
-=	a=a-1
*=	a=a*3
/=	a=a/3
%=	a=a%3

3-2、三目运算符

布尔表达式 ? 表达式1 : 表达式2

int a = 5;
Integer b = null;
Integer c = true ? b : a;
// 还是会变成Integer c = true ? b.intValue() : a;
System.out.println(c);

四、键盘输入

Scanner input=new Scanner(System.in);

通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取前我们一般需要使hasNext()与hasNextLine()判断是否还有输入的数据。

next(): 1、一定要读取到有效字符后才可以结束输入。 2、对输入有效字符之前遇到的空白,next()方法会自动将其去掉。

3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。

4、next()不能得到带有空格的字符串。

nextLine():

1、以Enter为结束符,也就是说nextLine()方法返回的是输入回车之前的所有字符。

2、可以获得空白。

package day03键盘输入;
import java.util.Scanner;  //引入类Scanner

public class day01 {
    public static void main(String[] args) {
    	// 输入Scanner会引用import java.util.Scanner;
  		//   int b = new Scanner(System.in).nextInt();
        Scanner input=new Scanner(System.in);
        System.out.println("请输入你的年龄：");
        int a=input.nextInt();
        System.out.println("你的年龄是："+a+"岁");
    }
}

五、条件选择结构

5-1 If 语句

语法结构：

if (条件表达式)

{

执行语句

}

package day04if语句;
public class day01 {
    public static void main(String[] args) {
        double a=100;
        if (a>10){
            System.out.println("满足条件");
        }
    }
}

5-2 if-else

语法结构：

if (条件表达式)

{

执行语句1

}else{

执行语句2

}

package day04if语句;
public class day03 {
    public static void main(String[] args) {
        double a=100;
        if (a>10){
            System.out.println("满足条件");
        }else {
            System.out.println("不满足条件");
        }
    }
}

package day04if语句;

import java.util.Scanner;

public class day02 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入你的年龄：");
        double a=scanner.nextDouble();
        System.out.println("你的年龄是："+a+"岁");
        if (a<10){
            System.out.println("满足条件");
        }else {
            System.out.println("不满足条件");
        }
    }
}

案例 equals 判断字符串是否相等

package Dame练习题.day01if;
import java.util.Scanner;
/*
 *案例:模拟登录
 *使用两个变量分别保存用户名和密码;
 * 引导用户输入一个用户名和密码,
 * 通过if判断是否登录成功。
 * */
public class day03 {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        String user="小莫";
        String password="123";
        System.out.println("请输入用户名：");
        String  nsername=input.next();
        System.out.println("请输入密码：");
        String  pass=input.next();
 // equals 判断字符串是否相等
        if (user.equals(nsername)&&password.equals(pass)){
            System.out.println("登录成功");
        }else {
            System.out.println("登录失败");
        }
    }
}

5-3 if-else-if-用于查询大概的内容

语法结构：

if (条件表达式)

{

执行语句1

} else if (条件表达式1){

执行语句2

} else if (条件表达式2){

执行语句3;

...

}

else

{不成立处的代码}

package day04if语句;
import java.util.Scanner;
public class day04 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入成绩");
        int score = scanner.nextInt();
        if (score == 10) {
            System.out.println();
        } else if (score < 100 && score > 90) {
            System.out.println("优秀");
        }else if (score>80){
            System.out.println("良好");
        }else if (score>60){
            System.out.println("及格");
        }else {
            System.out.println("不及格");
        }
    }
}

5-4 嵌套if结构

语法结构：

if (条件表达式) {

执行语句1

if (条件表达式1){

执行语句2

}

}

5-5 switch语句---用于查询具体的内容

语法结构：

switch(表达式) {

case value1:

执行语句1;

break;

case value2:

执行语句2;

break;

...

default:

执行最后的语句;

}

六、循环

6-1 for循环

语法结构：

for (初始化变量;条件表达式;操作表达式)

{

语句;

......

}

package day基础.day05循环;
public class day03 {
    public static void main(String[] args) {
        for (int i=1;i<100;i++){
            System.out.println(i);
        }
    }
}

6-2 for的双层循环

语法结构：

for(外层的初始变量;外层的条件表达式;外层的操作表达式) \外层打印行数\

for(里层的初始变量;里层的条件表达式;里层的操作表达式) \里层打印每行的个数\

6-3 while循环

语法结构：

While(条件表达式){

// 循环体

}

package day基础.day05循环;
public class day01 {
    public static void main(String[] args) {
        int i=0;
        while (i<50){
            i++;
            System.out.println(i);
        }
    }
}

6-4 do while

语法结构：

七、break和continue

break 跳出整个循环(结束循环)

package day基础.day05循环;
public class day04 {
    public static void main(String[] args) {
        int a=0;
        while (a<100){
            a++;
            System.out.println(a);
            if(a==30){
                break;
            }
        }
    }
}

Continue 跳出本次循环，继续下一次循环

八、数组

8-1 创建数组

方式一动态初始化

数据类型[ ] 数组名字 = new 数据类型[数组长度];

数据类型数组名字[ ] = new 数据类型[数组长度];

适合做一开始不能确定具体数据的情况。先定义数组，后赋值数据进去

int[] arr = new int[3];  
int   arr[] = new int[3];
// 可以拆分 
int[] arr;
arr = new int[3];

package day基础.day07数组;
public class day01 {
    public static void main(String[] args) {
        int[] num;  			//声明一个数组
        num=new  int[4];        //创建数组
        num[0]=1;
        num[1]=2;
        num[2]=6;
        num[3]=6;
        System.out.println(num[0]);
    }
}

方式二静态初始化

数据类型[ ] 数组名 = new 数据类型[ ]{元素1,元素2,元素3…};

一旦确定了数据的具体值,我们就用这种方式存储批量数据。

int[] arr = new int[]{1,2,3,4,5}; 
// 可以拆分 
int[] arr;
arr = new int[]{1,2,3,4,5};

package day基础.day07数组;
public class day03 {
    public static void main(String[] args) {
        int[] a={1,2,3,4,5}; 
        System.out.println(a[1]);
    }
}

package day基础.day07数组;
public class day04 {
    public static void main(String[] args) {
        //定义存储int类型数组，赋值元素1，2，3，4，3
        int[] arr = {1, 2, 3, 4, 6};
        //输入 arr.for自动生成 for (int i : arr)
        for (int i : arr) {
            System.out.println(i);      
        }
    }
}

方式三静态初始化`Arrays.fill`快速初始化填充一个数组

import java.util.Arrays;
public class HelloWorld {
    public static void main(String[] args) {
        int[] arr = new int[5];
        Arrays.fill(arr, 1);
        System.out.println(Arrays.toString(arr));  // [1, 1, 1, 1, 1]
    }
}

8-2 数组索引

8-2-3 数组长度索引数组名.length

public static void main(String[] args) {
	 int[] arr = new int[]{1,2,8,5,5}; 
	 //打印数组的属性，输出结果是5
	  System.out.println(arr.length); //数组名.length
}

8-2-3 修改数组元素

数组名[索引] = 数值，为数组中的元素赋值

变量 = 数组名[索引]，获取出数组中的元素

package day基础.day07数组;
public class day02 {
    public static void main(String[] args) {
        //定义存储int类型数组，赋值元素1，2，3，4，5
        int[] arr = {1,2,3,4,5};
        System.out.println(arr[0]);
        //为0索引元素赋值为6
        arr[0] = 6;
        //获取数组0索引上的元素
        int i = arr[0];
        System.out.println(i);
        //直接输出数组0索引元素
        System.out.println(arr[0]);
    }
}

8-2-4 循环遍历

//输入 arr.for自动生成 for (int i : arr)

package day基础.day07数组;
public class day04 {
    public static void main(String[] args) {
        //定义存储int类型数组，赋值元素1，2，3，4，5
        int[] arr = {1, 2, 3, 4, 5};
//输入 arr.for自动生成 for (int i : arr)
        for (int i : arr) {
            System.out.println(i);            
        }
    }
}

package day基础.day07数组;
public class day05 {
    public static void main(String[] args) {
        //定义存储int类型数组，赋值元素1，2，3，4，5
        int[] arr = {1, 2, 3, 4, 5};
        for (int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }
}

8-3 多维数组

8-3-1 二维数组

int a[ ] [ ] =new int [2] [5];

package day基础.day07多维数组;
import sun.plugin2.message.PrintAppletReplyMessage;
public class day01 {
    public static void main(String[] args) {
        int [][] array={{1,2},{2,3},{5,4}};
        System.out.print(array[2][0]);
        System.out.print(array[2][1]);
    }
}

8-4 数组打印方法

Arrays.toString()

package day基础.day07多维数组;
import java.sql.Array;
import java.util.Arrays;

public class day02 {
    public static void main(String[] args) {
        int[] a={1,2,3,4,7,8,9};
//        打印数组元素
        System.out.println(Arrays.toString(a));
    }
}

8-5 数组排序

8-5-1 顺序排序 Arrays.sort()

package day基础.day07数组排序;
import java.util.Arrays;
public class day01 {
    public static void main(String[] args) {
        int[] arr = {8,5,3,1, 2, 3, 4, 5};
        Arrays.sort(arr);   //  Arrays.sort() 顺序排序
        System.out.println(Arrays.toString(arr));  //Arrays.toString打印数组排序
    }
}

8-5-2 排序修改 Arrays.sort()

package day基础.day07数组排序;
import java.util.Arrays;
public class day01 {
    public static void main(String[] args) {
        int[] arr = {8,5,3,1, 2, 3, 4, 5};
        Arrays.sort(arr);  //排序修改
        System.out.println(Arrays.toString(arr));
        int[] ar = {8,5,3,1, 2, 3, 4, 5};
//        Arrays.fill(ar,2);   // val 要修改的值
        Arrays.fill(ar,2,4,0); // 把下标2-4的内容进行修改
        System.out.println(Arrays.toString(ar));
    }
}

8-6 冒泡排序

九、面向对象创建初始化对象

9-1 创建初始化对象

创建一个app文件和一个Student文件用app文件作为main方法，一个项目种应只存放一个main方法

面向对象 public static void main(String[] args)最好不要加**static **

9-2 super注意点:

super调用父类的构造方法.必须在构造方法的第一个

super必须只能出现在子类的方法或者构造方法中!

super和l this不能同时调用构造方法!

vs this:

代表的对象不同:

this:本身调用者这个对象

super:代表父类对象的应用

前提

this:没有继承也可以使用 super:只能在继承条件才可以使用

构造方法

this() ;本类的构造

super(）:父类的构造!

语法结构：

app.java 一个项目种应只存放一个main方法

package day基础.day08面向对象;

//  一个项目种应只存放一个main方法
public class App {
    public static void main(String[] args) {
//        类:抽象的,实例化
//        类实例化后会返回一个自己的对象!

//        student对象就是一个student类的具体实例!
			//使用 new Student();调用Student中的内容
        Student xingming= new Student();
        Student xing= new Student();
//        给String 进行赋值
        xingming.name="小明";
        xingming.age=15;

//        在Student 处String没进行赋值
        System.out.println(xing.name);
//        赋值后
        System.out.println(xingming.name);
        System.out.println(xingming.age);
    }
}

Student.java

package day基础.day08面向对象;
public class Student {
//    属性    字段
    String name;
    int age;

    public void study(){
        System.out.println(this.name+"在学习");
    }
}

语法结构：

无参构造

application.java

package day基础.day08面向对象;
public class application {
    public static void main(String[] args) {
//        new实例化了一个对象 无参构造
        person perso=new person();
        System.out.println(perso.name);
    }
}

person.java

package day基础.day08面向对象;

public class person {
//    显示的定义构造器
    String name;
    //实例化初始值
    public person(){
   		 this.name="名字";  //无参构造
    }
}

有参构造

application.java

package day基础.day08面向对象;
public class application {
    public static void main(String[] args) {
        person pers=new person("姓名");
        System.out.println(pers.name);
    }
}

person.java

package day基础.day08面向对象;

public class person {
//    显示的定义构造器
    String name;
    //实例化初始值
    public person(){
    //有参构造 这个必须空着
    }
// 一旦定义了有参构造application的,person pers=new person("姓名");就必须显示定义
    public person(String name){
        this.name="name";
    }
}

9-3 封装

提高程序的安全性，保护数据，隐藏代码的实现细节，统一接口

属性私有，get/set

day2 main方法

package day基础.day08面向对象;
public class day2 {
    public static void main(String[] args) {
        day02 name=new day02();
        name.setName("小明");
        System.out.println(name.getName());
    }
}

day02 alt+insert快捷键生成get

package day基础.day08面向对象;

public class day02 {
    // private私有 属性私有
    private String name; // 名字
    private int id; // 学号
    private char sex; // 性别

    //提供一些可以操作这个属性的方法!
    //提供一些public 的get、 set方法

// 可以使用快捷键生成下面内容 alt+insert  选Getter and Setter
    //get获得这个数据
    public String getName(){
        return this.name;
    }
    //set给这个数据设置值
    public void setName(String name){
        this.name=name;
    }
}

9-4 继承

JAVA中类只有单继承，没有多继承!

子类继承父类,使用关键字extends来表示。

super调用父类内容必须只能出现在子类的方法和构造方法中

Application.java main()方法

package day基础.day08面向对象.继承;

import javax.naming.Name;

public class Application {
    public static void main(String[] args) {
        Student student =new Student();
        student.test("名字");
    }
}

person.java 父类

package day基础.day08面向对象.继承;

// 父类
public class person {
        protected String name="父类";

}

Student.java 子类

package day基础.day08面向对象.继承;
// 子类
public class Student extends person{
    private String name="子类";
    public void test(String name){
        System.out.println(name);
        // this调用子类
        System.out.println(this.name);
        // super 必须只能出现在子类的方法和构造方法中
        // super调用父类
        System.out.println(super.name);
    }
}

9-5 方法重写

重写:需要有继承关系，子类重写父类的方法!

1．方法名必须相同 2.参数列表列表必须相同 3．修饰符:范围可以扩大但不能缩小:public>Protected>Default>private 4．抛出的异常:范围，可以被缩小，但不能扩大; ClassNotFoundException --> Exception(大)

重写，子类的方法和父类必要一致:方法体不同!

为什么需要重写:

1．父类的功能,子类不一定需要，或者不一定满足

Alt + Insert ;override;

9-6 多态

多态是在继承/实现情况下的一种现象，表现为:对象多态、行为多态。

多态的前提

有继承/实现关系;存在父类引用子类对象;存在方法重写。

9-6-1 自动类型转换

父类  变量名=new  子类();
 Peoele p1 = new Teacher();

main方法

package day基础.day08面向对象.多态.polymorphism;
public class Test {
    public static void main(String[] args) {
//    ---- Peoele 对象多态
        Peoele p1 = new Teacher();
        p1.run();
        Peoele p2 = new Student();
        p2.run();
    }
}

父类Peoele

package day基础.day08面向对象.多态.polymorphism;
//父类
public class Peoele {
    public void run(){
        System.out.println("人可以跑");
    }
}

子类Student

package day基础.day08面向对象.多态.polymorphism;

public class Student extends Peoele {
//    直接输入run
    @Override
    public void run() {
        System.out.println("学生跑的很快");
    }
}

子类Teacher

package day基础.day08面向对象.多态.polymorphism;
public class Teacher extends Peoele{
//    直接输入run
    @Override
    public void run() {
        System.out.println("老师跑的慢");
    }
}

9-6-2 强转类型

子类 变量名=(子类) 父类变量
Student s1=(Student) p1;

package day基础.day08面向对象.多态.polymorphism;
public class Test {
    public static void main(String[] args) {
 		Peoele p1= new Student();
//强制类型转换可能存在的问题;编译阶段有继续或者实现关系就可以强制转换，但是运行时可能出现类型转换异常
 		// 把p1强制转换成Student				快捷键alt+回车键
        Student s1=(Student) p1;
        p1.run();
        Peoele p2 = new Student();
        p2.run();
    }
}

instanceof判断是否是某个类型

Peoele p2 = new Student();
 Student s1=(Student) p1;
  p1.run();
 Peoele p2 = new Student();
 
// instanceof判断是否是某个类型
if(phone instanceof BoLuo ){
	BoLuo bl = (BoLuo)phone;//调用子类特有方法
	b1.loudMusic();
}else if(phone instanceof Apple ){
	Apple ap = (Apple)phone;
	//调用特有方法
	ap.downloadApp();

9-7 final

final修饰类，类不能被继承了

final class A{}

final修饰方法，方法不能被重写了

class C{
	public final void test(){
	
	}
}
class D extends C{
    // 不能重写 重写会报错
    @Override
    public void test(){
        
    }
}

// 使用了static final修饰的成员变量就被称为常量;
// 作用:通常用于记录系统的配置信息。
public class Test2 {
public static final string SCHOOL_NAME = "程序员";
public static void main(string[] args){
//目标:认识常量。
system.out.println(SCHOOL_NAME);
system.out.printin(SCHOOL_NAME);

}

9-8 抽象类abstract

抽象类最主要的特点:抽象类不能创建对象，仅作为一种特殊的父类，让子类继承并实现

语法结构：

public abstract class Test1 {
//抽象方法:必须abstract修饰，只有方法签名，不能有方法体。
    public abstract void test();
}

语法结构：

main方法

package day基础.day08面向对象.test07;
public class Test {
    public static void main(String[] args) {
        Staff develop= new Develop();
        develop.work();
        //---------特有方法-----------
//        强转类型
        Develop d=(Develop)develop;
        d.smok();

    }
}

员工父类

package day基础.day08面向对象.test07;
public abstract class Staff {
    //    员工 父类
    public abstract void work();
}

人事子类

package day基础.day08面向对象.test07;
// 引入父类extends Staff会报错 使用快捷键lat+INS/CTRL+I加上实现方法
       
public class Personnel extends Staff{
//    人事  快捷键lat+INS  实现方法
    @Override
    public void work() {
        System.out.println("招聘");
    }
    public void KeGuaZi(){
        System.out.println("嗑瓜子");
    }
}

十、方法

语法结构：

修饰符返回值类型方法名(形参列表)

方法体代码(需要执行的功能代码)

return返回值;

package day基础.day06方法;
public class day01 {
//main方法
    public static void main(String[] args) {
        int sum = add(1, 2);
        System.out.println(sum);
    }
	//方法 可以重复使用
    public static int add(int a, int b) {
        return a + b;    // int c=a+b;  return c;
    }
}

如果方法不需要返回数据，返回值类型必须申明成void

(无返回值申明)，此时方法内部不可以使用return返回数据。

package day基础.day06方法;

public class Day03 {
    public static void main(String[] args) {
        helloWorl(5);
    }
//    有参数，无返回值
    public static void helloWorl(int n){
        for (int i=1;i<=n;i++){
            System.out.println("Hello World");
        }
    }
}

package Dame练习题.day03方法;
public class day03 {
    public static void main(String[] args) {
//       double  price=cal(1000,8,"经济舱");
        double price = calculate(1000, 8, "经济舱");
        System.out.println("优惠价："+price);
    }
    public static double calculate(double price, int month, String type) {
        if (month > 5 && month <= 10) {
            switch (type) {
                case "头等舱":
                    price *= 0.9;
                    break;
                case "经济舱":
                    price *= 0.85;
                    break;
            }
        } else {
            switch (type) {
                case "头等舱":
                    price *= 0.9;
                    break;
                case "经济舱":
                    price *= 0.85;
                    break;
            }
        }
        return price;
    }
}

十一、集合

11-1、Collection单列集合

Collection是单列集合的祖宗接口，它的功能是全部单列集合都可以继承使用的。

方法名称	说明
public boolean add(E e)	把给定的对象添加到当前集合中
public void clear()	清空集合中所有的元素
public boolean remove(E e)	把给定的对象在当前集合中删除
public boolean contains(object obj)	判断当前集合中是否包含给定的对象
public boolean isEmpty()	判断当前集合是否为空
public int size()	返回集合中元素的个数/集合的长度

11-1-1 List

List系列集合:添加的元素是有序、可重复、有索引

package day基础.day13集合;

import java.util.ArrayList;
import java.util.Collection;
public class Test01 {
    public static void main(String[] args) {
        ArrayList arr= new ArrayList();  // ①
        ArrayList<String> objects = new ArrayList<>(); // ②
        arr.add(1);
//        用下标获取元素
        arr.get(0);
        System.out.println(arr);
        Collection<String> objects = new ArrayList<>(); // ③
//        添加元素  可重复数据
        objects.add("添加1");
        objects.add("添加2");
        System.out.println(objects);
//        获取集合长度
        int si=objects.size();
        System.out.println(si);


//        清空
        objects.clear();
        System.out.println(objects);
//        删除
        System.out.println(objects.remove("添加1")); // true
        objects.remove("添加1");
        System.out.println(objects);

//        判断当前集合中是否包含给定的对象
        boolean re=objects.contains("添加2");  // true
        System.out.println(re);
//        判断当前集合是否为空
        boolean is=objects.isEmpty();  // true
        System.out.println(is);

    }
}

迭代遍历

collection集合获取迭代器

方法名称	说明
iterator iterator()	返回迭代器对象，默认指向当前集合的0索引

package day基础.day13集合;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Test02 {
    public static void main(String[] args) {
        Collection<String> coll = new ArrayList<>();
        coll.add("第一个");
        coll.add("第二个");
        coll.add("第三个");
        Iterator<String> it=coll.iterator();
        while (it.hasNext()){
            String str=it.next();
            System.out.println(str);
        }
    }
}

1，报错NoSuchElementException

2，迭代器遍历完毕，指针不会复位

3，循环中只能用一次next方法

4，迭代器遍历时，不能用集合的方法进行增加或者删除

☆☆lterator中的常用方法 for

方法名称	说明
boolean hasNext()	判断当前位置是否有元素有元素返回true ,没有元素返回false
E next()	获取当前位置的元素，并将迭代器对象移向下一个位置。

package day基础.day13集合;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Test02 {
    public static void main(String[] args) {
        Collection<String> coll = new ArrayList<>();
        coll.add("第一个");
        coll.add("第二个");
        coll.add("第三个");
//        coll.for
        for (String s:coll){
            System.out.println(s);
        }

    }
}

forEach遍历

package day基础.day13集合;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.function.Consumer;
public class Test02 {
    public static void main(String[] args) {
        Collection<String> coll = new ArrayList<>();
        coll.add("第一个");
        coll.add("第二个");
        coll.add("第三个");
//        forEach(new 一个接口)
        coll.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });

    }
}

List 集合特有方法

方法名称	说明
void add(int index,E element)	在此集合中的指定位置插入指定的元素
E remove(int index)	删除指定索引处的元素,返回被删除的元素
E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
E get(int index)	返回指定索引处的元素

package day基础.day13集合;

import java.util.ArrayList;
import java.util.List;

public class Test03 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
//                添加
        list.add("1");
        list.add("2");
        list.add("3");
//        按下表进行添加内容
        list.add(1,"p");
        System.out.println(list);
//        删除元素
        list.remove(1);
        list.remove("3");
        System.out.println(list);

        String res=list.set(1,"1111");
        System.out.println(res);

        String s=list.get(0);
        System.out.println(s);
    }
}

Arraylist

利用空参创建的集合，在底层创建一个默认长度为0的数组

添加第一个元素时，底层会创建一个新的长度为10的数组

存满时，会扩容1.5倍

LinkedList

链表的特点1:查询慢，无论查询哪个数据都要从头开始找。

链表的特点2:链表增删相对快

Vector

11-1-2 Set

set系列集合:添加的元素是无序、不重复、无索引

hashSet ：无序、不重复、无索引。

LinkedHashSet：有序、不重复、无索引。

TreeSet：排序、不重复、无索引。

package day基础.day13集合;

import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;
public class Test {
    public static void main(String[] args) {
//        创建了一个HashSet的集合对象。无序 不重复 无索引
        Set<Integer> set1 = new HashSet<>();
//        有序  不重复 无索引
        Set<Integer> set2 = new LinkedHashSet<>();
//        可排序  不重复 无索引
        Set<Integer> set3 = new TreeSet<>();

        set1.add(666);
        set1.add(888);
        set1.add(999);
        System.out.println(set1);
//        ----------------
        set2.add(777);
        set2.add(666);
        set2.add(999);
        System.out.println(set2);
    }

}

泛型集合

Map集合

Map集合的键不能重复

Map集合的值可以重复

HashMap

HashMap（由键决定特点):无序、不重复、无索引;(用的最多)

LinkedHashMap（(由键决定特点）:由键决定的特点:有序、不重复、无索引。

TreeMap（由键决定特点):按照大小默认升序排序、不重复、无索引。

十二、接口

12-1 interface

Java提供了一个关键字interface，用这个关键字我们可以定义出一个特殊的结构:接口。

public interface接口名{
// 成员变量（常量)
// 成员方法（抽象方法)
)

A

public interface A {
//    成员变量（常量)  public static final 默认加着呢，可以不写
     String name="小马";

//     成员方法（抽象方法)   public abstract 默认加着呢，可以不写
      void test();

}

main方法

public class Test {
    public static void main(String[] args) {
        System.out.println(A.name);
    }
}

12-2 implements

接口不能创建对象;接口是用来被类实现（implements)的，实现接口的类称为实现类。

一个类可以实现多个接口（接口可以理解成干爹)，实现类实现多个接口，必须重写完全部接口的全部抽象方法，否则实现类需要定义成抽象类。

main方法

package day基础.day09接口.day01;
public class Test {
    public static void main(String[] args) {
//        使用D创建对象
        D d=new D();
        d.testb1();
    }
}

实现类实现类实现多个接口

package day基础.day09接口.day01;
//------实现类----
public class D implements  B,C{
// 会出现报错  快捷键重写方法/实现方法ALT+INS 生成B，C。所有的接口和抽象方法

    @Override
    public void testb1() {

    }

    @Override
    public void testb2() {

    }

    @Override
    public void testc1() {

    }

    @Override
    public void testc2() {

    }
}

B

package day基础.day09接口.day01;
public interface B {
    void testb1();
    void testb2();
}

C

package day基础.day09接口.day01;
public interface C {
    void testc1();
    void testc2();
}

12-3 jdk8新特性

默认方法:必须使用default修饰，默认会被public修饰

package day基础.day09接口.day03;
public interface A1 {
//    默认方法:必须使用default修饰，默认会被public修饰
    default void test(){
        System.out.println("默认方法default");

    }
//    静态方法:必须使用static修饰,默认会被public修饰
    static void test2(){
        System.out.println("静态方法");
    }
//    私有方法:必须用private修饰(JDK9开始才支持)
    private void test3(){
		 System.out.println("私有方法");
//    }

}

package day基础.day09接口.day03;
public class B1 implements A1{

}

--------------------main方法-------------------------
package day基础.day09接口.day03;
import day基础.day09接口.day01.B;
public class Text01 {
    public static void main(String[] args) {
        B1 b=new B1();
        b.test();
        A1.test2();
    }
}

十三、异常处理

13-1 异常概述

package day基础.day10异常处理;
public class Test {
    public static void main(String[] args) {

// 会发生算术异常 报错信息 ArithmeticException
        System.out.println(10/0);

// 数组下标越界异常 报错信息 ArrayIndexOutOfBoundsException
        int[] arry=new int[]{1,2,3,4};
        System.out.println(arry[10]);

// 发生空指针异常  报错信息 NullPointerException
        int[] array=null;
        System.out.println(array.length);

// 类型转换异常


// 数字格式异常

	}
}

13-2 异常处理方式

Error:代表的系统级别错误(属于严重问题)Error是给公司自己用的，不是给我们程序员用的，因此我们开发人员不用管它。

Exception:叫异常，我们程序员通常会用Exception以及它的孩子来封装程序出现的问题。

在Java中，异常处理主要的5个关键字：throw、try、catch、final、throws。

13-2-1 异常的抛出throw

可以借助throw关键字，抛出一个指定的异常对象，将错误信息告知给调用者。具体语法如下：

方法 throws 异常1，异常2..{
		...
}

13-2-2 异常的捕获try-catch

直接捕获程序出现的异常

try{
   执行可能出现异常的代码
}catch(要捕获的异常类型 变量){
   匹配（对应的异常）
}catch(异常类型 变量){
   匹配（对应的异常）
}

try{
   执行可能出现异常的代码
}catch(要捕获的异常类型 e){
   匹配（对应的异常）
  // 如果try中的代码抛出异常了，此处catch捕获时异常类型与try中抛出的异常类型一致时，       或者是try中抛出异常的父类时，就会被捕获到
 // 对异常就可以正常处理，处理完成后，跳出try-catch结构，继续执行后序代码
}catch(异常类型 e){
  // 对异常进行处理
} finally{
   执行 资源的关闭
  // 此处代码一定会被执行到
}

package day基础.day10异常处理;
import java.text.SimpleDateFormat;
import java.util.Date;
public class throw05 {
    public static void main(String[] args) {
//选择然后 快捷键 ctrl+alt+t
        try {
            SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Date d =sdf.parse("2025-11-11 10:24");
            System.out.println(d);
        } catch (Exception e) {
//            把异常信息打印出来
            e.printStackTrace();
        }
    }
}

把parse异常抛出去，交给上一层处理

package day基础.day10异常处理;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class throw06 {
                                            //    把异常抛出去
    public static void main(String[] args) throws ParseException {
//选择然后 快捷键 ctrl+alt+t

//        try {
            SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Date d =sdf.parse("2025-11-11 10:24");
            System.out.println(d);
    }
}

13-2-3 自定义异常

package day基础.day10异常处理;

import java.util.Scanner;
public class Test02 {
    public static void main(String[] args) {
        while (true) {
            try {
                System.out.println(getMony());
            } catch (Exception e) {
//                把异常信息打印出来
//                e.printStackTrace();
                System.out.println("输入的内容不合法");
            }
        }
    }
    public static double getMony(){
        Scanner sc=new Scanner(System.in);
        while (true) {
            System.out.println("请输入合适的价格");
            double money=sc.nextDouble();
            if(money>0){
                return money;
            }else {
                System.out.println("你输入的价格错误");
            }
        }
    }
}

技术交流群欢迎加入