Java学习笔记

Java

1.2语言发展史

1.java语言在1996发布

2.java5.0更新力度非常大，使java进入了发展的快车道

3.java8.0是公司使用最多的版本

4.11.0用来初学

Java语言跨平台原理

1.平台：指的是操作系统，可以在任意操作系统上运行Windows，macos

2.需要一个翻译：Window版本的JVM，maocos版本的JVM，Linux版本的JVM

JRE和JDK

1.JRM是程序的运行时环境，包含JVM和运行时需要的核心类库（Java Runtime Environment）

JRE（Java Runtime Environment）

想要运行java程序安装JRE就可以2.JDK是Java程序的开发工具包，包含JRE和开发人员使用的工具(Java Development Kit)

包括编译工具（Javac.exe Java.exe)

开发一个全新的Java程序需要JDK

3.JDK包含JRE和开发工具

_JDK的下载和安装

1.Oracle | Cloud Applications and Cloud Platform

2.安装路径不要有中文和空格

常用dos命令

1.打开命令提示符窗口

win+R，输入cmd

2.c盘切换到e盘，e：

dir查看当前文件夹下面的文件夹

cls清屏

exit关闭窗口

_PATH环境变量的配置

左键我的电脑，选择属性，高级系统设置

Java编程

1.需要三个步骤：编写程序，编译程序，运行程序

2.编译程序需要javac，运行程序需要java

3.Helloworld案例的编写

新建文本文档。修改名称为Helloworld.java

记事本打开Helloworld.java，输入程序的内容

4.具备识别bug的能力，具备分析bug的能力，具备分析bug的能力

Notepad软件的安装和使用

显示行号

注释

1.在程序指定位置的说明性信息

单行注释//

多行注释/* */

文档注释/** */

java程序中最基本的组合是类，类的定义格式是

public class 类名{

}

main方法是程序的入口方法

关键字

1.java语言赋予特定含义的单词

2.关键字全部小写

常量

1.不变的值是常量

2.字符串常量（双引号括起来的量），整数常量，小数常量，字符常量（单引号括起来的量），布尔常量，空常量

3.空常量不能直接输出，布尔常量可以直接输出

数据类型

1.java是强制类型语言，对于每一种数据都给出了明确的数据类型，不同的数据类型也分配了不同的内存空间，所以它们表示的数据类型也是不一样的

2.基本数据类型：数值型(整数，浮点数，字符），非数值型（布尔），引用数据类型（类，接口，数组）

变量

1.在程序运行过程中，其值可以发生改变的量。本质上讲，变量是内存中的一小块区域

2.变量名，数据类型，值。

3.取值和修改值变量使用时的注意事项

4.long 1=10000000000;

会报错

因为默认为int类型

long 1=10000000000L;

定义float类型的变量float f=13.14;

会报错

应定义为float f=13.14F;

5.名字不能重复

变量未赋值，不能使用

long类型的变量定义的时候，为了防止整数过大，后面加L

float类型的变量定义的时候，为了防止类型不兼容，后面加F

标识符

1.由数字，字母，下划线，美元$组成

2.不能以数字开头，不能是关键字，区分大小写

3.常见的命名约定

小驼峰命名法（针对方法和变量命名的）：

一个单词的时候首字母小写

多个单词组成的时候，第一个单词首字母小写，其余单词首字母大写，例如firstName

大驼峰命名法（根据类命名）：

一个单词的时候，首字母大写

多个单词的时候，每个单词首字母大写

类型转换

1.类型转换的分类

自动类型转换

把一个表示数据范围小的数据或者变量赋值给另一个表示数据范围大的变量

byte-short-int-long-float-double

char-int-long-float-double

byte不能转换为char

2.强制类型转换，把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量

运算符

1.加减乘除取余

整数相除得到整数，要想得到小数必须有浮点数的参与

2.字符的+操作

字符0是48，字符a是97，字符A是65

byte，short，char类型会提升到int类型

3.字符串的+操作

“it”+“heima”=itheima

"it"+666=it666

做的是字符串的拼接

“黑马”+6+66=黑马666

1+99+“黑马”=100黑马

先有整数加法会先执行整数加法

数据输入

scanner使用的基本步骤

import java.util.scanner

导包：导包的动作必须出现在类定义上面

创建对象：Scanner sc=new Scanner(system.in);

接收数据：int i=sc.nextInt();

三元运算符

1.关系表达式?表达式1:表达式2

三个和尚升级版

1.身高测量的输出

首先导包，然后创建对象

import java.util.scanner;

Scanner sc=new Scanner(System.in);

键盘录入三个身高赋值给三个变量

int height1=sc.nextlnt();

int height2=sc.nextlnt();

int height3=sc.nextlnt();

顺序结构

流程控制语句的分类

顺序结构

循环结构

条件结构

选择结构

1.if(关系表达式){

语句体;

}

2.if_else结构

3.if...else if...if结构

4.switch语句

循环结构

for循环结构

while循环

do...while

Random

1.用于产生一个随机数

导包

import java.util.Random

创建对象

Random r=new random();

获取随机数

int number=r.nextInt();获取的数据范围是0到9的随机数

IDEA

1.IDEA概述和安装：是用于java语言的集成开发环境，它是业界公认的目前用于Java程序开发的工具

集成环境：把代码编写，编译，执行，调试等多种功能综合到一起的开发工具

下载位置

IntelliJ IDEA – the Leading Java and Kotlin IDE

2.IDEA中的helloworld步骤

创建一个空项目JavaSE_Code

创建一个新模块idea_test

在idea_test模块下的src下创建一个包(com.itheima)

在com.itheima下建立一个类(Hello world)

在Helloworld类中编写代码

在idea中执行程序

数组

1.一次性声明大量的用于存储数据的变量

要存储的数据通常都是同类型数据，例如：考试成绩

2.数组定义格式：

数据类型[] 变量名

int[] arr

定义了一个int类型

数据类型 变量名[]

int arr[]

定义了一个int类型的变量，变量名是arr数组

3.数组初始化

java中的数组必须初始化然后才能使用

4.数组动态初始化

数据类型[] 变量名=new 数据类型[数据长度];

int[] arr=new int[3];

左边：

int说明数组中的元素类型是int类型

[]说明这是一个数组

arr是数组的名称

右边

new为数组申请内存空间

int说明数组中的元素类型是int类型

[]说明是一个数组

3数组长度

5.数组元素访问

数组变量的访问方式

格式：数组名

索引是数组中数据的编号方式

索引是连续的

6.输出数组中的元素

7.内存分配

Java程序在运行时，需要在内存中分配空间。为了提高运算效率，就对空间进行了不同区域的划分

int[] arr会开辟一块内存空间,叫栈内存，存储局部变量

new int[3]会开辟另一块内存空间，并用一个内存地址标记，会将这个内存地址交给int[] arr，叫堆内存，存储new出来的内容（实体，对象）

局部变量是定义在方法中的变量，例如arr，使用完毕，立即消失

8.单个数组内存图

int arr[]=new int[3];

9.多个数组的内存图

10.多个数组指向相同的内存图

int[] arr2=arr;

11.数组静态初始化

数据类型[] 变量名=new 数据类型[]{数据1，数据2，数据3，数据4......};

12.数组操作中的两个常见小问题

越界访问

空指针异常：访问的数组已经不再指向堆内存的数据，造成空指针异常

13.遍历

14.获取数组元素的数量

数组名.length

范例：arr.length

int arr={11,22,33,44,55};

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

•   System.out.println(arr[x]);

}

15.获取最值

int[] arr={12,45,98,73,60};
int max;
int max=arr[0];
for(int x=1;x<arr.length;x++){
 if(arr[x]>max){
•   max=arr[x];
•   }
}

方法

方法概述

int a;

int b;

int max=a>b?a:b;

System.outprintln("max"+max)

可以打包为一个方法

方法是具有独立的代码块组织成为一个整体，使其具有特殊功能的代码集。

方法必须先创建才能使用，该过程称为方法定义。

方法创建后并不是直接运行，需要手动使用后才能执行，该过程称为方法调用。

方法定义和调用

方法定义

public static void 方法名(){

//方法体

}

方法调用

方法名();

需求定义一个方法，在方法中定义一个变量，判断该数据是否是偶数

方法必须先定义后调用

方法调用过程

public class MethodDemo{
​
•   public static void main(String[] args){
​
•       is EvenNumber();
​
•   }
​
}
​
public static void isEvennumber(){
​
•   int number=10;
​
•   if(number%2==0){
​
•       System.out.println(true);
​
•   }
​
•   else{
​
•       System.out.println(false);
​
•   }
​
}

带参数方法的定义和调用

public static void 方法名（数据类型，变量名）{

}

调用

方法(变量名/常量值);

形参和实参

1.形参：方法定义中的参数

2.实参：方法调用中的参数

带返回值方法的定义和调用

boolean flag=isEvenNumber(5);

方法注意事项

1.方法不能嵌套定义，方法里面不能定义方法

2.void可以不写return，可以写单独的return;

方法的通用格式

public static 返回值类型 方法名(参数){ 方法体

return 数据；

}

public static是修饰符

方法重载

1.

public class MethodDemo{
​
public static int sum(int a,int b){
​
•   return a+b;
​
}
​
public static int sum(int a,int b,int c){
​
•   return a+b+c;
​
}
​
}

方法重载指的是一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载

1.多个方法在同一个类中

2.多个方法有相同的方法名

3.多个方法的参数不相同，类型不同或数量不同

方法重载的特点

1.重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式

2.重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，不根据返回值判定两个方法是否构成重载

方法的参数传递

方法参数传递的基本类型

基本数据类型的参数，形式参数的改变，不影响实际参数的值

方法参数传递引用类型

1.syso输出语句

2.对于引用类型的参数，形式参数的改变，影响实际参数的值

public sattic void 方法名(int[] arr){ }

System.out.println("内容")；输出换行

System.out.print("内容")；输出不换行

System.out.println()；起到换行的作用

Debug

1.Debug是供程序员使用的调试工具，它可以用于查看程序的执行流程，也可以追踪程序执行过程来调试程序

2.差看程序执行流程

面向对象基础

类和对象

万物皆对象

面向对象的编程是面向一个对象说的

类是对现实生活中一类具有共同属性和行为的事物的抽象

类的特点

类是对象的数据类型

类是具有相同属性的一组对象的集合

属性：对象具有的各种特征，每个对象的每个属性都有特定的值

行为：对象能执行的操作

类和对象的关系

类：类是对现实生活中一类具有共同属性和行为的事物的抽象

对象：是能够看得见摸的着的真实存在的实体

类是对象的抽象，对象是类的实体

类的定义

类的重要性：类是Java程序的基本组成单位

类的组成：属性和行为

属性：在类中通过成员变量来实现（类中方法外的变量）

行为：在类中通过成员方法来体现（和前面的方法相比去掉了static关键字）

类的定义

public class 类名{

//成员变量

//成员方法

}
public class phone{
​
•   String brand;
​
•   int price;
​
•   public void call{
​
•       SYstem.out.println("打电话")；
​
•   }
​
•   public void sendMessage{
​
•       SYstem.out.println("发短信")；
​
•   }
​
}

对象的使用

创建对象

格式：类名 对象名=new 类名();

范例 phone p=new phone();

public class PhoneDemo{
​
•   public static void main(String[] args){
​
•       //创建对象
​
•       Phone p=new Phone();
​
•       //使用成员变量
​
•       System.out.println(p.brand);
​
•       System.out,println(p.price);
​
•       p.call();
​
•       p.SendMessage();
​
•   }
​
}

private关键字

1.是一个权限修饰符，可以修饰成员，作用是保护成员不被别的类使用。

2.被private修饰的成员只能在本类中才能访问。

3.针对private修饰的变量，如果需要被其他类使用，提供相应的操作

提供get变量名()方法，用于获取成员变量的值，方法用public修饰

提供set变量名（参数）方法用于设置成员变量的值，方法用public使用

this关键字

1.形参如果与成员变量同名，不带this修饰的变量是形参，方法内用this修饰就是成员变量，否则就是局部变量

2.没有同名，不带this修饰代表的也是成员变量

3.方法被哪个对象调用，this就代表哪个对象

构造方法的注意事项

1.构造方法可以给成员变量赋值

2.如果没有定义构造方法，系统将给出一个默认的无参构造方法。

3.如果自定义了带参构造方法还要使用无参构造方法，就必须再写一个无参数构造方法

标准类制作

1.成员变量

使用private修饰

2.公祖奥方法

提供一个无参构造方法

提供一个带多个参数的构造方法

API

1.应用程序编程接口

java API就是JDK中提供的各种功能的Java类

2.使用

打开帮助文档

String

1.代表字符串，java程序中所有的字符串都被实现为此类的实例

2.在java.lang包下面

3.字符串不可变，他们的值在创建后不能被更改

虽然string的值不可变，但是它们可以被共享

效果上相当于字符数组，实际上是字节数组

string是构造方法

1.public String()创建一个空白字符串对象，不含任何内容

public String(char[] chs)根据字符数组的内容，来创建字符串对象

public String(byte[] bys)根据字节数组的内容，来创建字符串对象

String s="abc"

String字符串的比较

1.基本类型：比较的是数据值是否相同

引用类型：比较的是地址值是否相同

2.字符串是对象，它比较内容是否相同，是通过一个方法来实现，这个方法叫做equals()

public boolean equals(Object anObject):将此字符串与指定对象进行比较。由于我们比较的是字符串对象，所以参数直接传递一个字符串。

StringBuilder和String相互转化

String s=sb.toString();

StringBuilder sb=new Stringbuilder(s);

Stringbuilder sb=new Stringbuilder("hello");

sb.append();

sb.reverse();

字符串拼接翻转

1.定义一个int类型的数组，通用静态初始化完成数组元素的初始化

2.定义一个方法，用于把int数组中的数据按照指定的格式拼接成一个字符串返回。返回类型值String，参数列表int[] arr

3.在方法中用StringBuilder按照要求进行拼接，并把结果转成String返回

4.调用方法，用一个变量接受结果

5.输出结果

定义方法先明确返回值类型和参数

代码实现

public static String arrayToString(int[] arr){
​
•   StringBuilder sb =new StringBuilder();
​
•   sb.append("[");
​
•   for(int i=0;i<arr.length;i++){
​
•       if(i=arr.length-1){
​
•               sb.append(arr.length[i]);
​
•       }
​
•       else{
​
•           sb.append(arr[i]).append(", ");
​
•       }
​
•   }
​
}

翻转字符串

pubilic static String myReverse(String s){
​
•   StringBuilder sb=new StringBuilder(s);
​
•   sb.reverse();
​
•   String ss=sb.toString();
​
•   return ss;
​
}

StringBuilder 帮助文档

1.append可以跟任意的数据类型

2.StringBuilder返回字符串

Arraylist

1.集合基础

编程的时候要存储多个数据，使用长度固定的数据存储格式，不一定满足我们的需求，更适应不了变化的需求

集合的特点：提供了一种存储空间可变的存储模型，存储的数据容量可以发生改变。

ArrayList是一个集合，在java.util

Arraylist<String> array=new arraylist<String>();

无元素返回一个中括号

array.add("hello");

array.add（"world");

array.add(index:1,element:"javase");

2.Arraylist常用方法

1.array.remove(o:"world");

2.array.remove(index:1);

3.array.set(1,"javaee"); //set是修改，不能索引越界

4.array.get(0);

5.array.size(); //得到集合中的元素的数量

3.集合的遍历

for(int i=0;i<array.size();i++){

}

学生管理系统

1.实现思路

1.定义学生类

2.主界面的代码编写

3.添加学生代码编写

4.查看学生代码编写

5.删除学生代码编写

6.修改学生代码编写

Alt+insult

2.主界面的代码

1.用输出语句完成主界面的编写

2.用Scanner实现键盘录入数据

3，用Scanner实现操作的选择

4.用循环完成

System.exit(status:0); ///JVM退出

继承

1.继承是面向对象的三大特征之一。

2.可以使得子类具有父亲的属性和方法，还可以在子类中重新定义，追加属性和方法。

public class 子类名 extends 父亲名{}

3.父类，也被称为基类，超类。

4.子类，被称为派生类。

继承的好处和弊端

1.提高了代码的复用性

2.提高了代码的维护性

3.继承让类与类之间产生了关系，父类改变，子类改变，削弱了子类的独立性。

Super

1.super.变量访问的是父类中的成员变量

2.this 本类对象引用

3.super 父类对象引用

继承中构造方法的访问特点

1.子中的构造方法被调用时候会访问父类中构造方法

2.子类初始化之前，一定呀完成父类的初始化

3.每一个子类构造方法的第一条语句默认都是 super();

继承中变量的访问特点

子类中所有的构造方法默认都会访问父类中无参的构造方法

为什么呢

因为子类会继承父类中的数据，可能还会使用父类中的数据。所以，子类在初始化之前，一定要完成父类的初始化

每一个子类构造方法的第一条语句默认都是super();

如果父类中没有无参的构造方法，只有带参的构造方法，该怎么办呢

通过super关键字去显示的调用父亲的带参构造方法

在父类中自己提供一个无参构造方法

集成中成员方法的访问特点

1.从子方法中调方法，首先从子类里面找，子类里面没有，从父类里面找。

2.不考虑父亲的父亲

方法重写

1.方法重写

2.子类中出现和父类一模一样的方法声明

方法重写的应用

当子类需要父类的功能，二功能主题子类拥有自己特有的内容时，可以重写父亲中的方法，这样既沿袭了父类的功能，又定义了子类特有的功能。

3.@override

标注重写

可以帮助我们检查正确性

父类中的私有内容子类是不能继承到的

没有public和private也会有默认的标识符

private低于public

java中继承的注意事项

1.java中类不能同时继承多个类

2.son可以继承father，father可以继承granddad

_Package

1.包其实就是文件夹

作用：对类进行分类管理

2.包的概述和使用

格式：package 包名;

3.带包的java编译和执行

手动建包

按照以前的格式编译java文件 javac Helloworld.java

手动创建包 在E盘下建立文件夹itheima

把class文件放在包里面

带包执行

自动建包

javac -d. Helloworld.java

java com.itheima

导包

java.util.Scanner sc=new java.util.jianjianScanner(System.in);

import 包名

修饰符

同一个类中，四种表示符都可以访问到

同一个包中子类无关类。默认，protected，public可以访问到

不同包子类，protected，public可以访问到

不通包无关类只有public可以访问到

状态修饰符

1.final

一个方法被final修饰不可以被重写

一个类被final修饰不可以被继承

一个变量被final修饰不可以被修改

2，final修饰局部变量

final修饰引用变量，其实是一个地址不能变，这个变量可以变

4.static修饰的特点

被类的所有对象共享

这也是我们判断是否使用静态关键字的条件

可以通过类名调用

当然,也可以通过对象名带调用

5.静态的成员变量只能访问静态成员

多态

1.多态的前提和实现

有继承/实现关系

有方法重写

有父类引用指向子类对象

2.多态中成员的访问特点

成员变量：编译看左边，执行看左边

成员方法：编译看左边，执行看右边

为什么成员变量和成员方法的访问不一样呢

因为成员方法有重写，而成员变量没有

3.多态的好处和弊端

好处：提高了程序的扩展性，使用父类作为参数，将来在使用的时候，使用具体的子类型参加操作

弊端：不能使用子类的特有功能

4.多态中的转型

向上转型：

从子到父

父亲引用指向子类对象

向下转型

从父到子

父类引用转为子类对象

抽象类

1.在Java中，一个没有方法体的方法定义为抽象方法，而类中如果有抽象方法，该类必须定义为重选ing类

2.抽象类需要abstract修饰

3.抽象类中可以没有抽象方法

4.抽象类的特点

有抽象方法的一定是抽象类

抽象类中不一定有抽象方法

抽象类不能实例化

抽象类的子类：要么重写父类中所有的抽象方法，要么就是抽象类

5.抽象类的成员特点

抽象类可以有变量和常量

接口

1.接口是一种公共的规范标准，只要符合规范请按标准，大家都可以使用

Java中的接口更多的体现在对行为的抽象

2.接口特点

public interface 接口名{}

public class 类名 implements 接口名{}

接口的成员特点

1.接口中的成员变量

接口中的成员变量默认是final修饰的

2.Inter.num

3.接口中的成员变量

public static final int num3=30等效于int num=30

4.接口不能实例化，只能通过实现类进行实例化

5.接口是没有构造方法的，接口主要对行为进行抽象的

6.类Object是类层次结构的根，每个类都有Object作为超类。所有对象（包括数组）都实现了这个类的方法

7.成员方法

接口里面不能有非抽象方法

8.接口里面的方法默认带着public abstract修饰

猫和狗

1.思路：定义接口

成员方法：跳高();

定以抽象动物类

成员变量：姓名，年龄；构造方法：无参带参；成员方法：get/set方法，吃饭

定义具体猫类

定义具体狗类

类和接口的关系

1.类和类的关系

继承关系，只能单继承，但是可以多层继承

2.类和接口的关系

实现关系，可以单实现，还可以在继承一个类的同时实现多个接口

3.接口和接口的关系

继承关系，可以单继承，也可以多继承

抽象类和接口的区别

1.

成员区别

抽象类：变量，常量：有构造方法，也有非抽象方法

接口：常量：抽象方法

关系区别：

类与类 继承，单继承

类与接口 实现 可以单实现，也可以多实现

接口与接口 继承，单继承，多继承

2.

抽象类是对事物的抽象，而接口是对行为的抽象

类名作为形参和返回值

public class Cat{
•   public void eat(){
•       System.out.println("猫吃鱼");
•   }
}

public class Catoperater{
•   public void useCat(Cat c){
•           c.cat();
•   }
•   public Cat getCat(){
•       Cat c=new Cat();
•       return c;
•   }
}

public class CatDemo{
•   public static void main(String[] args){
•       Catoperater co=new Catoperater();
•       Cat c=new Cat();
•       co.useCat(c);
•       Cat c2=co.getCat();
    }
}

方法的形参是该类的类名，其实需要的是该类的对象

方法的返回值是类名，其实返回的是该类的对象

抽象类名作为形参和返回值

方法的形参是抽象类名，其实需要的是该抽象类的子类对象

方法的返回值是抽象类名，其实返回的是抽象类的子类对象

public abstract class Animal{
•   public abstract void eat();
}
public class AnimalOperater{
•   public void useAnimal(Animal a){
•       a.eat();
•   }
}
public class Cat extends Animal{
•   public void eat(){
•       System.out.println("猫吃鱼");
•   }
}
public class AnimalDemo{
•   public static void main(String[] args){
•       AnimalOperater ao=new AnimalOperater();
•       Animal a=new Cat();
•       ao.useAnimal(a);
•       Cat a2=ao.getAnimal();
•   }
}

接口名作为形参和返回值

public interface JumppingOperater{
•   public void useJumpping(Jumpping j){
•       j.jump();
•   }
    public Jumpping getJumpping(){
        Jumpping j=new Cat();
        return j;
    }
}

public class  Cat implements Jumpping{
•   @override
•   public void jump(){
•       System.out.println("猫可以跳高了");
•   }
}

方法的形参是接口名，其实需要的是该接口的实现类对象

方法的返回值是接口名，其实返回值是接口的实现类对象

内部类

1.就是在一个类中定义一个类，在一个类A的内部定义一个类B，类b是内部类

2.特点： 内部类可以直接访问外部类的成员，包括私有

外部类要访问内部类的成员，必须创建对象

成员内部类

1.在类的定义位置不同，可以分为以下两种形式

在类的成员位置：成员内部类

在类的局部位置：局部内部类

public class Outer{
•   private int num=100;
    public class Inner{
•       public void show(){
•           System,out,println(num);
•       }
    }
}

//外部访问内部类
Outer.inter oi=new Outer().new.inter();

public class Outer{
    private int num=100;
    private class Inner{
        public void show(){
            System,out,println(num);
        }
    }
    public void method(){
        Inner i=new Inner();
        i.show();
    }
}

局部内部类

public class Outer{
    private int num=100;
    public void method(){
•      class Inner{
•           public void show(){
•               System,out,println(num);
•           }
•      }
    }
    Inner i=new Inner();
    i.show();
}

局部内部类是方法内部定义的类，外界是无法使用的，需要在方法内部创建对象并使用

该类可以直接访问外部类的成员，也可以访问方法内的局部变量

匿名内部类

前提：存在一个类或者接口，这里的类可以是具体的类也可以是抽象类

Math(常用API)

1.Math包含执行基本数字运算的方法

2.没有构造方法

3.用static修饰的方法是可以通过方法名访问的

4.

public static int abs(int a)

public static double ceil(double a)

public static double floor(double a)

public static int max(int a,int b)

public static int min(int a,int b)

public static double pow(double a,double b) //求a的b次幂

public static double random() //返回double的正值 【0.0 1.0】

Math.abs()

5.java.lang包下，不需要导包

System(常用API)

1.System包含几个有用的类字段和方法，它不能被实例化

2.

public static void exit();

用于终止当前正在运行的java虚拟机

System.exit(status: 0);

3.

public static long currrentTimeMillis()

返回当前时间，单位为毫秒(返回当前时间与1970年之间的毫秒值)

Object类的tostring()方法

1.object是所有类的层次结构的根，每个类都有object作为超类，所有对象都实现了这个类的方法

2.为什么子类只访问了父类的无参构造方法，因为他们的顶级父类只有无参构造方法

3.双击方法goto找declaration

或者选中方法按下Ctrl+b，查看源码

4.为了在子类中可以看明白子类信息，而不是无效信息，可以重写tostring方法

建议操作为Alt+insert tostring

Object中的equal()方法

1.

s1.equal(s2);

2.

在子类中重写的简单方法

Alt+insert equal() 选择模板Intel Default

next

3.重写后的方法

先判断地址，一样返回true

再判断参数是否为NULL，为NULL返回false

判断两个对象是否为一个类的，否返回false

4.向下转型

Arrays

1.

java.util

需要导包

包含用于操作数组的各种放方法

2.

Arrays类中包含的各种操作数组的方法

public static String toString(int[] a)

返回指定数组的内容的字符串表示形式

public static void sort(int[] a)

按照数字排列指定的数组

3.

Arrays.toString(arr);

Arrays.sort(arr);

4.工具类的设计思想 构造方法用private修饰

成员方法用public static修饰

基本类型包装类

1.

Integer类

public final class Integer

在java.lang包下面，使用时不需要导包

java.lang.Integer继承自java.lang.Number

java.lang.Number继承自java.lang.Object

2.

Integer类下面有

public static final int MAX_VALUE

public static final int MIN_VALUE

3.

调用时

Integer.MAX_VALUE

4.

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据

常见的操作是：用于基本数据类型与字符串之间的转换

5.基本数据类型有：byte short int long float double char boolen

分别对应的包装类是：Byte Short Integer Long Float Double Character Boolen

Integer

1.Integer类的概述和使用

过时的方法是可以用的

过时的构造方法：

public Integer(int value)

public Integer(String s)

2.

用过时的方法创建对象

Integer i2=new Integer(value:100);

Integer i2=new Integer(s:"100");

3.

用不过时的方法创建对象

Integer i1=Integer.valueof(100);

Integer i1=Integer.valueof("100");

int和String的互相转换

不专业的int类型转换成String

int number=100；
String s1=""+number;
System.out.println(s1);
//字符串做加法实际上是字符串的拼接

专业方式

Integer i1=Integer.valueof(100);
String s2=String.valueof(number);
System.out.println(s2);

String转成int

借助Integer间接转化

String s="100"；
//先把String转化成Integer类型，再把Integer转化成int类型
Integer i=Integer.Valueof(s);
//public  int intValue()
int x=i.intValue();
System.out.println(x);

直接转化

//public static int parseInt(String s)
String s="100"；
int y=Integer.parseInt(s);
System.,out.println(y);

Date

一个Date类在java.sql包下

现在学的是util下面的Date类

Date代表了一个特定的时间，以毫秒为精度

public class Date

有两个构造方法

public Date()

public Date(long date)

代码演示

import java.util.Date;
public class DateDemo{
   public static void main(String[] args){
      Date d1=new Date();
      System.out.println(d1);
      long date=1000*60*60;
      Date d2=new Date(date);
      System.out.println(d2);
       //此时输出会受到时差影响
    }
}

代码输出为

Sat Mar 05 21:22:27 CST 2022 Thu Jan 01 09:00:00 CST 1970

Date常用方法

1.

public long getTime()

//获取的是日期对象从1970年1月1日00;00;00到现在的毫秒值

public void setTime(long time)

//设置时间给的是毫秒值

import java.util.Date;
public class Demo{
   public static void main(String[] args){
      Date d=new Date();
      System.out.println(d.getTime()*1.0/1000/60/60/24/365+"年");
   }
}
import java.util.Date;
public class Demo{
   public static void main(String[] args){
      Date d=new Date();
       long time=1000*60*60;
       d.setTime(time);
      System.out.println(d);
   }
}

SimpleDateFormat

1.

java.text.SImpleDateFormat继承自java.text.DateFormat

java.text.DateFormat继承自java.text.Format

java.text.Format继承自Java.lang.Object

int main(){

return 0；

}

2.允许您从选择日期格式化的任何用户定义的模式开始

日期和时间日期和时间模式字符串指定，在日期和时间模式字符串中，从A到Z以及a到z引号字母被解释为表示日期或时间字符串的组件模式字母

3.SimpleDateFormat是具体的类，用于以区域设置敏感的方式格式化和解析日期，我们重点学习日期格式化和解析

4.

y 年

M 月

d 日

H 时

m 分

s 秒

5.SimpleDateFormat的构造方法

public SimpleDateFormat() 构造一个SimpleDateFormat，使用默认的模式和日期格式

public SimpleDateFormat(String pattern) 构造一个SimpleDateFormat，使用给定的的模式和默认的日期格式

6.SimpleDateFormat的格式化和解析日期

public final String format(Date date)

将日期格式化成日期时间字符串

public Date parse(String source)

从给定字符串的开始解析文本以生成日期

7.实例

import java.text.SimpleDateFormat;
import java.util.Date;
public class StudentDemo{
    public static void main(String[] args){
        Date d=new Date();
        SimpleDateFormat sdf=new SimpleDateFormat();
        String s=sdf.format(d);
        System.out.println(s);
    }
}
//输出:2022/3/6 上午11:26

import java.text.SimpleDateFormat;
import java.util.Date;
public class StudentDemo{
    public static void main(String[] args){
        Date d=new Date();
        SimpleDateFormat sdf=new SimpleDateFormat("yyyyMMddHHmmss");
        String s=sdf.format(d);
        System.out.println(s);
    }
}
//输出：20220306112545

import java.text.SimpleDateFormat;
import java.util.Date;
public class StudentDemo{
    public static void main(String[] args){
        Date d=new Date();
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        String s=sdf.format(d);
        System.out.println(s);
    }
}
//输出：2022年03月06日 11:28:09

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class StudentDemo{
    public static void main(String[] args) throws ParseException {
        String ss="2048-08-09 11:11:11";
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date dd=sdf.parse(ss);
        System.out.println(dd);
    }
}

日期工具类

1.

定义一个日期工具类(DateUtlis),包含两个方法：把日期转换成指定的格式字符串；把字符串解析成指定的格式日期

2.

定义日期工具类

定义一个方法dateToString

异常

public class StudentDemo{
    public static void main(String[] args){
      method();
    }
    public static void method(){
        int[] arr={1,2,3};
        System.out.println(arr[3]);
    }
}

输出为

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3 at com.itheima_02.StudentDemo.method(StudentDemo.java:9) at com.itheima_02.StudentDemo.main(StudentDemo.java:5)

数组越界异常

ArrayIndexOutOfBoundsException在java.lang包下面

java.lang.ArrayIndexOutOfBoundsException间接继承自java.lang.Throwable

2.

Throwable是java中所有错误和异常的超类

两个子类error和异常通常用于表示出现的异常情况

3.

Error表示严重的问题，合理的应用程序不应该试图捕获

4.

异常及其子类是Throwable的形式，表示合理应用程序可能想要捕获的条件

异常类和不是RuntimeException的子类的任何子类都是检查异常

JVM的默认处理方案

1.将异常的名称原因位置输出在控制台

2.然后结束程序

异常处理之try...catch

1.格式

try{

可能出现异常的代码

} catch(异常类名 变量名){ 异常代码的处理代码

}

出现异常，会自动生成一个异常对象，该异常对象会被提交给Java运行时程序

当Java运行时程序接收到异常对象时，会到catch中去找匹配的异常类。找到后进行异常的处理

public class StudentDemo{
    public static void main(String[] args){
        System.out.println("开始");
        method();
        System.out.println("结束");
    }
    public static void method(){
        try {
            int[] arr = {1, 2, 3};
            System.out.println(arr[3]);  //异常之后相当于new ArrayIndexOutOfBoundsExceptio
        }catch(ArrayIndexOutOfBoundsException e){
            System.out.println("您访问的数组越界");
        }
    }
}

public class StudentDemo{
    public static void main(String[] args){
        System.out.println("开始");
        method();
        System.out.println("结束");
    }
    public static void method(){
        try {
            int[] arr = {1, 2, 3};
            System.out.println(arr[3]);
        }catch(ArrayIndexOutOfBoundsException e){
            e.printStackTrace();
        }
    }
}

Throwable

1.

public String getMessage()

返回Throwable的详细消息字符串

public String toString()

返回此可抛出的简短描述

public void printStackTrace()

把异常错误信息输出在控制台

2.代码实现

public class StudentDemo{
    public static void main(String[] args){
        System.out.println("开始");
        method();
        System.out.println("结束");
    }
    public static void method(){
        try {
            int[] arr = {1, 2, 3};
            System.out.println(arr[3]);
        }catch(ArrayIndexOutOfBoundsException e){
            System.out.println(e.getMessage());
        }
    }
}
/*输出：
开始
Index 3 out of bounds for length 3
结束
*/

编译时异常和运行时异常的区别

1.

编译性异常称为受检异常

运行时异常称为非首检异常

2.

java.lang.RuntimeException是运行时异常的父类

java.lang.Exception是编译时异常的父类

异常处理之throws

1.格式

throws 异常

2.

public class StudentDemo{
    public static void main(String[] args){
        System.out.println("开始");
        method();
        System.out.println("结束");
    }
    public static void method()throws ArrayIndexOutOfBoundsException{
            int[] arr = {1, 2, 3};
            System.out.println(arr[3]);
    }
}

3.

throws并不是真正处理异常，而是把异常抛出

如果采用throws这种方案，将来谁调用谁处理

自定义异常

1.

自定义异常需要继承自Exception或者RuntimeException

2.

public class ScoreException extends Exception{
    public ScoreException(){}
    public ScoreException(String message){
        super(message);
    }
}
//自定义一个异常

public Throwable(String message) {
    fillInStackTrace();
    detailMessage = message;
}

package com.itheima_02;
​
import java.util.Scanner;
​
public class StudentDemo{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入分数");
        int score=sc.nextInt();
        Teacher t=new Teacher();
        try {
            t.checkScore(score);
        } catch (ScoreException e) {
            e.printStackTrace();
        }
    }
}

package com.itheima_02;
​
public class Teacher {
    public void checkScore(int score) throws ScoreException {
        if (score < 0 || score > 100) {
            throw new ScoreException("你给的分数有误，分数应该在0-100之间");
        }else{
            System.out.println("分数正常");
        }
    }
}
//制作一个类，当接收数据符合异常范围时，抛出异常

3、throws和throw的区别

throws

用在方法声明的后面，跟的是异常类名

表示抛出异常，由该方法的调用者来处理

表示出现异常的一种可能性，并不一定会经常出现这些异常

throw

用在方法体内，跟的是异常对象名

表示抛出异常，由方法体内的语句处理

执行throw一定是抛出了某种异常

集合体系结构

1.

集合类的特点： 提供一种存储空间可变的存储类型，存储的数据容量可以随时发生改变

2.

Collection 单列集合

Map 双列集合

list 存储元素可重复

Set 不可重复

3.

List下有 ArrayList LinkedList

Set 下面有 HashSet TreeSet

Map下面有HashMap

Collection的集合概述和使用

1.

在java.util包下面

2.

Collection是集合层次中的根界面

是单列集合的顶层接口，表示一组对象，这些对象也称为Collection的元素

JDk不提供此接口的任何直接实现，它提供更具体的字接口的实现

3.

package Collection;
​
import java.util.ArrayList;
import java.util.Collection;
​
public class CollectionDemo01 {
    public static void main(String[] args){
        //创建集合对象
        Collection<String> c=new ArrayList<String>();
        //添加数据
        c.add("hello");
        c.add("world");
        c.add("java");
        //输出对象
        System.out.println(c);
    }
}

Collection集合的常用方法

1.

boolen add(E e)

//调用add永远返回true

添加元素

boolen remove(Object o)

从集合中溢出指定的元素

void clear()

清空元素

boolen contains(Object o)

判断集合中是否存在指定的元素

boolen isEmpty()

判端集合是否为空

int size()

集合的长度，集合汇总元素的长度

2.

View

ToolWindows

structure

3.

package Collection;
​
import java.util.ArrayList;
import java.util.Collection;
​
public class CollectionDemo2 {
    public static void main(String[] args){
        Collection<String> c=new ArrayList<String>();
        System.out.println(c.add("hello"));
        System.out.println(c.add("world"));
        System.out.println(c.add("java"));
        System.out.println(c.remove("world"));
        System.out.println(c.remove("javaee"));
        System.out.println(c);
        c.clear();
        System.out.println(c);
    }
}
输出为：
true true true true false [hello, java] []
package Collection;
​
import java.util.ArrayList;
import java.util.Collection;
​
public class CollectionDemo2 {
    public static void main(String[] args){
        Collection<String> c=new ArrayList<String>();
        c.add("hello");
        c.add("world");
        c.add("java");
        System.out.println(c.contains("world"));
        System.out.println(c.isEmpty());
        System.out.println(c.size());
    }
}

输出

true

false

3

Collection集合的遍历

1.

Iterator

迭代器，集合专用遍历方式

迭代器是通过集合的方法得到的，所以我们说它是依赖于集合而存在的

2.

Iterator<E> iterater();

返回集合中元素的迭代器

3.

Iterator中的常用方法

E next();

返回集合中的下一个元素

boolen hasNext();

如果迭代中具有更多的元素，则返回true

4.itrater是一个接口

5.

package Collection;
​
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
​
public class IteratorDemo {
    public static void main(String[] args){
        Collection<String> c=new ArrayList<String>();
        c.add("hello");
        c.add("world");
        c.add("java");
        Iterator<String> it=c.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
        }
}

创建集合对象

创建元素

添加元素到集合

遍历集合（通过集合对象获取迭代器对象，通过迭代器对象的hasNext方法判断是否还有元素，通过next方法获取下一个元素）

Collection集合存储学生对象并遍历

定义学生类

创建Collection

创建学生对象

把学生添加到集合

遍历集合(迭代器方法)

List集合的概述和特点

1.在java.util

是一个接口，继承字自collection

2.有序集合

3.允许重复的元素

4.存储和取出的元素一致

5.

package List;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ListDemo1 {
    public static void main(String[] args) {
        //创建集合对象
        List<String> list=new ArrayList<String>();
        list.add("hello");
        list.add("world");
        list.add("java");
        System.out.println(list);
        //迭代器
        Iterator<String> it= list.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }

List集合特有方法

list(int index,String element);

remove(int index); //删除元素并返回元素

set(int index,E element);

get(int index);

package List;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ListDemo1 {
    public static void main(String[] args) {
        //创建集合对象
        List<String> list=new ArrayList<String>();
        list.add("hello");
        list.add("world");
        list.add("java");
        list.add(1,"javaee");
        //迭代器
        Iterator<String> it= list.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}
输出为:
[hello, javaee, world, java] hello javaee world java
package List;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ListDemo1 {
    public static void main(String[] args) {
        //创建集合对象
        List<String> list=new ArrayList<String>();
        list.add("hello");
        list.add("world");
        list.add("java");
        list.remove(1);
        //迭代器
        Iterator<String> it= list.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
​
    }

输出为

hello java

List遍历集合

package List;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ListDemo1 {
    public static void main(String[] args) {
        //创建集合对象
        List<String> list=new ArrayList<String>();
        list.add("hello");
        list.add("world");
        list.add("java");
        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }
​
    }
}

并发修改异常

错误程序

package List;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ListDemo1 {
    public static void main(String[] args) {
        //创建集合对象
        List<String> list = new ArrayList<String>();
        list.add("hello");
        list.add("world");
        list.add("java");
        //迭代器
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            String s = it.next();
            if (s.equals("world")) {
                list.add("javaee");
            }
        }
        System.out.println(list);
    }
}

报错

Exception in thread "main" java.util.ConcurrentModificationException at java.base/java.util.ArrayList$Itr.checkForComodification(ArrayList.java:1013) at java.base/java.util.ArrayList$Itr.next(ArrayList.java:967) at List.ListDemo1.main(ListDemo1.java:15)

是运行时异常

增强for循环

为了简化遍历

for(元素数据类型 变量名：数组或者Collection集合){

//在此处使用变量即可，该变量就是元素

}
package List;
import javax.swing.*;
import java.awt.*;
​
public class ListDemo1 {
    private static Object statements;
​
    public static void main(String[] args) {
        int[] arr={1,2,3};
        for(int i: arr) {
            System.out.println(i);
        }
    }
}

List集合存储学生对象用三种方法遍历

迭代

for

增强for

增强for方法

for(Student s:list){

System.out,println(s.getname()+","+s.getAge());

}

List数据结构

数据结构：数据结构是计算机存储组织数据的方式，是指相互之间存在一种或多种特定关系的数据元素的集合

栈

一端开口，栈顶，一端封闭，栈底

数据进入栈称为压栈或者进栈

数据离开栈的过程叫做弹/出栈

进栈和出栈的顺序相反

栈是先进后出的模型

队列

一段开口：后端

一段开头：前端

从后端进入称为进队列

从前端离开称为出队列

是一种先进先出的模型

数组

查询数据通过索引定位。查询任意数据耗时相同，查询速度快

删除时，将原始数据删除，每个坐标前移，删除效率低

添加数据时，添加位置后的每个数据后移，再添加元素，添加效率极低

是一种查询快，增删慢的模型

链表

结点

节点的存储位置称为地址，存储具体的数据，下一个结点的地址

头结点

结点指向空地址（表示结束）

链表是一种增删快的模型（对比数组）

查询数据D是否存在，必须从头开始查询

哈希值

1.哈希值是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值

2.Object对象中有一个方法可以获取对象的哈希值

3.hascode返回对象的哈希码值

4.

public int hashCode();

5.

默认情况下，不同对象的哈希值不同

通过方法重写，可以实现不停对象的哈希值是相同的

HashSet集合概述和特点

1.底层数据结构是哈希表

2.继承自Abstract

3.实现了Set接口，由哈希表支持，对集合的迭代顺序不做任何保证

4.Hashset存储字符串

//创建集合对象

HashSet<String> hs=new HashSet<String>();

import java.util.HashSet;
​
public class Demo {
    public static void main(String[] args){
        HashSet<String> hs=new HashSet<String>();
        hs.add("hello");
        hs.add("world");
        hs.add("java");
        //遍历
        for(String s:hs){
            System.out.println(s);
        }
    }
}
输出： world java hello
import java.util.HashSet;
​
public class Demo {
    public static void main(String[] args){
        HashSet<String> hs=new HashSet<String>();
        hs.add("hello");
        hs.add("world");
        hs.add("java");
        hs.add("world");
        //遍历
        for(String s:hs){
            System.out.println(s);
        }
    }
}

输出：

world java hello

哈希表不包含重复元素

常见数据结构之哈希表

1.JDK8之前，采用数组加链表实现的，可以说是一个元素为链表的数组

2.JDK8以后，在长度比较长的时候，底层实现了优化

3.哈希值除以16相同存到一个地方形成链表

哈希值完全相同比较内容，内容相同不存储

LinkedHashSet集合的概述和特点

由哈希表和链表实现的Set接口，具有可预测的迭代次序

由链表确保元素有序，也就是说元素的存储和取出顺序是一致的

由哈希表保证元素唯一，也就是说没有重复的元素

import java.util.HashSet;
import java.util.LinkedHashSet;
​
public class Demo {
    public static void main(String[] args) {
        //创建集合对象
        LinkedHashSet<String> LinkedHashSet=new LinkedHashSet<String>();
        LinkedHashSet.add("hello");
        LinkedHashSet.add("world");
        LinkedHashSet.add("java");
        for(String s:LinkedHashSet){
            System.out.println(s);
        }
    }
​
}

输出

hello world java

TreeSet集合的概述和特点

1.

继承自AbstractSet

TreeSet间接实现了Set接口

NavigableSet实现基于TreeMap，的元件使用其有序natural ordering，或由Comparator集合创建时提供，这取决于使用的构造方法

2.

无参根据自然排序进行排序

带参构造传递一个比较器接口，根据指定的比较器进行排序

3.

import java.net.InetAddress;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.TreeSet;
​
public class Demo {
    public static void main(String[] args) {
        TreeSet<Integer> ts=new TreeSet<Integer>();
        //添加元素
        ts.add(10);
        ts.add(40);
        ts.add(30);
        ts.add(20);
        for(Integer i:ts){
            System.out.println(i);
        }
    }
​
}

输出： 10

20

30

40

自然排序Comparable的使用

1.创建学生对象并遍历，创建TreeSet集合使用无参构造方法

2.

package Send;
​
import org.w3c.dom.ls.LSOutput;
​
public class Student {
        private String name;
        private int age;
​
        public Student(String name, int age) {
            this.name = name;
            this.age = age;
         }
​
       public Student() {
​
        }
        public String getname(){
            return name;
        }
        public int getAge(){
            return age;
        }
​
}
import Send.Student;
​
import java.net.InetAddress;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.TreeSet;
​
public class Demo {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Student> ts=new TreeSet<Student>();
        //添加元素
        Student s1=new Student("李万洲",18);
        Student s2=new Student("风清扬",62);
        Student s3=new Student("李华",30);
        Student s4=new Student("Ben",12);
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        //遍历集合
        for(Student s:ts){
            System.out.println(s.getname()+","+s.getAge());
        }
    }
​
}

报错：

Exception in thread "main" java.lang.ClassCastException: class Send.Student cannot be cast to class java.lang.Comparable (Send.Student is in unnamed module of loader 'app'; java.lang.Comparable is in module java.base of loader 'bootstrap')

at java.base/java.util.TreeMap.compare(TreeMap.java:1569)  at java.base/java.util.TreeMap.addEntryToEmptyMap(TreeMap.java:776)  at java.base/java.util.TreeMap.put(TreeMap.java:785)  at java.base/java.util.TreeMap.put(TreeMap.java:534)  at java.base/java.util.TreeSet.add(TreeSet.java:255)  at Demo.main(Demo.java:17)

package Send;
​
import org.w3c.dom.ls.LSOutput;
​
public class Student implements Comparable<Student>{
        private String name;
        private int age;
​
        public Student(String name, int age) {
            this.name = name;
            this.age = age;
         }
​
       public Student() {
​
        }
        public String getname(){
            return name;
        }
        public int getAge(){
            return age;
        }
​
    @Override
    public int compareTo(Student o) {
        return 0;
    }
}

线程同步

判断多线程程序会有数据安全问题的标准

是否是多线程环境

是否有共享数据

是否有多条语句操作共享数据

解决安全问题

把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可

synchronized(任意对象){

}

泛型的概述和好处

1.

是JDK5引入的特性，它提供了编译时类型安全检查机制，该机制允许在编译时检测到非法的类型，他的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数

一提到参数，就是将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型

这中参数类型可以用在类，方法和接口中，分别被称为泛型类，泛型方法，泛型接口

2.

泛型定义格式

<类型> 指定一种类型的格式，类型可以看做是形参

<类型1.类型2> 指定多种类型的格式，类型可以看做是形参

将来调用的时候给定给定类型可以看做是实参，实参的形式只能是引用数据类型

3.

好处：

不需要强制转换

将运行时错误提前到了编译期

泛型类

1.

泛型类的定义格式

修饰符 class 类名<T>{}

此处的类可以是任意标识，常见的如T，E，K，V等形式的参数常用于表示泛型

public class Generic<T>{
    private T t;
​
    public T getT() {
        return t;
    }
​
    public void setT(T t) {
        this.t = t;
    }
}

泛型方法

1.方法名相同，参数列表不同，叫方法重载

public class Generic<T>{
    public void show(T t){
        System.out.println(t);
    }
}

2.泛型方法的定义格式

修饰符 <T> 返回值类型 方法名(类型 变量名){ }

public <T> void show()

public class Generic{
    public <T> void show(T t){
        System.out.println(t);
    }
}

泛型接口

格式

修饰符 interface 接口名<类型>{}

public interface Generic<T>{}

类型通配符

1.

为了表示各种泛型的父类，可以使用类型通配符

类型通配符 <?>

List 表示元素类型为未知的List，它的元素可以匹配任何类型

这种带通配符的List仅表示它是各种类型的父类，并不能把元素添加到其中2.

2.如果不希望List<?>是任何泛型list的父类，只希望它表示某一类泛型List的父类，可以使用类型通配符的上限

<?:extends 类型>

也可以指定下限

<?:super 类型>