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;i8-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 coll = new ArrayList<>();
coll.add("第一个");
coll.add("第二个");
coll.add("第三个");
Iterator 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 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 coll = new ArrayList<>();
coll.add("第一个");
coll.add("第二个");
coll.add("第三个");
// forEach(new 一个接口)
coll.forEach(new Consumer() {
@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 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 set1 = new HashSet<>();
// 有序 不重复 无索引
Set set2 = new LinkedHashSet<>();
// 可排序 不重复 无索引
Set 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("你输入的价格错误");
}
}
}
}
技术交流群：点击跳转进群