javase笔记

IDEA创建Java项目的代码结构... 6

字面量... 7

进制... 7

数据类型... 7

标识符... 8

方法... 9

类型转换... 9

表达式的自动类型提升... 10

输入输出... 10

基本运算符... 10

分支结构... 11

循环结构... 12

实例... 13

数组... 13

对象... 14

构造器... 15

this关键字... 15

封装... 15

Javabean(实体类)... 16

static. 16

继承... 18

多态... 20

final 21

单例类(单例设计模式)... 22

枚举类... 22

抽象类、模板方法设计模式... 23

接口... 24

抽象类和接口的区别... 26

代码块... 27

内部类... 27

函数式编程... 29

Lambda. 29

方法引用... 30

常用API 31

String. 31

ArrayList 32

GUI 33

事件处理... 34

异常... 34

异常的基本处理... 35

自定义异常... 36

异常的处理方案... 37

泛型... 38

泛型类... 38

泛型接口... 38

泛型方法、通配符、上下限... 39

泛型支持的类型... 39

集合框架... 41

Collection集合... 41

List集合... 44

List集合的特有方法:... 44

ArrayList的底层原理... 44

LinkedList的底层原理... 45

Set集合... 46

特点... 46

HashSet集合的底层原理... 46

HashSet集合去重复的机制... 47

LinkedHashSet集合的底层原理... 47

TreeSet集合... 48

Map. 48

Map的常用方法... 49

Map的遍历方式... 50

Map集合的实现类... 50

Stream流... 50

获取Stream流... 51

Stream流提供的常用方法... 51

终结方法、收集Stream流... 52

方法中可变参数... 53

Collections工具类... 54

File. 54

方法递归... 56

字符集... 57

字符集的编码解码操作... 57

IO流... 58

FileInputSteam(文件字节输入流) 58

FileOutputStream(文件字节输出流)... 59

资源释放问题... 60

FileReader文件字符输入流... 61

FileWriter文件字符输出流... 61

缓冲字节流... 62

BufferedInputStream缓冲字节输入流... 63

BufferedOutputStream缓冲字节输出流... 63

BufferedReader缓冲字符输入流... 63

BufferedWriter缓冲字符输出流... 63

性能分析... 64

其他流... 64

字符输入转换流(InputStreamReader) 64

打印流... 64

PrintStream(继承字节输出流) 65

PrintWriter(继承字符输出流) 65

特殊数据流... 65

DataOutputStream(数据输出流) 65

IO框架... 66

多线程... 67

创建线程... 67

线程的常用方法... 69

线程安全... 70

线程同步... 70

线程池... 72

创建线程池... 72

并发、并行... 75

Java网络编程... 75

基本的通信架构... 75

网络编程三要素... 75

IP. 76

端口... 77

协议... 77

UDP通信... 78

TCP通信... 79

单元测试... 80

Junit单元测试框架... 80

反射(Reflection)... 81

作用、应用场景... 84

注解... 84

元注解... 85

注解的解析... 86

作用、应用场景... 87

动态代理... 87

Java跨平台的原理:编译型的语言会因为编写软件以及运行软件的电脑硬件不同或操作系统不同,从而不能跨平台开发,而Java是混合型语言,融合了编译型和解释型语言的特点。

Java 不是直接运行在系统中的,而是运行在虚拟机中的,得益于虚拟机Java可以跨平台。

IDEA创建Java项目的代码结构

Project   工程

Module  模块

Package  包

Class     类

字面量

字符串类型:用双引号括起来的内容

字符类型:用单引号括起来的,内容只能有一个

null值不能直接打印,如果要打印只能用字符串的形式进行打印

\t 制表符:在打印的时候,把前面的字符串的长度补齐到8,或者8的整数倍。最少补1个空格,最多补8个空格

进制

二进制必须以0B开头

八进制必须以0开头

十六进制必须以0X开头

数据类型

数据类型                                内存占用(字节数)

整型

byte                                             1

short                                            2

int                                               4

long                                             8

浮点型

float                                             4

double                                         8

字符型

char                                             2

布尔型

boolean                                       1

数据范围的计算方法:2的数据类型内存占用乘以8的次方。

根据具体需求,选择合适的数据类型,达到节省内存的目的(实际开发中不用),通常整型使用int,浮点型 使用double。

随便写一个整数字面量默认是int类型;随便写一个浮点数字面量默认是double类型,如果想要把这个字面量定义为其他类型,需要在该字面量后面加上类型的首字母

标识符

一般有数字、字母、下划线、$组成。不能以数字开头,

不能是关键字,不能包含一些特殊字符。

变量名:建议首字母小写,满足“驼峰模式”,第二个单词首字母大写。

类名:建议首字母大写,满足“驼峰模式”,每个单词首字母大写。

方法

Java开发的软件,功能的最小单位是方法。

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

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

     return 返回值;

}

当不需要接收处理数据时不用写形参列表。

将入口方法(main)放在类的顶部。

方法可以重载,一个类中,出现多个方法的名称相同,但是它们的形参列表不同(类型不同,个数不同,顺序不同),称这些方法为方法重载。

无返回值的方法中可以直接通过单独的return;立即结束当前方法的执行。

类型转换

自动类型转换:类型范围小的变量,可以直接赋值给类型范围大的变量。

byte→short/char→int→long→float→double

强制类型转换:类型范围大的变量,不可以直接赋值给类型范围小的变量,会报错,需要强制转换类型。

强制类型转换格式:类型 变量1 = (类型)变量2

强制类型转换可能出现数据溢出

表达式的自动类型提升

表达式的最终结果类型由表达式中的最高类型决定。

在表达式中,byte、short、char是直接转换成int类型参与运算的。

byte、short、char→int→long→float→double

输入输出

输入通过Java提供的Scanner程序来实现

API(Application Programming Interface:应用程序编程接口)

导包语句应该放在程序的开头

基本运算符

+符号与字符串运算的时候是用作连接符的,其结果依然是一个字符串。

++、--如果在变量前后单独使用是没有区别的

++、--如果不是单独使用(如在表达式中、或同时有其他操作),放在变量前后存在明显区别

在变量的前面,先对变量+1、-1,再拿变量的值运算。

在变量的后面,先拿变量的值运算,再对变量的值+1、-1。

扩展赋值运算符自带强制类型转换。

三元运算符 :条件表达式?值1:值2

逻辑运算符

&逻辑与:需要所有条件都满足,结果才是true

|逻辑或:多个条件中只要有一个是true,结果就是true。

!逻辑非:取反,!true=false,!false=true。

^逻辑异或:前后条件的结果相同,就直接返回false,前后的条件结果不同,才返回true。

&&短路与:判断结果与&一样,过程不同:左边为false,右边则不执行。

||短路或:判断结果与|一样,过程不同:左边为true,右边则不执行。

实际开发中常用的是:&&、||、!

分支结构

if在功能上远远强大于switch。

当条件是区间的时候,建议使用if分支结构实现。

当条件是与一个一个值比较的时候,建议使用switch更合适(格式良好,性能较好,代码优雅)。

switch分支结构注意事项:1.表达式类型只能是byte、short、int、char、枚举、string,不支持double、float、long。2.case给出的值不允许重复,且只能是字面量,不能是变量。3.正常使用 switch的时候,不要忘记写break,否则会出现击穿现象。

击穿现象的应用:相同程序的case块,可以通过穿透性进行合并,从而减少重复代码的书写。

循环结构

什么时候使用while,什么时候使用for?

使用规范:知道循环几次使用for,不知道循环几次建议使用while。

do-while循环特点:先执行后判断(即使判断结果为false也会执行一次)。

for循环中,控制循环的变量只在循环中使用。while循环中,控制循环的变量在循环后还可以继续使用。

break:跳出并结束当前所在循环的执行,只能用于结束所在循坏,或者结束所在switch分支的执行。

continue:用于跳出当前循环的当次执行,直接进入循环的下一次执行,只能在循环中使用。

实例

  1. 计算器:根据输入的数字及运算符进行对应的运算。
  2. 猜数字:在1-100区间内生成随机数,用户进行猜数字,直到用户猜出数字,程序才能终止。
  3. 验证码:随机生成一个指定位数的验证码,每位只能是大写字母、小写字母、数字。
  4. 找素数:求101-200之间的素数。

使用Random生成随机数步骤:1.导包:import java.util.Random;2.Random num =  new Random();3. int s = num.nextint(10);

如何生成65-91之间的随机数

91-65=26   (0-26)+65

int  s = num.nextint(27)+65;

数组

数组是一个数据容器,可用来存储一批同类型的数据。

静态初始化数组

格式:数据类型 [ ] 数组名 = { 元素一 ,元素二 ,元素三};

完整格式:数据类型 [ ] 数组名 =  new 数据类型[ ] { 元素一 ,元素二 ,};

动态初始化数组,只确定数组的类型和存储数据的容量,不事先存入具体的数据。

格式:数据类型 [ ] 数组名 = new 数据类型[长度];

动态初始化数组boolean默认为false。

数组的访问:数组名[索引]

二维数组

静态初始化格式:数据类型[ ][ ] 数组名 = new 数据类型[ ][ ]{ yu,an,su,a };

动态初始化格式:数据类型[ ][ ] 数组名 = new 数据类型[长度1][长度2];

访问:数组名[行索引]

访问2:数组名[行索引][列索引]

长度访问:数组名.length

对象

对象:对象是一种特殊的数据结构,可以用来记住一个事物的数据,从而代表该事物。

对象的使用步骤:

  1. 先设计对象的模板,也就是对象的设计图:类。
  2. 通过new关键字,每new一次类就得到一个新的对象。

创建对象的格式:类名 对象名 = new 类名();

对象是存放在堆内存中。

构造器

构造器:是一种特殊方法,不能写返回值类型,名称必须是类名。包含无参数构造器和有参数构造器两种类型。

特点:创建对象时,对象回去调用构造器。

应用场景:1.创建对象时,同时完成对对象成员变量(属性)的赋值。

注意事项:1.类默认就自带了一个无参构造器。2.如果为类定义了有参数构造器,类默认的无参数构造器就没有了,此时如果还想用无参数构造器,就必须自己手写一个无参数构造器出来。

this关键字

this就是一个变量,可以用在方法中,来拿到当前对象。

方法调用哪一个对象,this就指向该对象

应用场景:1.解决变量名称冲突的问题。

封装

封装:把数据和对数据的处理放到同一个类中。

设计要求:合理隐藏、合理暴露。

如何隐藏:使用private关键字修饰成员变量,就只能在本类中被直接访问,其他任何地方不能直接访问。

如何暴露:使用public修饰的get和set方法合理暴露,成员变量的取值和赋值。

Javabean(实体类)

实体类 :是一种特殊类,类中要满足如下要求:1.类中的成员变量全部私有,并提供public修饰的getter/setter方法。2.类中需要提供一个无参数构造器,有参数构造器可写可不写。

基本作用:创建它的对象,存取数据(封装数据)。

应用场景:实体类的对象只负责数据存取,而对数据的业务处理交给其他类的对象来执行,以实现数据和数据业务处理相分离。

static

static叫静态,可以修饰成员变量、成员方法。

成员变量按照有无static修饰分为两种:1.静态变量(类变量),有static修饰,属于类,在计算机中只有一份,会被类的全部对象共享。2.实例变量(对象的变量),无static修饰,属于每个对象的。

对静态变量的访问:类名.静态变量

对实例变量的访问:对象.实例变量

成员方法按照有无static修饰分为两种:1.静态方法,有static修饰的成员方法,属于类。2.实例方法,无static修饰的成员方法,属于对象。

对静态方法的访问:类名.静态方法

对实例方法的访问:对象.实例方法

规范:如果这个方法只是为了做一个功能且不需要直接访问对象的数据,这个方法直接定义成静态方法。如果这个方法是对象的行为,需要访问对象的数据,这个方法必须定义成实例方法。

静态方法常见应用场景 :做工具类

使用静态方法设计工具类好处:提高了代码复用,调用方便,提高了开发效率。

工具类没有创建对象的需求,建议将工具类的构造器进行私有。

注意事项:1.静态方法中可以直接访问静态成员,不可以直接访问实例成员。2.实例方法中既可以直接访问静态成员,也可以直接访问实例成员。3.实例方法中可以出现this关键字,静态方法中不可以出现this关键字。

继承

作用:提高代码的重用性,减少一些重复代码的书写。

Java中提供一个extends关键字,用这个关键字,可以让一个类和另一个类建立起父子关系。

子类能继承父类的非私有成员(成员变量、成员方法)。

提高代码的重用性,减少一些重复代码的书写。

子类的对象是由子类、父类共同完成的。

权限修饰符:用来限制类中的成员(成员变量、成员方法、构造器)能够被访问的范围。

1.private      只能本类

2.缺省        本类、同一个包中的类

3.protected      本类、同一个包中的类、子孙类中

4.public       任意位置

继承的特点:1.单继承:Java是单继承模式:一个类只能继承一个直接父类。2.多层继承:Java不支持多继承,但支持多层继承。3.祖宗类:Java中所有类都是Object类的子类。4.就近原则:优先访问自己类中,自己类中没有的才会访问父类。

Java中所有类,要么直接继承Object,要么默认继承了Object,要么间接继承了Object。因此Object是所有类的祖宗类。

在子类方法中访问其他成员(成员变量、成员方法),是按照就近原则的。先子类局部范围找,然后子类成员范围找,然后父类成员范围找,如果父类范围还没有找到就报错。

如果子类中,出现了重名的成员,会优先使用子类的,如果此时一定要在子类中使用父类的怎么办?

可以通过super关键字,指定访问父类的成员。super.父类成员变量/父类成员方法

方法重写(override):当子类觉得父类中的某个方法不好用,或者无法满足自己的需求时,子类可以重写一个方法名称、参数列表一样的方法,去覆盖父类的这个方法。在实际开发中在方法重写的上一行写上@Overide。

方法重写的注意事项:1.子类重写父类方法时,访问权限必须大于或者等于父类该方法的权限(public>protected>缺省>private)。2.重写的方法返回值类型,必须与被重写方法的返回值类型一样,或者范围更小。3.私有方法、静态方法不能被重写,不然会报错。

方法重写的常见应用场景:1.子类重写Object类的toString()方法,以便返回对象的内容。

子类构造器的特点:子类的全部构造器,都会先调用父类的构造器,在执行自己。

子类构造器是如何实现调用父类构造器的:1.默认情况下,子类全部构造器的第一行代码都是super()写不写都有,它会调用父类的无参数构造器。2.如果父类没有无参构造器(无参构造器被私有),则我们必须在子类构造器的第一行手写super(…),指定去调用父类的有参数构造器。

this(…)调用兄弟构造器:任意类的构造器中,是可以通过this(…)去调用该类的其他的构造器的。

注意事项:super(…),this(…)必须写在构造器的第一行,而且两者不能同时出现。

多态

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

方法:编译看左边,运行看右边。

成员变量:编译看左边,运行也看左边。

多态的前提:有继承/实现关系;存在父类引用子类对象;存在方法重写。

多态的注意事项:多态是对象、行为的多态,Java的属性 (成员变量)不谈多态。

使用多态的好处:1.在多态形式下,右边对象是解耦合的,更便于拓展和维护。2.定义方法时,使用父类类型的形参,可以接受一切子类对象,扩展性更强、更便利。

多态下不能使用子类的独有功能

多态下的类型转换:1.自动类型转换: 父类 变量名 = new 子类();2.强制类型转换: 子类 变量名 =(子类)父类变量

强制类型转换注意事项:1.存在继承/实现关系就可以在编译阶段进行强制类型转换,编译阶段不会报错。2.运行时,如果发现对象的真实类型与强转后的类型不同,就会报类型转换异常(ClassCastException)的错误出来。

强转前建议使用instanceof关键字,判断当前对象的真实类型,再进行强转

final

final关键字是最终的意思,可以修饰:类、方法、变量。

修饰类:该类被称为最终类,特点是不能再被继承了。

修饰方法:该方法被称为最终方法,特点是不能被重写了。

修饰变量:该变量有且仅能被赋值一次。

final修饰静态变量,这个变量今后被称为常量,常量的名称全部大写,多个单词用下划线连接。

final修饰实例变量(一般没有意义)

注意事项:1.final修饰基本类型的变量,变量存储的数据不能被改变。2.final修饰引用类型的变量,变量存储的地址不能被改变,但该地址所指向的内容是可以改变的。

使用常量记录系统配置信息的优势、执行原理:1.代码可读性更好,可维护性也更好。2.程序编译后,常量会被“宏替换”:出现常量的地方全部会被替换成其记住的字面量,这样可以保证使用常量和直接使用字面量的性能是一样的。

单例类(单例设计模式)

设计模式:一个问题通常有n种解法,其中肯定有一种解法是最优的,这个最优的解法被人总结出来了,称之为设计模式。

单例设计模式作用:确保某个类只能创建一个对象。

饿汉式单例:拿对象时,对象早就创建好了。

懒汉式单例:拿对象时,才开始创建对象。

饿汉式单例实现步骤:1.把类的构造器私有。作用:确保单例类对外不能创建太多对象,单例才有可能性。2.定义一个类变量记住类的一个对象。3.定义一个类方法返回对象。

懒汉式单例实现步骤:1.把类的构造器私有。2.定义一个静态变量用于存储对象。3.提供一个静态方法,保证返回的是同一个对象。

枚举类

写法: 修饰符 enum 枚举类名{

                   名称1,名称2,……;

                   其他成员;

}

特点:1.枚举类的第一行,只能写枚举类的对象名称,且要用逗号隔开。2.这些名称,本质是常量,每个常量都记住了枚举类的一个对象。3.枚举都是最终类,不可以被继承,枚举类都是 继承java.lang.Enum类的。4.枚举类的构造器是私有的(写不写都只能是私有的),因此,枚举类不能对外创建对象。5.编译器为枚举类新增了几个方法。

常见应用场景:1.枚举类很适合做信息分类和标志。

抽象类、模板方法设计模式

Java关键字abstract,可以用它修饰类、成员方法。

abstract修饰类,这个类就是抽象类。

abstract修饰方法,这个方法就是抽象方法。

抽象方法:必须abstract修饰,只有方法签名,不能有方法体

修饰符 abstract class 类名{

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

}

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

注意事项:1.抽象类中不一定要有抽象方法,有抽象方法的必须是抽象类。2.类有的成员:成员变量、方法、构造器,抽象类都可以有。3.一个类继承抽象类,必须重写抽象类的全部抽象方法,否则这个类也必须定义成抽象类。

使用抽象类的好处:1.父类知道每个子类都要做某个行为,但每个子类要做的情况不一样,父类就定义成抽象方法,交给子类去重写实现,我们设计这样的抽象类,就是为了更好的支持多态

模板方法设计模式:提供一个方法作为完成某类功能的模板,模板方法封装了每个实现步骤,但允许子类提供特定步骤的实现。

模板方法设计模式作用:提高代码的复用,并简化子类设计。

模板方法写法:1.定义一个抽象类。2.在里面定义两个方法,一个是模板方法:把共同的实现步骤放进去,建议用final修饰方法;一个是抽象方法:不确定的实现步骤,交给具体的子类来完成。

接口

Java提供了一个关键字interface定义出接口。

在JDK8之前,接口中只能定义常量和抽象方法。

传统接口:public interface 接口名 {

                   //成员变量:(常量)

                   //成员方法:(抽象方法)

}

注意:接口不能创建对象。

接口是用来被类实现(implements)的,实现接口的类称为实现类,一个类可以同时实现多个接口。

实现类实现多个接口,必须重写完全部接口的全部抽象方法,否则这个类必须定义成抽象类。

接口的好处:1.弥补了类单继承的不足,一个类可以同时实现多个接口,使类的角色更多,功能更强大。2.让程序可以面向接口编程,这样程序员就可以灵活方便的切换各种业务实现(更利于程序解耦合)。

从JDK8开始,接口中新增三种方法可以定义:

  1. 默认方法(实例方法):使用default修饰,默认会被加上public修饰。注意:只能用实现类对象调用。
  2. 私有方法:必须用private修饰(JDK 9才开始支持)
  3. 类方法(静态方法):使用static修饰,默认会被加上public修饰。注意:只能用接口名调用

作用:增强了接口的能力,更便于项目的扩展和维护。

接口的注意事项

  1. 接口与接口可以多继承:一个接口可以同时继承多个接口。【重点】
  2. 一个接口可以继承多个接口,如果多个接口中存在方法签名冲突,则此时不支持多继承,也不支持多实现。
  3. 一个类继承了父类,又同时实现了接口,如果父类中和接口中有同名的默认方法,实现类会优先用父类的。
  4. 一个类实现了多个 接口,如果多个接口中存在同名的默认方法,可以不冲突,这个类重写该方法即可。

抽象类和接口的区别

相同点

  1. 都是抽象形式,都可以有抽象方法,都不能创建对象。
  2. 都是派生子类形式,抽象类是被子类继承使用,接口是被实现类实现。
  3. 一个类继承抽象类,或者实现接口,都必须重写它们的抽象方法,否则自己要成为抽象类或者报错!
  4. 都能支持多态,都能够实现解耦合。

不同点

  1. 抽象类中可以定义类的全部普通成员,接口只能定义常量,抽象方法(JDK 8新增的三种方法)。
  2. 抽象类只能被类单继承,接口可以被类多实现。
  3. 一个类继承抽象类就不能再继承其他类,一个类实现了接口(还可以继承其他类或实现其他接口)。
  4. 抽象类体现模板思想:更利于做父类,实现代码的复用性。
  5. 接口更适合做功能的解耦合:解耦合性更强更灵活。

代码块

代码块是类的5大成分之一(成员变量、构造器、方法、代码块、内部类)。

代码块分为两种:静态代码块、实例代码块。

静态代码块

格式:static{ }

特点:类加载时自动执行,由于类只会加载一次,所以静态代码块也只会执行一次。优先执行一次。

作用:完成类的初始化,例如:对静态变量的初始化赋值。

实例代码块

格式:{ }

特点:每次创建对象时,执行实例代码块,并在构造器前执行。

作用:和构造器一样,都是用来完成对象的初始化的,例如:对实例变量进行初始化赋值。优先执行一次。

内部类

如果一个类定义在另一个类的内部,这个类就是内部类。

场景:当一个类的内部,包含了一个完整的事物,且这个类没有必要单独设计的时候,就可以把这个事物设计成内部类。

内部类可以分为:成员内部类、静态内部类、局部内部类、匿名内部类

成员内部类:就是类中的一个普通成员,类似普通的成员变量、成员方法,属于外部类的对象持有。

成员内部类创建对象的格式:外部类名.内部类名 对象名 = new 外部类名( ).new 内部类名( );

成员内部类访问外部类成员的特点:1.成员内部类中可以直接访问外部类的静态成员,也可以直接访问外部类的实例成员。2.成员内部类的实例方法中,可以直接拿到当前寄生的外部对象:外部类名.this;

静态内部类:有static修饰的内部类,属于外部类自己持有。

静态内部类创建对象的格式:外部类名.内部类名 对象名 = new 外部类名.内部类名( );

静态内部类的特点:可以直接访问外部类的静态成员,不能直接访问外部类的实例成员。

局部内部类(了解):局部内部类是定义在方法中、代码块中、构造器等执行体中。

匿名内部类(重点):是一种特殊的局部内部类;所谓匿名:指的是程序员不需要为这个类声明名字,默认有个隐藏的名字。

格式

new 类或接口(参数值(一般不用写)){

         类体(一般是方法重写);

};

特点:匿名内部类本质就是一个子类,并会立即创建出一个子类对象。

作用:用于更方便的创建一个子类对象。

匿名内部类在开发中的常见形式:通常作为一个对象参数传输给方法。

匿名内部类在开发中的真实使用场景:1.调用别人的方法实现需求时,这个方法正好可以让我们传输一个匿名内部类对象给其使用。

函数式编程

Lambda

此“函数(Lambda)”类似于数学中的函数,只要输入的数据一致返回的结果也是一致的。

Lambda表达式:JDK 8开始新增的一种语法形式,它表示函数。

作用:使用Lambda函数替代某些匿名内部类对象,从而让代码更简洁,可读性更好。

格式

(被重写方法的形参列表)->{

         被重写方法的方法体代码

}

注意:Lambda并不是可以简化全部的匿名内部类,Lambda只能简化函数式接口的匿名内部类。

函数式接口:有且仅有一个抽象方法的接口。可以用@FunctionalInterface注解

Lambda表达式的省略规则:1.参数类型可以全部省略不写。2.如果只有一个参数,参数类型省略的同时“( )”也可以省略,但多个参数不能省略“( )”。3.如果Lambda表达式只有一行代码,大括号可以不写,同时要省略分号;如果这行代码是return语句,也必须去掉return。

作用:用于进一步简化Lambda表达式的写法。

方法引用

静态方法引用

格式:        类名::静态方法

使用场景:如果某个Lambda表达式里只是调用一个静态方法,并且”->”前后参数的形式一致,就可以使用静态方法引用。

实例方法引用

格式:        对象名::实例方法

使用场景:如果某个Lambda表达式里只是通过对象名称调用一个实例方法,并且“->”前后参数的形式一致,就可以使用实例方法引用。

特定类型方法引用

格式:        特定类的类型名称::方法名称

使用场景:如果某个Lambda表达式里只是调用一个特定类型的实例方法,并且前面参数列表中的第一个参数是作为方法的主调,后面的所有参数都是作为该实例方法的入参的,则此时就可以使用特定类型的方法引用。

构造器引用

格式:       类名::new

使用场景:如果某个Lambda表达式里只是在创建对象,并且“->”前后参数情况一致,就可以使用构造器引用。

常用API

String

String代表字符串,它的对象可以封装字符串数据,并提供了很多方法完成对字符串的处理。

步骤:1.创建字符串对象,封装字符串数据。2.调用String提供的操作字符串数据的方法。

String创建字符串对象的方式:

方法一:Java程序中的所有字符串文字都可以作为此类的对象。

方法二:调用String类的构造器初始化字符串对象。

public String( ) 创建一个空白字符串对象,不含有任何内容。

public String(String original) 根据传入的字符串内容,来创建字符串对象。

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

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

String创建对象的区别:1.只要是以”…”方式写出的字符串对象,会存储到字符串常量池,且相同内容的字符串只存储一份。2.通过new方式创建字符串对象,每new一次都会产生一个新的对象放在堆内存中。

字符串对象的内容比较,千万不要用==,==默认比较地址,字符串对象的内容一样时地址不一定一样。判断字符串内容,建议使用String提供的equals方法,只关心内容一样,就返回true,不关心地址。

ArrayList

集合是一种容器,用来装数据的,类似于数组。

集合相较于数组的优点:数组定义完成并启动后,长度就固定了;集合大小可变,功能丰富,开发中用的更多。

步骤:1.创建ArrayList对象,代表一个集合容器。2.调用ArrayList提供的方法,对容器中的数据进行增删改查操作。

ArrayList是集合中最常用的一种,ArrayList是泛型类,可以约束存储的数据类型。

使用步骤:1.创建对象:调用无参构造器public ArrayList( )初始化对象。2.调用增删改查数据的方法。

GUI

GUI,全称Graphical User Interface,是指图形用户界面。

Java的GUI编程包:

AWT(Abstract Window Toolkit):提供了一组原生的GUI组件,依赖于操作系统的本地窗口系统。

Swing:基于AWT,提供了更丰富的GUI组件,轻量级组件,不依赖于本地窗口系统。

常用的Swing组件

JFrame:窗口

JPanel:用于组织其他组件的容器

JButton:按钮组件

JTextField:输入框

JTable:表格

布局管理器它们可以决定组件在容器中的布局方式,避免了手动设置每个组件的位置和大小,从而简化了GUI设计过程。

常见的布局管理器

  1. FlowLayOut  
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值