Java学习笔记

变量的注意事项：

1. 名字不能重复
2. 变量未赋值不能使用
3. long类型的变量定义的时候，为了防止整数过大，后面要加L
4. float类型的变量定义的时候，为了防止类型不兼容，后面要加F

标识符概述：

标识符就是给类、方法、变量等起名字的符号

命名规则：

1. 由数字、字母、下划线和美元符组成
2. 不能以数字开头
3. 不能是关键字
4. 区分大小写

约定：

小驼峰命名法（方法、变量）

1. 标识符是一个单词的时候，首字母小写
2. 标识符由多个单词组成的时候，第一个单词首字母小写，其他单词首字母大写

大驼峰命名法（类）

1. 标识符是一个单词的时候，首字母大写
2. 标识符由多个单词组成的时候，每个单词的首字母大写

类型转换：

自动类型转换：把一个表示数据范围小的数值或者变量赋值给另一个表示数据范围大的变量

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

格式：目标数据类型 变量名 = （目标数据类型）值或者变量；

运算符和表达式：

运算符：对常量或者变量进行操作的符号

表达式：用运算符把常量或者变量连接起来符合Java语法的式子就可以称为表达式。不同运算符连接的表达式体现的是不同类型的表达式

当“+”操作中出现字符串时，这个“+”是字符串连接符，而不是算术运算

当“+”操作中，如果出现了字符串，就是连接运算符，否则就是算术运算，当连续进行“+”操作时，从左到右逐个执行

逻辑运算符：

& 逻辑与 a&b，a和b都是true,结果未true,否则为false

| 逻辑或 a|b,a和b都是false，结果为false,否则为true

^ 逻辑异或 a^b，a和b结果不同为true,相同为false

! 逻辑非 !a ,结果和a的结果正好相反

&& 短路与 作用和&相同，但是有短路效果

|| 短路或 作用和|相同，但是有短路效果

数据输入：

Scanner使用基本步骤

1.导包

import java.util.Scanner;

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

2.创建对象

Scanner sc = new Scanner(System.in);

上面这个格式里面，只有sc是变量名，可以变，其他的都不允许变

3.接收数据

int i = sc.nextInt();

上面这个格式里面，只有i是变量名，可以边，其他的都不允许变

流程控制：

1.顺序结构：顺序结构是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数代码都是这样执行的

2.switch语句

表达式：取值为byte、short、int、char，JDK5以后可以是枚举，JDK7以后可是String

case:后面跟的是要和表达式进行比较的值

break：表示中断，结束的意思，用来结束switch语句

default:表示所有情况都不匹配的时候,就执行该处的内容，和if语句的else相似

注意事项：在switch语句中，如果case控制的语句体后面不写break，将出现穿透现象，在不判断下一个case值的情况下，向下运行，知道遇到break，或者整体switch结束

循环语句：

循环结构的组成：

初始化语句：用于表示循环开启时的起始状态，简单说就是循环开始时候什么样

条件判断语句：用于表示循环反复执行的条件，简单说就是判断循环是否能一直执行下去

循环体语句：用于表示循环反复执行的内容，简单说就是循环反复执行的事情

条件控制语句：用于表示循环执行中每次变化的内容，简单说就是控制循环是否能执行下去

数组

数组（array）是一种用于存储多个相同类型数据的存储模型

数组的定义格式：

格式一：数据类型[] 变量名

范例：int[] arr

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

格式二：数据类型 变量名[]

范例：int arr[]

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

数组初始化之动态初始化

动态初始化：初始化时只指定数组长度，由系统为数组分配初始值

格式：数据类型[] 变量名 = new 数据类型[数组长度]

数组初始化之静态初始化

静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度

格式：数据类型[] 变量名 = new 数据类型[] ｛数据1，数据2，数据3，……｝

简化格式：数据类型[] 变量名 = {数据1，数据2，数据3，……}

范例：int[] arr = {1,2,3}；（推荐格式）

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

索引越界：访问了数组中不存在的索引对应的元素，造成索引越界问题

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

（null：空值，引用数据类型的默认值，表示不指向任何有效对象）

数组的常见操作

获取数组元素数量

格式：数组名.length

范例：arr.length

方法

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

注意：

1. 方法必须先创建才可以使用，该过程称为方法定义
2. 方法创建后并不是直接运行的，需要手动使用后才执行，该过程称为方法调用

方法定义格式

public static void 方法名（）｛

//方法体

｝

方法调用格式

格式：方法名();

范例：isEvenNumber();

带参数方法定义

格式：public static void 方法名（数据类型 变量名）｛……｝

注意：

1. 方法定义时，参数中的数据类型与变量名都不能缺少，缺少任意一个程序将报错
2. 方法定义时，多个参数之间使用逗号分隔

带参数方法调用

格式：方法名（变量名/常量值）

注意：

方法调用时，参数的数量与类型必须与方法定义中的设置相匹配，否则程序将报错

形参和实参

形参：方法定义中的参数

实参：方法调用中的参数

带返回值方法定义

格式：public static 数据类型 方法名（参数）｛

return 数据；

｝

注意：方法定义时return后面的返回值与方法定义上的数据类型要匹配，否则程序将报错

带返回值方法调用

格式：数据类型 变量名 = 方法名（参数）；

范例：boolean flag = isEvenNumber(5);

注意：方法的返回值通常会使用变量接收，否者该返回值将无意义

方法注意事项：

1.方法不能嵌套定义

2.void表示无返回值，可以省略return,也可以单独的书写return，后面不加数据

方法的通用格式

格式：public static 返回值类型 方法名（参数）｛

方法体；
return 数据；

｝

public static——修饰符，目前先记住这个格式

返回值类型——方法操作完毕之后返回的数据类型

如果方法操作完毕，没有数据返回，这里写void，而且方法体中一般不写return

方法名——调用方法时使用的标识

参数——由数据类型和变量名组成，多个参数之间用逗号隔开

方法体——完成功能的代码块

return——如果方法操作完毕，有数据返回，用于把数据返回给调用者

定义方法时，要做到两个明确

明确返回值类型：主要是明确方法操作完毕之后是否有数据返回，如果没有，写void，如果有，写对应的数据类型

明确参数：主要是明确参数的类型和数量

调用方法时

void类型的方法，直接调用即可

非void类型的方法，推荐用变量接收调用

方法重载

方法重载的定义

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

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

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

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

方法重载的特点

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

2.重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，换句话说不能通过返回值来判定两个方法是否相互构成重载

方法参数传递

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

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

Debug

概述：

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

Debug操作流程

Debug调试又被称为断点调试，断点其实是一个标记，告诉我们从哪里开始查看

1.如何加断点

设置要设置断点的代码行，在行号的区域后面单击鼠标左键即可

2.如何运行加了断点的程序

在代码区域右键Debug执行

3.看哪里

看Debug窗口

看Console窗口

4.点哪里

点Step lnto(F7)这个箭头，也可以直接按F7

点Stop结束

5.如何删除断点

选择要删除的断点，单击鼠标左键即可

类和对象

什么是对象？

万物皆对象，客观存在的事物皆为对象

什么是类？

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

类的特点：

1.类是对象的数据类型

2.类是具有相同属性和行为的一组对象的集合

什么是对象的属性：

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

什么是对象的行为：

行为：对象能够执行的操作

类和对象的关系

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

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

类是对象的抽象

对象是类的实体

类的定义

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

类是什么：是对现实生活中一类具有共同属性和行为的事物的抽象，确定对象将会拥有的属性和行为

类的组成：属性和行为

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

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

类的定义步骤：

1.定义类

2.编写类的成员变量

3.编写类的成员方法

对象的使用：

1.创建对象

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

范例：Phone p = new Phone();

2.使用对象

使用成员对象

格式：对象名.变量名

范例：p.brand

使用成员方法

格式：对象名.方法名()

范例：p.call()

成员变量和局部变量

成员变量：类中方法外的变量

局部变量：方法中的变量

区别

类中位置不同，成员变量类中方法外，局部变量方法内或者方法生命上

内存中位置不同，成员变量堆内存，局部变量栈内存

生命周期不同，成员变量随着对象的存在而存在，随着对象的消失而消失，局部变量随着方法的调用而存在，随着方法的调用完毕而消失

初始化值不同，成员变量有默认的初始化值，局部变量没有默认的初始化值，必须先定义，赋值才能使用

封装

private关键字

是一个权限修饰符

可以修饰成员（成员变量和成员方法）

作用是保护成员不被别的类使用，被private修饰的成员只在本类中才能访问

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

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

2.提供“ste变量名(参数)”方法，用于设置成员变量的值，方法用public修饰

this关键字

1.this修饰的变量用于指代成员变量

方法形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量

方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量

2.什么时候使用this呢？

解决局部变量隐藏成员变量

3.this代表所在类的对象引用

记住：方法被哪个对象调用，this就代表哪个对象

封装的概述

是面向对象三大特征之一（封装、继承、多态）

是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作的

封装的原则

将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问，成员变量private，提供对应的getXX()/setXX()方法

快捷键：Alt+Insert 快速生成构造、get、set方法

封装的好处

通过方法来控制成员变量的操作，提高了代码的安全性

把代码用方法进行封装，提高了代码的复用性

构造方法

构造方法是一种特殊的方法

作用：创建对象

格式：

public class 类名{

修饰符 类名（参数）{
}

}

功能:主要完成对象数据的初始化

构造方法的注意事项

1.构造方法的创建

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

如果定义了构造方法，系统将不在提供默认的构造方法

2.构造方法的重载

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

3.推荐的使用方式

无论是否使用，都书写无参构造方法

标准类制作

1.成员变量

使用private修饰

2.构造方法

提供一个无参构造方法

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

3.成员变量

提供每一个成员变量对应的setXxx()/getXxx()

提供一个显示对象信息的show()

4.创建对象并为其成员变量赋值的两种方式

无参构造方法创建对象后使用setXx()赋值

使用带参构造方法直接创建带有属性值的对象

API

API（Application Programming Interface）:应用程序编程接口

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

这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可，我们可以通过帮助文档来学习这些API如何使用

注意：

调用方法的时候，如果方法有明确的返回值，我们用变量接收

可以手动完成，也可以使用快捷键方式完成（Ctrl+Alt+V）快速生成左边

String

String概述

String类在java.lang包下，所以使用的时候不需要导报

String类代表字符串，Java程序中的所有字符串文字（例如”abc”）都被实现为此类的实例，也就是说，Java程序中所有的双引号字符串，都是String类的对象

字符串的特点

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

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

3.字符串效果上相当于字符数组（char[]），但是地城原理是字节数组（byte[]）

JADK8以前是字符数组，JDK9以后是字节数组

有两种方式得到String对象，一种是通过构造方法，一种是直接赋值

String对象的特点：

1.通过new创建的字符串对象，每一次new都会申请一个内存空间，虽然内容相同，但是地址值不同

2.以“”方式给出的字符串，只要字符串序列相同（顺序和大小写），无论在程序代码种出现几次，JVM都只会建立一个String对象，并在字符串池中维护

字符串比较：

使用==作比较

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

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

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

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

遍历字符串：

public char charAt(int index):返回指定索引处的char值，字符串的索引也是从0开始的

获取字符串长度：

public int length():返回字符串的长度

数组的长度：数组名.length

字符串的长度：字符串对象.length()

StringBuilder

StringBuilder是一个可变的字符串类，我们可以把它看成是一个容器，这里的可变指的是StringBUilder对象中的内容是可变的

String和StringBulider的区别：

String：内容是不可变的

StringBuilder：内容是可变的

StringBuilder的添加和反转方法

public StringBuilder append(任意类型)：添加数据，并返回对象本身

public StringBuilder reverse()：返回相反的字符序列

StringBuilder和String相互转换

1.StringBuilder转换为String

public String toString()：通过toString()就可以实现把StringBuilder转换为String

2.String转换为StringBuilder

public StringBuilder(String s)：通过构造方法就可以实现把String转换为StringBuilder

集合基础

集合概述

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

集合类有很多，目前先学习ArrayList

ArrayList< E >:

可调整大小的数组实现

< E >是一种特殊的数据类型，泛型

在出现E的地方我们使用引用数据类型替换即可

举例：ArrayList< String >、ArrayList< Student >

ArrayList构造方法和添加方法

public ArrayList()：创建一个空的集合对象

public booolean add(E e)：将指定的元素追加到此集合的末尾

public void add(int index, E element)：在此集合的指定位置插入指定的元素

ArrayList集合常用方法

public boolean remove(Object o)：删除指定的元素，返回删除是否成功

public E remove(int index)：删除指定索引出的元素，返回被删除的元素

public E set(int index ,E element)：修改指定索引处的元素，返回被修改的元素

public E get(int index)：返回指定索引处的元素

public int size()：返回集合中的元素的个数

JVM退出：System.exit(0)

继承

继承概述

继承是面向对象三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，追加属性和方法

继承的格式

格式：public class 子类名 extends 父类名｛｝

范例：public class Zi extends Fu｛｝

Fu：是父类，也被称为基类、超类

Zi：是子类，也被称为派生类

继承中子类的特点：

子类可以有父类的内容

子类还可以有自己特有的内容

继承的好处和弊端

继承好处

提高了代码的复用性（多个类相同的成员可以放到同一个类中）

提高了代码的维护性（如果方法的代码需要修改，修改一处即可）

继承的弊端

继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性

什么时候使用继承？

继承体现的关系：is a

假设法：我有两个类A和B，如果他们满足A是B的一种，或者B是A的一种，就说明他们存在继承关系，这个时候就可以考虑使用继承来体现，否则就不能滥用继承

举例：苹果和水果，猫和动物，猫和狗

继承中变量的访问特点

在子类方法中访问一个变量

1.子类局部范围找

2.子类成员范围找

3.父类成员范围找

4.如果都没有就报错（不考虑父亲的父亲……）

super

super关键字的用法和this关键字的用法相似

this：代表本类对象的引用

super：代表父类存储空间的标识（可以理解为父类对象的引用）

关键字	访问成员变量	访问构造方法	访问成员方法
this	this.成员变量 访问本类成员变量	this(……) 访问本类构造方法	this.成员方法(……) 访问本类成员方法
super	super.成员变量 访问父类成员变量	super(……) 访问父类构造方法	super.成员方法(……) 访问父类成员方法

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

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

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

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

如果父类中没有无参构造方法，只有带参构造方法

1.通过使用super关键字去显示的调用父类的带参构造方法

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

推荐：自己给出无参构造方法

继承中成员方法的访问特点

通过子类对象访问一个方法

1.子类成员范围找

2.父类成员范围找

3.如果都没有就报错（不考虑父亲的父亲……）

方法重写

方法重写概述：

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

方法重写的应用

1.当子类需要父类的功能，而功能主体子类自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容

@Override

1.是一个注解

2.可以帮助我们检查重写方法的方法声明的正确性

方法重写注意事项

1.私有方法不能被重写（父类私有成员子类是不能继承的）

2.子类方法访问权限不能更低（public > 默认 > 私有）

Java中继承的注意事项

1.Java中类只支持单继承，不支持多继承

2.Java中类支持多层继承

修饰符

包的概述和使用

其实就是文件夹

作用：对类进行分类管理

包的定义格式

格式：package 包名；（多级包用.分开）

范例：package com.itheima;

带包的Java类编译和执行

1.手动建包：

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

手动创建包 在E盘建立文件夹com，然后在com下建立文件夹itheima

把class文件放到包的最里面,把HelloWorld.class文件放到com下的itheima这个文件夹下

带包执行 java com.itheima.HelloWorld

2.自动建包：

javac -d . HelloWorld.java

java com.itheima.HelloWorld

导包的概述和使用

使用不同包下的类时，使用的时候要写类的全路径，写起来太麻烦了

为了简化带包的操作，Java就提供了导包的功能

导包的格式

格式：import 包名；

范例：import cn.itcast.Teacher

权限修饰符

权限修饰符

修饰符	同一个类中	同一个包中子类无关类	不同包的子类	不同包的无关类
private	√
默认	√	√
protected	√	√	√
public	√	√	√	√

状态修饰符

final

final关键字是最终的意思，可以修饰成员方法，成员变量，类

final修饰的特点

1.修饰方法：表明该方法是最终方法，不能被重写

2.修饰变量：表明该变量是常量，不能再次被赋值

3.修饰类：表明该类是最终类，不能被继承

final修饰局部变量

变量是基本类型：final修饰指的是基本类型的数据值不能发生改变

变量是引用类型：final修饰指的是引用类型的地址值不能发生改变，但地址里面的内容是可以发生改变的

static

static关键字是静态的意思，可以修饰成员方法，成员变量

static修饰的特点

被类的所有对象共享，这也是我们判断是否使用静态关键字的条件

可以通过类名调用，当然也可以通过对象名调用（推荐使用类名调用）

static访问特点

非静态的成员方法

1.能访问静态的成员变量

2.能访问非静态的成员变量

3.能访问静态的成员方法

4.能访问非静态的成员方法

静态的成员方法

1.能访问静态的成员变量

2.能访问静态的成员方法

总结一句话就是：静态成员方法只能访问静态成员

多态

多态概述

同一个对象，在不同时刻表现出来的不同形态

举例：猫

我们可以说猫是猫：猫 cat = new 猫();

我们也可以说猫是动物：动物 animal = new 猫（）；

这里猫在不同的时刻表现出来了不同的形态，这就是多态

多态的前提和体现

1.有继承/实现关系

2.有方法重写

3.有父类引用指向子类对象

多态中成员访问特点

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

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

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

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

多态的好处和弊端

多态的好处：提高了程序的扩展性

具体体现：定义方法的时候，使用父类型作为参数，将来在使用的时候，使用具体的子类型参与操作

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

多态中的转型

向上转型：从子到父，父类引用指向子类对象

向下转型：从父到子，从父类引用转为子类对象

抽象类

抽象类概述

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

抽象类的特点

1.抽象类和抽象方法必须使用abstract关键字修饰

public abstract class 类名 ｛｝

public abstract void eat();

2.抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类

3.抽象类不能实例化

抽象类如何实例化呢？参照多态的方式，通过子类对象实例化，这叫抽象类多态

4.抽象类的子类

要么重写抽象类中的所有抽象方法

要么是抽象类

抽象类的成员特点

1.成员变量

可以是变量，也可以是常量

2.构造方法

有构造方法，但是不能实例化

那么，构造方法的作用是什么呢？用于子类访问父类数据的初始化

3.成员方法

可以有抽象方法：限定子类必须完成某些动作

也可以有非抽象方法：提高代码复用性

接口

接口概述

接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用

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

接口的特点

1.接口用关键字intetface修饰

public interface 接口名｛｝

2.类实现接口用implements表示

public class 类名 implements 接口名｛｝

3.接口不能实例化

接口如何实例化呢？参照多态的方式，通过实现类对象实例化，这叫接口多态

多态的形式：具体类多态，抽象类多态，接口多态

多态的前提：有继承或者实现关系；有方法重写；有父（类/接口）引用指向（子/实现）类对象

4.接口的实现类

要么重写接口中的所有抽象方法

要么是抽象类

接口的成员特点

1.成员变量

只能是常量

默认修饰符：public static final

2.构造方法

接口没有构造方法，因为接口主要是对行为进行抽象的，是没有具体存在

一个类如果没有父类，默认继承自Object类

3.成员方法

只能是抽象方法

默认修饰符：public abstract

类和接口的关系

1.类和类的关系

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

2.类和接口的关系

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

3.接口和接口的关系

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

抽象类和接口的区别

1.成员区别

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

接口 常量、抽象方法

2.关系区别

类与类 继承、单继承

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

3.设计理念区别

抽象类 对类抽象、包括属性、行为

接口 对行为抽象、主要是行为

形参和返回值

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

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

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

2.接口名作为形参和返回值

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

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

内部类

内部类概述

内部类：就是在一个类中定义一个类

举例：在一个类A的内部定义一个类B，类B就被称为内部类

内部类的定义格式：

public class 类名｛

修饰符 class 类名｛
｝

｝

内部类的访问特点

内部类可以直接访问外部类的成员，包括私有

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

按照内部类在类中定义的位置不同，可以分为如下两种形式

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

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

成员内部类

成员内部类，外界如何创建对象使用呢？

格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象；

范例：Outer.Inner oi = new Outer().new Inner();

局部内部类

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

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

匿名内部类

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

格式：

new 类名或者接口名（）｛

重写方法；

｝

范例：

new Inter(){

public void show(){
}

}

本质：是一个继承了该类或者实现了该接口的子类匿名对象

常用API

Math类概述

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

没有构造方法，如何使用类中的成员呢？

看类的成员是否都是静态的，如果是，通过类名就可以直接调用

System类概述

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

Object类的概述

Object是类层次结构的根，每个类都可以将Object作为超类，所有类都直接或者间接的继承自该类

回想面向对象中，为什么说子类的构造方法默认访问的是父类的无参构造方法？

因为它们的顶级父类只有无参构造方法

看方法的源码，选中方法，按下Ctrl+B

Object类的常用方法

public String toString()

返回对象的字符串表示形式，建议所有子类重写该方法，自动生成

public boolean equals(Object obj)

比较对象是否相等，默认比较地址，重写可以比较内容，自动生成

Array

冒泡排序

排序：将一组数据按照固定的规则进行排列

冒泡排序：一种排序的方式，对要进行排序的数据中相邻的数据进行两两比较，将较大的数据放在后面，依次对所有的数据进行操作，直至所有数据按要求完成排序

如果有n个数据进行排序，总共需要比较n-1次

每一次比较完毕，下一次的比较就会少一个数据参与

Arrays类的概述和常用方法

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

public static String toString(int[] a) 返回指定数组的内容的字符串表示形式

public static void sort(int[] a) 按照数字顺序排列指定的数组

工具类的设计思想：

1.构造方法用private修饰（防止外界创建对象）

2.成员用public static修饰（使用类名访问该成员方法）

基本类型包装类

基本类型包装类概述

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

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

基本数据类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

int和String的相互转换

基本类型包装类的最常见操作就是：用于基本类型和字符串之间的相互转换

1.int转换为String

public static String valueOf(int i)返回int参数的字符串表示形式，该方法是String类中的方法

2.String转换为int

public static int parseInt(String s)将字符串解析为int类型，该方法是Integer类中的方法

自动装箱和拆箱

装箱：把基本数据类型转换为对应的包装类类型

拆箱：把包装类类型转换为对应的基本数据类型

注意：在使用包装类类型的时候，如果做操作，最好先判断是否为null

我们推荐的是，只要是对象，在使用前就必须进行不为null的判断

赏

谢谢你请我吃糖果