Java基础

天天++

已于 2023-01-03 17:02:16 修改

阅读量186

点赞数

分类专栏： JAVA 文章标签： java jvm 开发语言

于 2023-01-03 16:59:17 首次发布

本文链接：https://blog.csdn.net/m0_56090275/article/details/128535841

版权

JAVA 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

文章详细介绍了Java的基础知识，包括JVM、数据类型、关键字、运算符和方法的使用，以及面向对象编程的核心概念如类、对象、继承、抽象类和接口。此外，还涵盖了集合框架、多线程、I/O流以及异常处理等内容，为读者构建了完整的Java编程知识体系。

摘要由CSDN通过智能技术生成

##JavaSE | 笔记

一变量与数据类型

1.Java概述

JVM（Java Virtual Machine Java虚拟机）
JRE（Java Runtime Environment Java运行环境）
JDK（Java Development Kit Java开发工具包）

2.常用Dos命令

打开控制台（win + R，然后cmd回车）
常用命令

①盘符切换 d: 回车
②列出当前目录下的文件以及文件夹 dir(directory)
③进入指定目录 cd (change directory)
进入 cd 目录；cd 多级目录
回退 cd… ；cd
④cls : (clear screen)清屏
⑥exit : 退出dos命令行

3.注释

单行注释格式： //注释文字
多行注释格式： /* 注释文字 */
文档注释格式：/** 注释文字 */

4.关键字

定义数据类型：class interface byte short int long float doubt char boolean void
定义数据类型值：true false null
定义流程控制：if else switch case default while do for break continue return
定义访问权限修饰符：private protected public
定义类，函数，变量修饰符：abstract final static synchronized
定义类与类间关系：extends implements
定义建立实例及引用实例，判断实例的关键字：new this super instanceof
用于异常处理：try catch finally throw throws
用于包：package import
其他修饰符：native strictfp transient volatile assert

5.常量

字符串常量(“Java”)
整数常量(24)
小数常量(3.14)
字符常量(‘A’)
布尔常量(true,false)
空常量(null)

6.变量

变量定义格式

数据类型变量名 = 初始化值；

7.计算机存储单元

1B = 8bit
1KB = 1024B
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB

8.数据类型

基本数据类型
- 数值型
  
  整数类型：byte short int long
  
  浮点类型：float double
- 字符型：char
- 布尔型：boolean
引用数据类型
- 类：class
- 接口：interface
- 数组：[]

9.标识符

作用：给包,类,方法,变量等起名字
组成规则：由字符，下划线_，美元符$组成
注意：不能以数字开头，不能是关键字

11.类型转换

boolean类型不能转换为其他数据类型
默认转换

byte,short,char—int—long—float—double
强制转换

目标类型变量名 = （目标类型）（被转换的数据）；

###二运算符与表达

1.Eclipse概述

IDE（集成开发环境）
下载：http://eclipse.org/

2.运算符

算术运算符
- + - * / 加减乘除
- %求余
- ++自增 --自减
赋值运算符
- 基本的赋值运算符：=
- 扩展的赋值运算符：+= -= *= /=
关系运算符
- 关系运算符的结果都是boolean型：== ，！=，>，>=，<，<=
逻辑运算符
- 逻辑运算符用于连接布尔型表达式
  
  &，|，^，！
  
  &&，||
三元运算符
- 格式：(关系表达式)?表达式1：表达式2；
  
  如果条件为true，运算后的结果是表达式1；
  
  如果条件为false，运算后的结果是表达式2；

3.键盘录入（Scanner）

导包：import java.util.Scanner;
创建对象：Scanner sc = new Scanner(System.in);
接受数据：Scanner sc = new Scanner(System.in);

三条件判断与循环

1.流程控制语句

顺序结构
选择结构（分支结构）
- if语句：
  
  ①if(){ }
  
  ②if(){ }else{ }
  
  ③if(){ }else if(){ }else{ }
- swich语句：
  
  switch(表达式) {
  
  case 值1：
  
  语句体1;
  
  break;
  
  case 值2：
  
  语句体2;
  
  break;
  
  …
  
  default：
  
  语句体n+1;
  
  break;
  
  }
循环结构
- for循环
- while循环
- do…while循环

2.跳转控制语句

break(中断)：退出当前循环
continue(继续)：退出本次循环

3.随机数（Random）

导包：import java.util.Random;
创建对象：Random r = new Random();
获取随机数：int number = r.nextInt(10);

数据区间：[0，10）半闭半开

四 Java数组

1.数组概述

①数组的定义格式：

格式1：数据类型[] 数组名;

格式2：数据类型数组名[];

②数组的初始化：

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

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

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

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

③数组操作常见异常

数组索引越界

ArrayIndexOutOfBoundsException

访问到了数组中的不存在的索引时发生。

空指针异常

NullPointerException

数组引用没有指向对象，却在操作对象中的元素时。

2.Java中内存分配

Java 程序在运行时，需要在内存中分配空间。为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

栈：存储局部变量
堆：存储new出来的东西
方法区 (面向对象进阶)
本地方法区 (和系统相关)
寄存器 (给CPU使用)

3.二维数组

①定义格式

数据类型[][] 数组名;

数据类型数组名[][]; 不推荐

数据类型[] 数组名[]; 不推荐

②初始化方式

数据类型[][] 变量名 = new 数据类型[m][n];

数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};

简化版格式：数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};

五方法

1.方法

①格式：

修饰符返回值类型方法名(参数类型参数名1，参数类型参数名2…) {

函数体;

return 返回值;

}

②方法格式解释

修饰符目前记住 public static

返回值类型用于限定返回值的数据类型

方法名一个名字，为了方便我们调用方法

参数类型用于限定调用方法时传入的数据的类型

参数名用于接收调用方法时传入的数据的变量

方法体完成功能的代码

return 结束方法，把返回值带给调用者

2.方法重载

①方法重载概述

在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

②方法重载特点

与返回值类型无关，只看方法名和参数列表

在调用时，虚拟机通过参数列表的不同来区分同名方法

六断点调试与数据加密

七面向对象基础

1.面向对象思想概述及举例

2.类与对象及其使用

创建对象：

类名对象名 = new 类名();

3.对象内存存储机制

4.成员变量和局部变量的区别

①在类中的位置不同

成员变量类中方法外

局部变量方法内或者方法声明上

②在内存中的位置不同

成员变量堆内存

局部变量栈内存

③生命周期不同

成员变量随着对象的存在而存在，随着对象的消失而消失

局部变量随着方法的调用而存在，随着方法的调用完毕而消失

④初始化值不同

成员变量有默认的初始化值

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

private关键字：是一个权限修饰符。可以修饰成员(成员变量和成员方法)。被private修饰的成员只在本类中才能访问。

private最常见的应用：把成员变量用private修饰提供对应的getXxx()/setXxx()方法一个标准的案例的使用

5.封装(private)

封装概述：是面向对象三大特征之一。(其它两个是继承和多态）；是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。

封装原则：将不需要对外提供的内容都隐藏起来。把属性隐藏，提供公共方法对其访问。成员变量private，提供对应的getXxx()/setXxx()方法

好处：通过方法来控制成员变量的操作，提高了代码的安全性把代码用方法进行封装，提高了代码的复用性。

6.this关键字

this：代表所在类的对象引用

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

什么时候使用this：局部变量隐藏成员变量

7.构造方法

①构造方法作用概述

给对象的数据进行初始化

②构造方法格式

方法名与类名相同

没有返回值类型，连void都没有

没有具体的返回值

③构造方法注意事项

如果你不提供构造方法，系统会给出默认构造方法

如果你提供了构造方法，系统将不再提供

构造方法也是可以重载的

标准类的代码写法和测试：

类：

成员变量

构造方法：无参构造方法，带参构造方法

成员方法：getXxx()，setXxx()

给成员变量赋值的方式：

无参构造方法+setXxx()

带参构造方法

8.类名作为形式参数和返回值

类名作为形式参数案例：要的其实是该类的对象

类名作为返回值案例：返回的其实是该类的对象

八 Java常用API

1.API概述

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

2.String

①String类概述

字符串是由多个字符组成的一串数据

字符串可以看成是字符数组

②构造方法

public String(String original)

public String(char[] value)

public String(char[] value,int offset,int count)

直接赋值也可以是一个对象

③String的特点

通过构造方法创建字符串对象

String s = new String(“hello”);

直接赋值创建字符串对象

String s = “hello”;

④String类的判断功能

boolean equals(Object obj)

boolean equalsIgnoreCase(String str)

boolean startsWith(String str)

boolean endsWith(String str)

⑤String类的获取功能

int length()

char charAt(int index)

int indexOf(String str)

String substring(int start)

String substring(int start,int end)

⑥String类的转换功能

char[] toCharArray()

String toLowerCase()

String toUpperCase()

⑦String类的其他功能

去除字符串两端空格 String trim()

按照指定符号分割字符串 String[] split(String str)

3.StringBuilder

①StringBuilder类概述：我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。而StringBuilder就可以解决这个问题

②StringBuilder构造方法：public StringBuilder()

③StringBuilder类的常用方法：

添加功能public StringBuilder append(任意类型)

反转功能public StringBuilder reverse()

九 Java集合

1.ArrayList类

①构造方法

ArrayList()

②成员方法

添加元素

public boolean add(E e):添加元素

public void add(int index,E element):在指定的索引处添加一个元素

获取元素

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

集合长度

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

删除元素

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

public E remove(int index):删除指定索引处的元素，返回被修改的元素

修改元素

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

③创建集合对象

ArrayList<String> array = new ArrayList<String>();

十 IO流

1.IO流概述

IO流用来处理设备之间的数据传输

文件复制,上传文件和下载文件

IO流分类

输出流：FileWriter

输入流：FileReader

2.FileWriter写数据

①构造方法

FileWriter(String fileName)

②成员方法

void write(String str)

void flush()

void close()

③写数据方法

void write(String str)

void write(String str,int index,int len)

void wirte(int ch)

void write(char[] chs)

void write(char[] chs,int index,int len)

3.FileReader读数据

①构造方法

FileReader(String fileName)

②成员方法

int read()

int read(char[] cbuf)

4.字符缓冲流

BufferedWriter基本用法

BufferedReader基本用法

字符缓冲流复制文本文件

特殊功能

BufferedWriter

void newLine()

BufferedReader

String readLine()

字符缓冲流特殊功能复制文本文件

十一面向对象高级-static&代码块

1.static(静态)关键字

①static是一个修饰符，用于修饰成员（成员变量、成员方法）

②static的特点

随着类的加载而加载

优先于对象存在

被类的所有对象共享

可以被类名调用

③static的注意事项

静态方法只能访问静态成员

非静态方法既可以访问静态也可以访问

非静态非静态方法中不可以定义静态变量

静态方法中不可以定义this,super关键字

④static的优点

对对象的共享数据提供单独空间的存储，节省空间，没有必要每一个对象都存储一份

可以直接被类名调用,不用在堆内存创建对象

⑤static的弊端

访问出现局限性。（静态虽好，但只能访问静态）

2.Math类

Math 类包含用于执行基本数学运算的方法。数学操作常用的类。

Math类的使用没有构造方法

Math类要掌握的功能

字段：PI

方法：abs ，max，min ，pow，ceil，floor，round,random

3.代码块

在Java中，使用{}括起来的代码被称为代码块代码块分类

①局部代码块

在方法中出现，控制变量生命周期，及早释放，提高内存利用率

②构造代码块

在类中方法外出现，抽取构造方法中的共性，每次创建对象都会执行，并且在构造方法前执行。

③静态代码块

在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且只执行一次。

一般用于加载驱动

④同步代码块(多线程部分)

十二面向对象高级-继承与抽象类

1.继承

①多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。

②子类可以直接访问父类中的非私有的属性和行为。

③通过 extends 关键字让类与类之间产生继承关系。

class SubDemo extends Demo{}

④Java只支持单继承，不支持多继承。

一个类只能有一个父类，不可以有多个父类。

class SubDemo extends Demo{} //ok

class SubDemo extends Demo1,Demo2…//error

⑤Java支持多层继承(继承体系)

class A{}

class B extends A{}

class C extends B{}

⑥继承中的成员变量

如果子父类中出现非私有的同名成员变量时，子类要访问本类中的变量，用this;访问父类中的同名变量用super。

super的使用和this的使用几乎一致。

this代表的是本类对象的引用；super当前子类对象父类的引用

⑦继承中的成员方法

当子类出现和父类一模一样的方法时，当子类对象调用该方法，会运行子类方法的内容。如同父类的方法被覆盖一样。

这种情况是方法的另一个特性：

重写（覆盖）(override)

重载overload

⑧继承中的构造方法

在对子类对象进行初始化时，父类的构造方法也会运行，那是因为子类的构造方法默认第一行有一条隐式的语句super()

super()：会访问父类中的空参数构造方法。而且子类中所有的构造方法默认第一行都是super( )

⑨继承的优缺点

优点：

提高了代码的复用性

提高了代码的可维护性

缺点：

类的耦合性增强了

开发的原则：高内聚低耦合

内聚：就是自己完成某件事情的能力

耦合：类与类的关系

2.方法的重写

子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为重写或者复写。

父类中的私有方法可不可以被覆盖呢?子类根本就看不到父类的方法

在子类覆盖方法中，继续使用被覆盖的方法可以通过super.方法名获取。

覆盖注意事项：覆盖时，子类方法权限一定要大于等于父类方法权限

覆盖的应用：当子类需要父类的功能，而功能主体子类有自己特有内容时，可以复写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。

3.super关键字

super和this的用法相像

this代表对象的引用(谁调用就代表谁)

super代表当前子类对象父类的引用

当子父类出现同名成员时，可以用super进行区分

子类要调用父类构造方法时，可以使用super语句

4.super和this的区别

this ：对象的引用(谁调用就代表谁)

使用this关键字引用成员变量。

使用this关键字在自身构造方法内部引用其他构造方法。

使用this关键字引用成员方法

super ：当前对象里面的父类的引用。

在子类的构造方法内部引用父类的构造方法。

在子类中调用父类中的成员方法。

在子类中调用父类中的成员变量。

5.抽象类（abstract）

①成员变量

可以有变量

可以有常量

②构造方法

可以有构造方法

③成员方法

可以有抽象方法

可以有非抽象方法

十三面向对象高级-接口与多态

1.接口（interface）

定义:是抽象方法和常量值的集合

从本质上讲,接口是一种特殊的抽象类,这种抽象类中只包含常量和方法的定义,而没有变量和方法的实现

格式：interface 接口名{}

接口的出现将“多继承”通过另一种形式体现出来，即“多实现”。(implements)

接口中的成员

接口中的成员修饰符是固定的

成员常量：public static final 接口里面定义变量是全局常量，而且上面三个关键字都可以省略,而且只能是 public static final

成员函数：public abstract 接口里面定义的方法都是抽象的，而且上面的两个关键字也是可以省略的

接口中的成员都是public的

接口的优点

接口是对外暴露的规则。

类与接口的关系是实现。

接口的出现降低耦合性。(实现了模块化开发,定义好规则,每个人实现自己的模块,大大提高了开发效率)。

2.继承和实现

类与类之间称为继承:因为该类无论是抽象的还是非抽象的,它的内部都可以定义非抽象方法,这个方法可以直接被子类使用,所以子类继承就可以应用了

类与接口是实现关系:因为接口中的方法都是抽象的,必须由子类实现才可以实例化,所以就用了这个关键字implements

接口与接口之间是继承关系:一个接口可以继承另一个接口,并添加新的属性和抽象方法,并且接口可以多继承

3.单继承和多实现

类只能单继承,而接口可以多实现

java将多继承机制进行改良,通过多实现接口的形式来体现

为什么不支持多继承呢?因为你继承的多个父类中定义了相同的方法,而方法内容不同,jvm无法判断选择哪个个父类的方法,有安全隐患而多实现就没有这个问题,即使是多个接口中都有相同的方法,但是他们都没有方法体

多实现的好处,一个类继承另一个类的同时可以实现多个接口,一个女星只能有一个亲爹,但是干爹就可以有很多了.多实现的好处是扩展了功能

接口的出现打破了单继承的局限性

4.匿名对象

匿名对象是对象的简化形式,是没有名字的对象.(只要是简化形式就有一定局限性)

匿名对象应用场景

匿名对象使用时需要注意的两种情况

当对对象方法仅进行一次调用的时候

匿名对象可以作为实际参数进行传递

5.final关键字

final可以修饰类，方法，变量。

final修饰的类不可以被继承。

final修饰的方法不可以被覆盖。

final修饰的变量是一个常量。只能被赋值一次。

什么时候将变量修饰成final呢?

通常在程序中使用一些不会变化的数据.也就是常见的一些常量值.比如3.14,这个数直接使用是可以的,但并不利于阅读,所以一般情况下,都会被该数据起个容易阅读的名称

final修饰的常量定义一般都有书写规范,被final修饰的常量名称,所有字母都大写例如:double PI = 3.14;如果由多个单词组成每个单词间用下划线连接

局部内部类只能访问被final修饰的局部变量。

final和private区别

区别1

final修饰的类可以访问

private不可以修饰外部类,但可以修饰内部类,讲内部类的时候会演示（其实把外部类私有化是没有意义的）

区别2

final修饰的方法不可以被子类重写

private修饰的方法表面上看是可以被子类重写的，其实不可以，子类是看不到父类的私有方法的

区别3

final修饰的变量只能在显式初始化或者构造函数初始化的时候赋值一次，以后不允许更改

private修饰的变量，也不允许直接被子类或一个包中的其它类访问或修改，但是它可以通过set和get方法对其改值和取值

6.多态（ polymorphic ）

定义：某一类事物的多种存在形态。

动态绑定：是指“在执行期间”（而非编译期间）判断所引用对象的实际类型，根据实际类型调用相应的方法。

程序中体现：父类或者接口的引用指向或者接收自己的子类对象。

多态三个必要条件：父类引用指向子类对象要有覆盖操作，也就是重写需要存在继承或者实现关系

多态的成员特点：

成员变量：

编译时期:看的是引用型变量所属的类中是否有所调用的变量

运行时期:也是看引用型变量所属的类是否有调用的变量

成员变量无论编译还是运行都看引用型变量所属的类,简单记成员变量,编译和运行都看等号左边

成员函数：

编译时：要查看引用变量所属的类中是否有所调用的成员。

在运行时：要查看对象所属的类中是否有所调用的成员。如果父子出现同名的方法,会运行子类中的方法,因为方法有覆盖的特性

编译看左边运行看右边

静态函数:

编译时期:看的引用型变量所属的类中是否有所调用的变量

运行时期:也是看引用型变量所属的类是否有调用的变量

编译和运行都看等号左边

多态中的类型转换

向上转型

子类转型成父类型

Animal a = new Dog();

向下转型

父类型转型成子类型

Dog d = (Dog)a;

多态的优缺点

好处和作用：多态的存在提高了程序的扩展性和后期可维护性

弊端:父类调用的时候只能调用父类里的方法,不能调用子类的特有方法,因为你并不清楚将来会有什么样的子类继承你

十四面向对象高级-包&修饰符&内部类

1.包（package）

①对类文件进行分类管理。

②给类提供多层命名空间。

③写在程序文件的第一行。

④类名的全称是包名.类名。

⑤包也是一种封装形式。

⑥不同包之间的相互访问

当一个包中的类访问其他包中的类：

使用类的全名称,包.类

使用import关键字将类导入，让导入的类对当前类可见

被访问的包中的类权限必须是public的。

注意:当类被public修饰,文件名和源文件必须一致,而且在一个文件写多个类的时候只能有一个类是public修饰的,这个被public修饰的还必须和文件名一致

类中的成员权限：public或者protected

protected是为其他包中的子类提供的一种权限

2.Java中常用的包

java.lang

包含一些Java语言的核心类，如String、Math、Integer、System和Thread，提供常用功能。

java.net

包含执行与网络相关的操作的类。

java.io

包含能提供多种输入/输出功能的类。

java.util

包含一些实用工具类，如定义系统特性、使用与日期日历相关的函数。

3.权限修饰符

	public	protected	default	private
同一个类中	√	√	√	√
同一个包不同类	√	√	√
不同包子类	√	√
不同包中的类	√

4.内部类

将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）

访问特点：内部类可以直接访问外部类中的成员，包括私有成员外部类要访问内部类中的成员必须要建立内部类的对象（内部类静态成员除外）

内部类分类

成员内部类

局部内部类

匿名内部类

共性:

内部类仍然是一个独立的类，在编译之后会内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号。

内部类不能用普通的方式访问。内部类是外部类的一个成员，因此内部类可以自由地访问外部类的成员变量，无论是否是private的。

5.成员内部类

解释:成员内部类,在一个外部类中有成员变量,和成员方法,那么成员内部类就是把整个一个类当成了外部类的成员了.

位置:在类中并且在方法外定义的类.

成员内部类创建对象方式:外部类名.内部类名对象名 = 外部类对象.内部类对象

成员内部类之所以可以直接访问外部类的成员,那是因为内部类中都持有一个外部类对象的引用:外部类名.this

成员内部类的修饰符：

对于普通的类，可用的修饰符有final、abstract、public和default。

但是成员内部类更像一个成员变量或方法。

可用的修饰符有：final、abstract、public、private、protected和static等。

一旦用static修饰内部类，它就变成静态内部类了。

静态的成员内部类

解释:静态内部类就是给成员内部类加上static这个修饰符

访问方式

方式1:在外部类中访问静态内部类中的非静态成员外部类名.内部类名对象名 = 外部类名.内部类对象通过创建对象访问

方式2:在外部类中访问静态内部类中的静态成员可以通过上一种,也可以直接外部类名.内部类名.成员我们把静态内部类看成一个类中的成员,既然是静态修饰的,就可以用类名.调用

注意:如果成员内部类用static修饰就出现了访问局限性,和静态方法是一个道理,就不能访问外部类的非静态成员了

静态内部类之所以可以直接访问外部类中的静态成员,其实是持有外部类名

6.局部内部类

位置:定义在方法中的类

注意:

方法内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化。

方法内部类对象不能使用该内部类所在方法的非final局部变量。

与成员内部类不同，方法内部类更像一个局部变量,可以用于修饰方法内部类的只有final和abstract。

静态方法是没有this引用的，因此在静态方法内的内部类遭受同样的待遇，即：只能访问外部类的静态成员。

7.匿名内部类

就是局部内部类的简化写法。

前提：内部类可以继承或实现一个外部类或者接口。

格式为：new 外部类名或者接口名(){覆盖类或者接口中的代码，(也可以自定义内容。)}

简单理解：就是建立一个带内容的外部类或者接口的子类匿名对象。

匿名内部类的应用场景：

通常在使用方法是接口类型参数、并且该接口中的方法不超过三个时，可以将匿名内部类作为参数传递。

简化书写,如果阅读实在费劲的话,可以写有名字的内部类

十五常用API-高级

1.Object

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

②Object类要掌握的功能

equals：指定其他某个对象是否与此对象"相等"

toString

String toString()：返回该对象的字符串表示

return getClass().getName()+“@”+Integer.toHexString(hashCode());

getClass()：返回一个字节码对象

Integer.toHesString()：返回指定参数的十六进制字符串形式

hashCode()：返回该对象的哈希码值(内部地址)

2.System

①System类提供的设施中，有标准输入、标准输出和错误输出流；对外部定义的属性和环境变量的访问；加载文件和库的方法；还有快速复制数组的一部分的实用方法。

②System类要掌握的功能：

arraycopy()：从指定源数组中复制一个数组

exit()：终止当前正在运行的Java虚拟机

currentTimeMillis()：返回以毫秒为单位的当前时间(System.currentTimeMillis())

gc()：运行垃圾回收器（传统而便捷的方式：System.gc()）

3.Date

类 Date 表示特定的瞬间，精确到毫秒。

Date类的构造方法

空构造

参数为毫秒值

Date类要掌握的功能

毫秒到日期的转换：setTime() toLocaleString() getTime()

日期到毫秒的转换

4.DateFormat

DateFormat类是对日期进行格式化的类

DateFormat类的使用

本身是一个抽象类，所以必须使用的时候使用的是其子类SimpleDateFormat，并且在子类中有很多模式字母需要记住。

DateFormat要掌握的功能

从日期到字符串的转换(format)

从字符串到日期的转换(parse)

5.Calendar

Calendar类是日历类，用于替代Date类的使用。它里面提供了很多功能来单独获取日历的某个数据。

Calendar类的使用

抽象类，但是提供方法用于获取子类对象：Calendar c = Calendar.getInstance();

获取：get(Calendar.YEAR)

修改：set(Calendar.YEAR,2030)

增减：add(Calendar.HOUR_OF_DAY,3)

6.基本数据类型包装类

byte Byte

short Short

char Character

int Integer

long Long

float Float

double Double

boolean Boolean

自动装箱

Integer i = new Integer(10);----------Integer i = 10;---------int i = 10;

自动拆箱

int a = i.intValue();----Integer i = 10;----int a = i;

7.正则表达式

正则表达式：是指一个用来描述或者匹配一系列符合某个句法规则的字符串的单个字符串。其实就是一种规则。有自己特殊的应用

匹配功能

使用String类中的matches方法：告知此字符串是否匹配给定的正则表达式

先去学习Pattern类，了解规则。

字符类,预定义字符类,边界匹配器,数量词

十六泛型与数据类型

1.集合的体系结构

由于不同的数据结构（数据的组织，存储方式)，所以Java为我们提供了不同的集合，
但是不同的集合他们的功能都是相似，不断的向上提取，将共性抽取出来，这就是集合体系结构形成的原因

Collection List ArrayList

2.泛型

泛型:是一种广泛的类型，把明确数据类型的工作提前到了编译时期，借鉴了数组的特点

泛型好处:
避兔了类型转换的问题

可以减少黄色警告线

可以简化我们代码的书写
什么时候可以使用泛型?
问API，当我们看到<E>，就可以使用泛型了

3.迭代器Iterator

集合的遍历方式:
1.toArray(),可以把集合转换成数组,然后遍历崴数组即可
2.iterator(),可以返回一个迭代器对象，我们可以通过迭代器对象来迭代集合
Iterator:可以用于遍历集合
E next():返回下一个元素
boolean hasNext():判断是否有元素可以获取
注意:Exception in thread “main” java.util.NoSuchElementException
使用next方法获取下一个元素，如果没有元素可以获取，则出现NoSuchElementException

4.foreach概述

foneach:增强for循环,—般用于遍历集合或者数组

格式:
for(元素的类型变量:集合或者数组对象){
可以直接使用变量;
}
注意:在增强for循环中不能修改集合，否则会出现并发修改异常。
public interface Iterable<T>
实现这个接口允许对象成为“foneach”语句的目标。

5.常见数据结构

①数组（查找快，增删慢）

数组的特点：

数组的长度一旦定义则不可改变
数组中的元素都有整数索引
数组只能存储同一类型的元素
数组即可以存储基本数据类型，也可以存储引用数据类型

②链表（查询慢，增删快）

链表︰由链子连接起来的一堆结点

结点:地址值，值，下一个结点地址值

1，2，3，4，5
如何获取结点3?
没有什么好的方法，只能遍历链表，然后一个一个查看
要在结点2后面添加一个新的结点8?
把结点2的下一个结点地址值修改为新结点8的地址值，把新结点8的下一个地址值改为Ox0033

③栈和队列

栈：先进后出

队列：先进先出

6.List接口

有序的《存储和读取的顺序是一致的》

有整数索引
允许重复的

List的特有功能:
void add(int index, E element)

E get(int index)
E remove(int index)
E set(int index，Eelement)
增删改查

7.LinkedList

List的常用子类:
ArrayList
底层是数组结构,查询快,增删慢

LinkedList
底层结构是链表,查询慢，增删快
如何选择使用不同的集合?
如果查询多，增删少，则使用ArrayList

如果查询少，增删多，则使用LinkedList

如果你不知道使用什么，则使用ArrayList

LinkedList的特有功能:
void addFirst(E e)

void addLast(E e)

E getFirst( )

E getLast()

E removeFirst()

E removeLast()

十七 Map与Set集合

1.Set

Set的特点：

无序（存储和读取的顺序可能不一样）

不允许重复

没有整数索引

2.HashSet

使用HashSet存储字符串并遍历

HashSet的add()方法，首先会使用当前集合中的每一个元素和新添加的元素进行hash值比较，

如果hash值不—样,则直接添加新的元素
如果hash值一样,比较地址值或者使用equals方法进行比较

比较结果一样,则认为是重复不添加
所有的比较结果都不一样则添加

3.Collections工具类

面试题:collection和collections有什么区别?
collection是集合体系的最顶层,包含了集合体系的共性

collections是一个工具类,方法都是用于操作collection

static int binarySearch(List list, 0bject key)使用二分查找法查找指定元素在指定列表的索引位置1 2 3 4 5 6 7

static void copy(List dest,List src):是把源列表中的数据覆盖到目标列表

注意:目标列表的长度至少等于源列表的长度
创建源列表

static void fill(List list，object obj):使用指定的对象填充指定列表的所有元素

static void reverse(List list):反转

static void shuffle(List list):随机置换

static void sort(List<T> list):按照列表中元素的自然顺序进行排序

static void swap(List list，int i, int j) :将指定列表中的两个索引进行位置互换

4.Map接口

将键映射到值的对象。一个映射不能包含重复的键;每个键最多只能映射到一个值

创建Map对象
Map<String,String> map = new HashMap<String,String>();

Map和Collection有什么区别?|
Map:是一个双列集合，常用语处理有对应关系的数据，key是不可以重复的，我们也称之为是夫妻对集合
Collection:是单列集合，collection有不同的子体系，有的允许重复有索引有序，有的不允许重复而且无序，那么我们也称之为单身汉集合

Map的常用功能:
映射功能:
V put(K key , V value):将key映射到value，如果key存在，则覆盖value，并将原来的value返回
获取功能:
V get(object key)int size()：根据指定的key返回对应的value
判断功能:
boolean containsKey (object key)：判断指定的key是否存在

boolean containsValue(object value)：判断指定的value是否存在

boolean isEmpty()：判断是否有对于关系
删除功能:
void clear():清空所有对应关系
V remove(object key)：根据指定的key删除对应关系，并返回key所对应的值，如果没有删除成功则返回null
遍历功能:
Set<Map.Entry<K,V>> entrySet( )

int size()：返回对应关系的个数

set<K> keySet():以Set的形式获得返回所有的key
Collection<V> values()：以Collection的形式获得返回所有的value

十八异常处理

1.异常概述

异常包含了错误的类型、原因以及位置
异常:不正常,我们在代码的时候出现的编译或者运行时的错误异常的体系结构:
Throwable《最顶层)
Error :出现的不能够处理的严重问题

Exception:可以处理的问题

2.异常的处理方式:
①捕获处理
try…catch语句
try {
有可能出现问题的代码;
}catch(ArithmeticException ae) {

处理异常;
}
try . …catch的执行顺序:
首先执行try语句
如果发现异常，异常下面的代码不在执行，直接跳入catch语句中,catch语句结束后，整个try . …catch结束

如果没有发现异常，try语句执行结束后，try. …catch直接结束，不在执行catch语句
②抛出去
当我们不想处理异常，或者没有能力处理的时候，我们可以选择抛出异常，谁调用方法谁处理异常

使用关键字throws在方法的声明出抛出异常

③jvm处理异常的方式:
如果出现异常我们没有处理，jvm会帮我们进行处理，他会把异常的类型，原因还有位置显示在命令行并且还终止了程序，异常后面的代码将不在执行

④如何处理多个异常:
可以使用多个try . . .catch语句

使用一个try和多个catch
多个catch之间的顺序:
多个catch之间可以有子父类

平级之间没有顺序关系
如果有子父类，父类异常必须放在后面

3.Throwable的常用方法

String getMessage() 原因

String toString() 类型和原因

void printStackTrace() 类型原因和位置

4.finally概述

finally:组合try. …catch使用，用于释放资源等收尾工作，无论try . …catch语句如何执行，finally的代码一定会执行
try {
有可能出现问题的代码;
} catch(异常对象){
处理异常;
}finally {
释放资源;

清理垃圾;

}

5.异常的分类

运行时期异常:RuntimeException的子类就是运行时期异常，在编译时期可以自由选择处理或者不处理

编译时期异常:是Exception的子类，非RuntimeExcpetion的子类，在编译时期必须处理

6.自定义异常

throws:处理异常的一种方式,把异常抛出，由调用者来处理

throw :制造异常的方式,并且结束方法

注意:如果抛出(throw〉的是编译时期异常，必须在方法声明处抛出(throws)

如何自定义一个异常类呢?
非常简单，写一个类去继承Exception或者RuntimeException，然后实现多个构造即可

7.递归概述

递归:把大问题拆成很多小问题，然后再把小问题拆成更多的小问题，
当我们把更多小问题解决了，小问题也解决了
随着小问题的解决，大问题也随之解决了
在方法本身不断的调用方法自己
递归注意事项:
递归一定要有出口，内存溢出

递归次数不宜过多，内存溢出

8.斐波那契数列

规律：除了第一和第二个数字以外，其余每个数都是前两个数之和

十九 IO流-高级

1.File类概述和常用功能

File:文件和目录路径名的抽象表示形式，File 类的实例是不可变的
构造方法:
File(File parent,string child)：根据指定的父路径对象和文件路径创建File对象

File(String pathname)：将指定的路径名转化成一个File对象

File( string parent, string child)：根据指定的父路径和文件路径创建File对象
File的常用功能:
创建功能
boolean createNewFile()：当指定文件不存在时创建文件并返回true，否则返回false
boolean mkdir()：当指定文件夹不存在时创建文件夹并返回true，否则返回false
boolean mkdirs()：创建指定文件夹，当文件夹所在的目录不存在，则顺道一块创建了

删除功能
boolean delete():当指定的文件或文件夹存在时删除文件或者文件夹并返回true，否则返回false

绝对路径:固定不可改变的路径，以盘符开头

相对路径:相对某个参照物,不能以盘符开头
在eclipse中相对路径相对应当前项目的根目录
注意:删除一个文件夹,这个文件夹下面不能有其他的文件和文件夹

获取功能
File getAbsoluteFile():以File对象的形式返回当前File对象所有指向的绝对路径

String getAbsolutepath():返回File对象所指向的绝对路径

String getName( )：获取文件和文件夹的名称
String getParent()：返回此抽象路径名父目录的路径名字符串;如果此路径名没有指定父目录，则返回null

File getParentFile()：返回此抽象路径名父目录的路径名;如果此路径名没有指定父目录，则返回null

String getPath()：返回创建File对象时给的路径

long lastModified()：以毫秒值的形式返回最后修改时间

long length()：返回文件的字节数
判断功能
boolean exists()：判断文件或者文件夹是否存在，如果存在则返回true，否则返回false
boolean isAbsolute():判断File对象指向的路径是否是绝对路径，如果是绝对路径则返回true，否则返回false

boolean isDirectory():判断File对象指向的路径是否是文件夹，如果是则返回true，否则返回false

boolean isFile():判断File对象指向的路径是否是文件，如果是则返回true，否则返回false

boolean isHidden():判断File对象指向的路径是否有隐藏属性，如果隐藏了则返回true，否则返回false

修改功能

boolean renameTo(File dest)：将当前File对象所指向的路径修改为指定File所指向的路径注意:修改的文件路径不能存在，如果存在则修改失败

File的重要获取功能

String[] list()

返回当前路径下所有的文件和文件夹名称

注意:只有指向文件夹的File对象才可以调用该方法

File[] listFiles()：返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。

static File[] listRoots()：返回所有盘符

2.I0流分类:
流向
输入流读取数据FileReader Reader

输出流写出数据Filewriter Writer
数据类型
字节流
字节输入流读取数据InputStream
字节输出流写出数据OutputStream
字符流
字符输入流读取数据Reader
字符输出流写出数据Writer

二十字符流与字节流

1.标准输入输出流:
public static final Inputstream in:字节输入流，用来读取键盘录入的数据
public static final int x;
InputStream in = System.in;
Scanner sc = new Scanner(System.in) ;
public static final PrintStream out :字节输出流，将数据输出到命令行
system.out.println( );

2.OutputStreamWriter

由于标准输出流是一个字节输出流，所以只能输出字节或字节数组，但是我们读取到的数据是字符串，如果想进行输出还需要转换成字节数组我们要想通过标准输出流输出字符串，把标准输出流转换成一种字符输出流即可，outputStreamwriter

3.InputStreamReader

转换流:需要把字节输入流转换成字符输入流，InputStreamReader

4.打印流
PrintStream字节输出流

PrintWriter字符输出流
不是自动行刷新,需要主动刷新

可以自动换行,pnintln()

不能输出字节，但是可以输出其它任意类型

通过某些配置，可以实现自动刷新（只有在调用println、printf或format才有用)

也是包装流，不具备写出功能

可以把字书输出流转换成字符输出流

注意:只能输出不能输入

打印流的特有功能:
自动换行使用pcintln()实现自动换行
自动刷新创建Printwriter对象时启动自动刷新开关，并且使用pnint.ln、pcintf或format三个方法可以实现自动刷新
注意:创建Filewriter对象时boolean参数是否追加
而创建打印流对象的boolean类型参数是是否自动刷新

5.对象操作流

可以用于读写任意类型的对象
ObjectOutputStream
writeObject
ObjectOutputStream(OutputStream out)
ObjectInputStream
readObject
ObjectInputStream( InputStream in)
注意:
使用对象输出流写出对象,只能使用对象输入流来读取对象

只能将支持java.io.Serializable接口的对象写入流中

6.Properties概述

Hashtable 实现一个哈希表，该哈希表将键映射到相应的值。任何非null对象都可以用作键或值。
从Java 2平台v1.2起，此类就被改进以实现Map接口.不像新的collection实现，Hashtable是同步的
properties extends Hashtable
Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。

getProperty()
setProperty()

7.编码表

把计算机底层的二进制转换成我们能看懂的字符

ASCII

GB2312----- GBK

Unicode 所有的字符都占2个字节

UTF-8 长度可变的码表

ANSI:本地编码表

Java中的字符串默认使用的是ANSI(gbk)

乱码：编码保持前后一致即可解决