java基础入门

2021年2月4日

java个版本和体系架构

J2EE（javaEE）定位在服务器端的应用

J2SE（javaSE）定位在个人计算机上的应用

J2MD（javaME）定位在消费形电资产品上

JVM

JVM是一种规范，就是一个虚拟的用于执行bytecodes字节码的计算机。

java虚拟机是java最核心的技术，也是跨平台的基础

可以使用软件来实现（LBM,SUN,BEA等，自己也可以写一个JVM）

可以使用硬件来实现，比如sun公司研发的java芯片

JAVA代码（理解为String）-----进行编译和解释------Runtime System---Operating System(CPU,存储设备)----Hardware（硬件设备）-----------由JVM实现的。

JVM和JAVA跨平台特性

通过“编译器”将java源程序编译成java字节码文件（.class）（字节码文件采用结构中立的中间文件格式）

通过“解释器”将java字节码文件解释为对应机器语言并运行

JRE(JAVA Runtime Environment)

包含java虚拟机，库函数运行java应用所必需的文件

JDK（JAVA Development Kit）

包含JRE，以及增加编译器和调试器等用于程序开发的文件

DOS命令

dir directory查看当前目录下的文件和子文件

cd change directory改变当前文件夹

md make directory创建当前文件夹

rd remove directory删除当前文件夹

cls clear screen清除屏幕

Tab键 帮助自动完成文件名或文件夹

上下箭头 显示之前或之后的命令

常规建议：

1，驼峰标识

1，类名，接口名称在命名的时候要首字母大写

2，方法，变量命名的时候首字母要小写

3多个单词拼接表示一个标志服的时候每个单词的首字符都大写

数据类型

java是一种强类型的语言

强类型表示，变量在定义的时候必须显式的声明类型是什么

弱类型表示，变量会更具值自己去判断，不需要指定类型是什么。

java数据类型

基本数据类型（4类8种）

整数类型：byte short int long

字符类型：char（占用两个字节）

浮点类型:float（4字节） double（8字节）------使用小数点----使用科学计数法，浮点型会损失一定的值。

布尔类型:boolean(占1位)

引用数据类型:class , interface, 数组引用

final常量：使用final修饰的变量，只能被初始化一次，变成了常量；

final常量是有名称的。

三目运算符：（？ ：），表达式如果是true，则返回？后的结果，如果是false，则返回：就的结果

打印输出语句

Scanner src = new Scanner(System.in);

int count = src.nextInt();

2021年2月5日

递归算法：

程序调用自身的编程技巧称为递归

一个过程或函数在其定义或说明中有直接后简介调用自身的一种方法

递归问题的特点：

一个问题可被分解为若干层简单地子问题

子问题和其上层问题的解决方案一致

外层问题的解决依赖于子问题的解决

递归结构：

递归结构包括两个部分：递归结束条件和递归体。

递归结束条件：什么时候不调用自身方法。如果没有条件，将陷入死循环

递归体：什么时候需要调用自身方法

递归函数：

在程序运行过程中，优势需要调用程序本身，此时可以使用递归

注意：在程序中，能不使用递归就不使用。使用递归回家打资源的消耗，如果递归层次较深，会造成栈溢出。比如输出某个磁盘目录下所有文件名称。

多重循环：

任何两种循环都可以相互嵌套

外层循环变量变化一次，能蹭循环变量要变化一遍

方法：

定义方法指定形参，调用方法指定实参

方法调用是要求形参实参要求个数相同，类型匹配

方法重载：方法名相同，参数不同。

数组：

数组是形同类型数据的有序集和

相同类型的若干个 数据，按照一定先后次序排列组合而成的。

其中，每一个数据称作一个数组元素

每个数组元素可以通过一个下表来访问它们

数组的特点：

其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。

其元素必须是相同类型，不允许出现混合类型。

数组中的元素可以使任何数据类型，包括基本类型和引用类型。

数组属引用类型。

注意：

声明一个变量就是在内存空纪检划出一块合适的空间

声明一个数组就是在内存空间划出一串连续的空间

数组只有一个名称，即标识符

元素下标标明了元素都可以通过下标来访问

数组长度固定不变，避免数组越界

如何使用数组

1，声明数组 int []a;(告诉计算机数据类型是什么)

2，分配空间 a=new int[5]（告诉计算机分配几个连续的空间）

3，赋值 a[0]=8（）

4，处理数据 a[0]=a[0]*10

数组的创建方式：

1,int [] arr; arr=new int[5];

2,声明并申请空间int [] arr=new int [5]

3,声明数组并赋值int [] arr2=new int[]{1,2,3,4,5}

数组初始化：

动态初始化：数组定义与为数组元素分配空间并赋值的操作分开进行int a[]=null;a=new int[3];

静态初始化：除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值int [] a={3,5,7}

数组元素的默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

数组相当于数据结构的一种实现，很多数据在进行存储的时候需要使用数组。

数据结构：线性表，非线性表，树，队列，栈，图

2021年2月6日

原码：

原码是指奖最高位作为符号位（0表示正，1表示负），其他数组位代表数值本身的绝对值的十字表示方式

数字6在计算机中原码表示为 ：0000 0110

数字-6在计算机中原码表示为：1000 0110

反码：

反码表示规则为：如果是正数，则表示方法和原码一样，如果是负数，则保留符号位1，然后将这个数字原码按照每位取反，则得到这个树的反码表示形式

数字6在计算机中反码就是它的原码：0000 0110

数字-6在计算机中反码为：1111 1001

补码：

补码是计算机表示数组的一般方式，其规则为：如果是正数，则表示方法和原码一样，如果是负数，则将数字的反码加上1（相当于将原码数值安慰取反然后在对低位加1）

按位取反：

先按位取反，然后再加1，然后取补码：0000 0100的按位取反是-5

得到0-5之间的随机数：

int i=(int)(Math.random()*6);

装饰者模式

import java.util.Scanner;

//创建文件扫描器对象，System.in表示的是标准输入，从控制台读取数据（装饰者模式）

Scanner sc=new Scanner(System.in);

String str=sc.nextLine();

System.out.println(str);

//注意：每次读取回来的值都是字符串类型，需要进行类型转换

Switch多分支结构：

1，每个case模块中要添加break，防止多次匹配

2，如果多个case中处理的逻辑代码的功能一直，可以考虑只在最后添加一次处理

3，default表示默认选项，当所有的case并不匹配的时候，会执行此选项

4，default可以有，也可以没有。

Switch 和多重if选择结构

相同点：都是用来处理多分支条件的结构

不同点：switch选择结构

只能处理等值条件判断的情况，而且条件必须是整型

变量或字符型变量或字符串

多重if选择结构

没有switch选择结构的限制，特别适合某个变量处于某个连续区间时的情况

面向对象：

面向过程：事务比较简单，可以用现行的思维去解决

面向对象：事务比较复杂，使用简单地线性思维无法解决。

类是对象的一个抽象，对象是类的实例化。（面试金句）

对象：用来描述客观事物的一个实体，有一组属性和方法构成

方法：对象执行的操作。对应逻辑代码块在类里面叫做方法，逻辑代码块写在类外面叫做函数

对象和类对的关系：

特殊到一般，具体到抽象

类可以看成一类对象的模板，对象可以看成该类的一个具体实例

类是用于描述同意类型的对象的一个抽象的概念，类中定义了者类对象所应具有的静态和动态属性

类的属性

属性：field，或者叫成员变量

属性用于定义该类或该类对象包含的数据或者说静态属性。

属性的作用范围是整个类体

在定义成员变量时可以对其初始化，如果不对其初始化，java使用在默认的值对其初始化

属性定义格式：修饰符 属性类型 属性名== 默认值

java中方法参数传递是：值传递。

2021年2月7日

while循环

在循环刚开始时，会计算一次“布尔表达式”的值，若条件为真，执行循环体，而对于后来每一次额外的循环，都会在开始前重新计算一次

语句中应有使循环趋向于结束的语句，否则会出现无限循环------死循环

需要四部分：初始化（变量的初始化），条件判断（必须要求返回true或者false）循环体（具体的要执行的逻辑代码），迭代变量（促使此循环结束）

2021年2月8日

break和continue

在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句。（break语句用于多支语句switch中）

continue语句用在循环语句体中，用于终止某次循环过程，即图熬过循环体尚未执行的语句，接着进行下一次是否执行循环的判定。

使用场合

break可用于switch结构和循环结构中

continue只能用于循环结构中

作用

break语句终止某个循环，程序跳转到循环块外的下一条语句。

continue跳出本次循环，进入下一次循环

return--跳转语句

return语句从当前方法退出，返回到调用该方法的语句处，并从该语句的下条语句继续执行程序

返回语句的两种格式

return expersion

返回一个值给调用该方法的语句

返回值的数据类型必须和方法声明中的返回值类型一致或是精度低于声明的数据类型

return

当方法声明中用void声明返回类型为空时，应使用这种返回类型，它不返回任何值

有两种用途：返回方法的返回值和终止当前程序

Object类

一个类如果没有使用extends显性的继承另一个类，那么这个类就继承Object类

public class Persion{

}等同于

public class Persion extends Object{

}

对象的比较“==”和“equals”

”==“是比较两个基本类型变量的值是否相等

比较两个引用类型的值即内存地址是否相等，即是否指向同一个对象

“equals（）”

俩对象的内容是否一致

注意：自定义类必须重写equals（），否则其对象比较结果总是false

2021年2月10日

多态：

对于不同对象接收到同一指令，可以进行不同的处理。

当不同对象，调用同一方法，每个对象具体子类实现，都是不同的。

自我解释（多态）：对于同一个指令（调用同一个名称的方法），不同对象给予不同的反应（不同的方法实现）。

规范（多态实现的前提）：

1，必须要有继承关系

2，子类方法必须重写父类的方法（没有继承不需要重写）

3，父类引用指向子类对象

使用多态实现思路

编写父类

编写子类，子类重写父类方法

运行时使用父类的类型，子类的对象

实现多态的两种形式：

使用父类作为方法形参实现多态

使用父类作为方法返回值实现多态。

三要素：继承---重写-=-父类引用指向子类对象

多态的目的：

为了提高代码的扩展性和维护性

方便代码逻辑编写。

多态两种变现形式：

父类作为方法的参数

父类作为方法的返回值类型

当父类需要转换成子类的时候，要进行强制转换，但是在强制转换之前一定要先判断父类引用指向子类对象到底是谁，如果无法确定，在运行过程中可能出错。当子类对象需要向父类转换的时候，自动转换，不需要强制转换。

2020年2月12日

类型转换

向上转型----------子类转换为父类，自动进行类型转换

向下转型------------父类转换为子类，结合instanceof运算符进行强制类型转换

实现多态两种方式

使用父类作为方法形参实现多态

使用父类作为方法返回时实现多态

使用多态的好处

多态可以减少类中代码量，可以提高代码的课扩展性和可维护性

引用变量的两种类型：

编译时类型（模糊一点，一般是一个父类）有声明时的类型决定

运行时类型（运行时，具体是哪个子类就是那个子类）由实际对应的对象类型决定

多态存在要有三个必要条件：要有继承，要有方法重写，父类引用指向子类对象。

代码块

概念：使用{}括起来的一段代码

分类：根据位置可分类

普通代码块-->直接在方法或语句中定义的代码块

构造代码块-->直接写在类中的代码块

注意：每次代码运行的时候会将构造代码块中的代码添加到构造方法的前面，构造代码块中的代码会添加到每一个构造方法中，当使用this的时候不会添加。

静态代码块-->使用static声明的代码块

在程序载入的时候优先执行，数据库连接等其他提前需要准备好的代码块会方法static代码块

是在类初始化时执行，不是在创建对象时执行。如果希望加载后，对整个类进行某些初始化操作，可以使用static初始化块

同步代码块-->多线程使用，用来给共享空间进行加锁操作

执行顺序：静态代码块-----构造代码块-----普通代码块

package：包，对应到文件系统就是多级目录

为了解决两个问题：

1，文件同名问题

2，为了方便管理类，将处理功能的代码方法同一个目录下使用

java.lang

包含一些java核心类，如String ，Math,Integer ,System和Thread，提供常用功能，不需要手动导入，自动加载。

java.awt

包含构成层抽象串口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用城促的图

形成用户界面GUI

java.net（网络包）

包含执行与网络线管的操作的类

java,io（输入输出流）

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

java.util（工具包）

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

import：

当需要引入非lang包的其他java类的时候，需要使用import工具。如果不适用import每次在使用某个类的时候要将类的完全限定名都加上才可以使用，太过于繁琐

import static（静态导入）：静态导入的作用，用于指定哪个类的静态属性

如何使用：import static java.lang.Math;//导入MATH类的所有静态属性

2020年2月16日

封装：

将类的某些信息隐藏在内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问

好处：只能通过规定方法访问数据，隐藏类的实现细节，方便加入控制语句。方便修改实现

面向对象的封装可以用一句话来概述：将类中的属性设置为私有属性，提供公有的外部方法供程序进行调用，可以实现丰富的细节操作。

广义封装：可以将完成特定功能的代码块封装成一个方法

程序设计要追求高内聚，低耦合，高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用

封装步骤：1，修改属性的可见性---设为private

2，创建公有的getter/setter--用于属性的读写

3，在getter/setter方法中加入属性控制语句---对属性值的合法性进行呢判断

定义类的时候需要包含一下组建：

私有属性，构造方法（无参构造方法和自定义构造方法），set/get方法，普通方法

面向对象的三大特征（还有个抽象）：

继承inheritance：

子类 父类

子类可以从父类继承属性和方法

子类可以提供自己单独的属性和方法

封装/隐藏encapsulation

对外隐藏某些属性和方法

对外公开某些属性和方法

多态polymorphism

为了适应需求的多种变化，时代吗变得更加通用

面向过程只有封装性（功能的封装，而没有数据的封装）没有继承和多态

使用访问控制符，实现封装：

成员变量/成员方法，访问权限共有四种：

public公共的：

可以被项目中所有的类访问

protected受保护的：

可以被这个类本身访问：同一个包中的所有其他类访问：被它的子类（同一个包以及不同包中的子类）访问

default/friendly默认的/友好的（包可见性）

被这个类本身访问，被同一个包中的类访问

private：可以被当前类访问（类可见性）

类的访问权限只有两种

public公共的：可被同一项目所有类访问。必须与文件同名

default/friendly：可被同一个包中的类访问

	同一个类	同一个包	子类	所有类
private	*
default	*	*
protect	*	*	*

封装的要点：

类的属性处理：

1，一般使用private，（除非本属性确定会让子类继承）。

2，提供相应的set/get方法来访问相关属性，这些方法通常是public，从而提供对属性的读取操作。（注意Boolean变量的get方法是用：is开头）

一些只用于本类的辅助性方法可以用private，希望其他类调用的方法用public

总结：

方法调用中的参数传递

--基本数据的类型的参数传递：不能改变参数的值

--引用数据类型的参数传递：不能改变参数的值

this

this代表当前对象自身的引用（必须new）

this可以修饰属性，区别成员变量和局部变量

this修饰方法

this修饰构造方法（必须是第一条语句）

static

static变量：只有一份，属于类，可以类名。static变量

static方法：类名，static方法，不能出现this和super

static代码块：只执行一次，最早执行的（类第一次调用）

package import

包:作用

导入：import com.bjsxt.oop.*;

静态导入：import static java.lang.Math.Pi;

方法参数的值是否改变：

方法中的参数列表叫做形式参数，没有具体的值，只是为了方便在方法体中使用。

调用方法的时候实际传入的值叫实际参数，代表具体的数值，用来替换在方法体重代码逻辑的值进行运算。

注意：

形式参数的变量名称也是局部变量

当方法的参数值是基本数据类型的时候，不会改变原来的值

当方法的参数值是引用类型的时候，如果改变了该引用类型的值，会改变原来对象的值

java中的传递是值传递。

继承：

表示父类跟子类之间的关系

类是对对象的抽象，继承是对某一批类的抽象，从而实现对显示世界更好的建模

提高代码的复用性

子类是父类的扩展，超类，父类，（基类，子类，派生类）子类

当两个类或者多个类具备相同的属性和方法的时候，可以提取出来，变成父类，子类可以继承

子类和父类是is a 的关系

使用：

1，使用继承的时候需要使用extends关键字

2，使用继承关系之后，父类中的属性和方法都可以在子类中进行使用（非私有属性和非私有方法）

3，java中是单继承关系

super关键字

super是直接父类对象的引用

可以通过super来访问父类中被子类覆盖的方法或属性

普通方法

没有顺序限制，可以随便调用

1，使用继承的时候需要写extends关键字

2,只用继承关系之后，父类中的属性和方法都可以在子类中进行使用

super：是直接父类对象的引用

可以在子类中调用父类中被子类覆盖的方法，super（）.父类方法名称

当super在普通方法中使用的话，可以任意位置编写

当super在构造方法中使用的话，会调用父类的构造方法，一定要将super放在第一行

在构造方法中super关键字和this关键字不能同时出现

super和this都不能在static方法中

父类中私有的属性和方法都不能被调用，包括构造方法

子类的构造方法中都会默认使用super关键字调用父类的构造方法，因此在定义类的时候无论自己是否自定义了其他构造方法，最好将无参构造方法写上。

如果构造方法中显式的指定了super的构造放啊，那么无参的构造方法就不会被调用

构造函数中：

任何类的构造函数中，若是构造函数的第一行代码没有显式的调用super（），那么java默认都会调用super （）；作为父类的初始化函数。所以加不加super（）都无所谓

不能被继承的：不能直接访问private成员，子类与父类不在同一包使用默认访问权限，，构造方法

多重继承关系的初始化顺序：父类属性-----》父类构造放啊发-----》子类属性-----》子类构造方法

注意：继承与真实直接类似，继承是代码重用的一种方式，将子类共有的属性和行为放到父类中。

小结：

通过继承可以简化类的定义，实现代码的重用

子类及承诺父类成员变量和成员方法，但不继承父类的构造方法

定义一个类时，没有调用extends，则它的父类是：java.lang.Object

方法的重写：

在子类中可以根据需要对从基类中继承来的方法进行重写

重写方法必须和被重写方法具有相同方法名称，参数列表和返回类型

重写方法不能使用比被重写方法更严格的访问权限（由于多态）

父类静态方法子类可以进行调用，但是子类不可以重写

2020年2月17日：

抽象类：

java中的对象是对现实世界的具象化，但是在现实世界中，某些并不具备实例化的意义，因此可以定义为抽象类

1，创建抽象类的时候需要添加abstract的关键字

2，不能进行实例化，也就是不能new对象

3，抽象类中的某些方法需要子类进行更丰富的实现，父类实现没有意义，此时可以将抽象类中的方法定义为抽象方法，没有具体的实现，只包含方法名称，返回值，参数列表，访问修饰符。

4，使用abstract关键字修饰的方法叫做抽象方法，可以不写方法的实现

5，子类在继承父类的时候，必须要将父类中的抽象方法进行实现或者将子类也定义为抽象类

6，有抽象方法的一定是抽象类，但是抽象类中不一定包含抽象方法

抽象类没有实例化，抽象方法没有方法体

抽象方法必须在抽象类里

抽象方法必须在子类中被实现，除非子类是抽象类

final关键字

修饰变量：表示变量的值不可变

修饰方法：表示方法不可以被重写

修饰类：表示类不可以被继承

java中用final修饰的词叫做常量

static是静态的意思，表示归属于整个类

局部变量和成员变量：

区别：

生命为止不同：类中，方法中

作用范围不同：当前类的方法 当前方法

不同的方法中及时有同名的局部变量，没有关系互不影响，建议相同

内存存放的位置的：栈内存中 堆内存中

成员变量有默认值：局部变量没有默认值

局部变量：

定义在方法中的变量

作用域：从定义位置开始到方法结束

注意：局部变量只能在当前方法中使用，其他地方无法使用。

成员变量：

定义在方法外，类内的变量（全局变量）

成员变量包含初始值： int 0 String null boolean false

作用域：在整个类内

引用类型：

java中的对象和数组是通过引用对其操作的

引用可以来理解为一种受限的指针

指针是可以进行与正数做加减运算的，两个指针之间也可以进行大小比较运算和加减运算。引用不行，只能进行赋值运算。

引用就是一个变量或对象的别名（引用的本质就是一个对象）；指针是一个段内存空间的地址（指向存储一个变量值的空间或一个对象的空间）

内存分析

栈：存放：局部变量

先进后出，自下而上存储

堆：

存放new出来的对象

需要垃圾回收器来回收：System.gc()

方法区：

存放：类的信息（代码），static变量，字符串常量

构造方法：

创建对象的时候默认会调用构造方法来创建对象，（从堆中开辟空间），可以完成成员变量的某些初始化操作

构造方法的语法：

方法名称：构造方法的方法名称必须跟类的名称保持一致

访问修饰符：

形参：可以用户自定义添加，跟方法的普通参数一样

方法体：完成对象的初始化功能

返回值：没有返回值

注意：

1，创建完类之后，如果没有手动调用构造方法，会有一个磨人的无参的构造方法供调用

2，当用户自定义了构造方法之后，默认的无参构造方法就不能够使用了，必须要手动定义无参构造方法

3，同一个类中可以包含多个同名的构造方法

重载：在一个类中可以包含多个重名的方法，但是注意方法的参数列表不能相同

三个方法不同：参数个数不同，参数的类型不同，参数的顺序不同

注意：

一般构造方法都会进行重载（一个类可能包含多个属性值，当只需要给部分属性初始化的时候需要调用不同的方法）

构造器：

构造器定义：constructor构造方法

一个在创建对象时被自动调用的特殊方法

构造器作用：

为对象进行初始化（成员变量）工作

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

构造器的方法名必须和类名一致

构造器虽然有返回值，但是不能定义返回类型（返回值的类型肯定是本类），不能在构造器里调用return

通过new关键字调用

如果我们没有定义构造器，则系统会自动定义一个无参的构造方法。如果已定义则编译器不会添加无参数构造方法

与普通方法一样，构造方法也可以重载

this关键字：

this的作用：

this表示的是当前对象本身，表示当前对象的引用。

构造方法：当构造方法中的参数名称跟类的成员变量名称一样的时候，可以使用this代表当前对象

注意：有了this之后可以将构造方法的参数跟成员变量保持一致

普通方法中：

当多个普通方法之间需要调用的时候，可以使用this来进行调用，值的是当前对象的其他方法

成员变量的使用：

当方法中对的参数名称跟成员变量保持一致的时候，使用this变量名称，表示的是对象的值，而使用变量名称表示形参列表中的值

static关键字：

修饰成员变量的时候，表示静态成员变量或者叫类变量

普通变量在使用的时候必须要通过对象名进行调用

类变量或者静态变量可以使用对象名调用也可以使用类名进行调用

修饰方法的时候，表示静态方法或者叫类方法：

普通方法在使用的时候，必须要通过对象名进行调用

类方法或者静态方法可以使用类名，也可以使用对象名

在类中，用static声明的成员变量称之为静态变量，或叫做：类 属性，类变量。它为该类的公共变量，属于类，被该类的所有实例共享，在类被载入时被显式初始化。对于该类的所有对象来说，static成员变量只有一份。被该类的所有对象共享，可以使用“对象。类属性”来调用。不过，一般都是用“类名。类属性”

static变量置于方法区中

用static声明的方法为静态方法

不需要对象，就可以调用（类名。方法名）

在调用该方法时，不会将对象的引用传递给它，所以在static方法中不可访问非static的成员，静态方法不能以任何方式引用this和super关键字（一般工具类的方法定义为static）

静态变量，在创建对象之前被初始化，或者说在类被载入之前进行初始化

静态变量被所有对象共享，属于公共变量，对象和类都可以直接调用，但是推荐使用类来调用

成员变量放在堆中，而静态变量放在方法区中静态区

静态变量不能定义在静态方法中

静态方法可以再非静态方法中进行调用

静态方法中不能直接调用非静态方法

static修饰与非static修饰的区别：

	static，非private修饰	非static，private修饰
属性	类属性，类变量	实例属性，实例变量
调用对象	类名。属性 类名。方法（） 对象。属性 对象。方法（）	对象。属性 对象。方法（）
方法/归属	类方法/类	实例方法/单个对象

2020年2月21日：

java异常及常用类：

在程序运行过程中，如果处理异常的部分包含finally的处理，那么无论代码是否发生异常，finally中的代码总会执行

finally包含哪些处理逻辑：

1，IO流的关闭操作一般设置在finally中

2，数据库的连接关闭操作设置在finally中

2020年2月23日：

异常处理机制：

throws：声明异常

在异常情况出现的时候，可以使用try。。。。catch。。。finally的方式对异常进行处理，除此之外。可以将异常向外抛出由外部进行处理

,1，在方法调用中，可以存在N多个方法之间的调用，此时加入每个方法都包含了异常情况那么就需要在每个方法中都进行try。catch，另外一种比较简单地方式就是在方法的最外层调用处理一次即可

使用throws的方法，对所有执行过程中的所有方法常出现的异常进行同意几种处理

2，如何判断是否使用throws还是使用try。。catch

最稳妥的方式是在每个方法中都进行异常处理

最偷懒的情况就是判断在整个调用的过程中，外层调用的方法是否对异常的处理，如果有，直接使用throws，如果没有就要使用try。。catch

throw：抛出异常：

public static void test() throws Exception{

String gender="123";

if (gender.equals("man")){

System.out.println("man");

}else if (gender.equals("woman")){

System.out.println("woman");

}else{

throw new Exception("性别出现错误");

}

}

//注意throw要和throws一起使用处理跑出的异常

try {

test();

}catch (Exception e){

e.printStackTrace();

}//方式1，：调用者处理异常

public static void main(String[] args){//main方法声明的异常，由java虚拟机处理，方式2：调用者继续声明异常

public static void test() throws Exception{//声明异常，多个异常用逗号隔开

自定义异常：

在java的API中提供了非常丰富的异常类，但是在某些情况下不满足我们的需求，此时需要自定义异常

步骤：

1，继承Exception类

2，自定义实现构造方法

3，需要使用的时候，使用throw new自定义异常的名称

什么时候需要自定义异常？

一般情况下不需要，要求异常格式规范必须要自己去实现的

小结：

异常分为Checked异常和运行时异常

--checked异常必须要捕获或者声明抛出

运行时异常不要求必须捕获或者声明抛出

try-catch-finally中存在return语句的执行顺序

finally语句块中语句不执行的情况

throw和throws关键字的区别

常用类：

包装类：

包装类是将基本类型封装到一个类中包含属性和方法，方便对象操作，包装类位于java。lang包中

使用：在使用过程中，会涉及到自动装箱和自动拆箱

装箱：将基本数据类型转换成包装类（基本类型就自动的封装到与它相同类型的包装中）

如：integer i=100；

本质上是，编译器编译时为我们添加了：

integer i=integer.valueOf（100）;

拆箱：将包装类转换成基本数据类型(包装类)

int a=10;

Integer i=new Integer(10);

Integer i2=Integer.valueOf(a);

int i3=i.intValue();

System.out.println(a==i);

基本数据类型转换为包装类：

integer intValue=new integer(21);

integer intValue=new integer("21");

integer intValue=integer.valueOf("21");

包装类转换成基本类型

integer integerID=new integer（25）；

int intID=integerID.intValue（）；

基本数据类型和包装类的自动转换：

integer intObject=5;

int intValue=intObject;

包装类并不是用来取代基本类型的

String类位于java.lang包中，具有丰富的方法。计算字符串的长度，计较字符串，提取字符串

常量池在1.7之后放置在堆空间之中

字符串的使用：

1，创建

String str="abc";

String str2=new String("abc");

两种方式都可以，只不过第一种使用比较多

2，字符串本质

字符串的本质就是字符数组或者叫字符序列

String类使用final修饰，不可以被继承

使用equals方法

String类的常用方法（1）

char charAt(int index)

返回字符串中第index个字符

Boolean equals(String other)

如果字符串与other相等，返回与other相等（忽略大小写），则返回true

intindexOf(String str) lastindexOf（String str,int idx）

int length()

返回字符串的长度。

String replace（char oldCahr,char newChar）

返回一个新串，它是通过用newChar替换此字符串中出现的所有oldChar而生成的

String类的常用方法（2）

boolean startWith(spring prefix)

如果字符串以prefix开始，则返回true

Boolean endsWith(string prefix)

如果字符串以prefix结尾，则返回true

string subString(int begainIndex,int endIndex)

返回一个新字符串，该串包含从原始字符串beginIndex到串尾或endIndex-1的所有字符

String s="abcdefghijk";

//在截取字符串的时候，需要注意是在左闭右开区间

System.out.println(s.substring(3));

System.out.println(s.substring(3,5));

String toLowerCase()

返回一个新字符串，该串将原始字符串中的所有大写字母改成小写字母

String toUpperCase（）

返回一个新字符串，该串将原始字符串中的所有小写字母改成大写字母

String trim()

返回一个新字符串，该串删除了跟原始字符串头部和尾部的空格

string是一个不可变对象，核心是value[]的引用不可变，数组中的值可变

对于 == 来说比较两个对象时，实质上是检查对象的内存地址是否相等

，==运算符进行比较时，将检查这两个String变量是否引用了同一个字符串，如果它们引用的是不同的字符串，其返回值为false，而不管其字符串内容是否相等。

equals来说只要字符串相等其返回值都为true，这也是为什么我们在比较字符串时首选的方法是用equals来比较。

那么有没有一种方法能让==运算符适用于字符串的比较呢？

答案是有的，用字符串扣留机制能实现 == 与equals产生相同的比较结果。字符串扣留功能确保了两个String对象不能封装同一个字符串，因此所有的String对象均封装惟一的字符串。这就意味着，如果两个String变量引用的字符串相等，那么这两个引用也必定相等。换一种说法就是，如果两个String变量包含不相等的引用，它们引用的字符串也必定不相等。如何安排才能使得所有的String对象封装惟一的字符串呢？这只需要为每一个String对象调用intern方法。

还是上面的例子，在str1 += str2;后加上

str1=str1.intern(); str3=str3.intern();

最后str1 == str3;表达式返回结果为true。这就是字符扣留的功能实现，它能减少用户程序中存储String对象需要的存储量，实现== 替代equals()方法。

接口interface：

java中的继承关系是单继承，如果拥有多个父类的时候，可以考虑使用接口进行实现java中的接口具备广泛的使用：

使用interface来修饰

接口中可以包含多个方法，且方法跟抽象类中的抽象方法一致，可以不写实现，子类要实现的时候必须要实现代码逻辑

子类实现接口使用implements关键字

必须要知道的接口特性

1，接口中的所有方法都是抽象方法，不能包含方法的实现

2，接口中的所有方法的访问修饰权限都是public，不写并不是默认访问权限而是public

3，接口不能被实例化

4，接口中的子类必须要实现接口中的所有方法，跟抽象类有所不同，抽象类中的抽象方法必须要被子类实现

5，子类可以拥有实现多个接口

6，接口中的变量都是静态常量（必需要赋初值），如果变量没有使用static关键字修饰，他也表示静态常量。不用final关键字修饰，也是静态常量

7，接口中的方法和常量无论是否添加public修饰，默认的权限有且仅有一个，就是public

接口的使用：

1，接口代表一种能力，体现在接口的方法上。可以定义N多个方法，子类在进行实现的时候，必须要实现这些方法，，将这些方法进行实现，就意味着具体了方法的能力

关心实现类有何能力，不关心实现细节

一个人可以具有多项能力，一个类可以实现多个接口

接口是一种约定：体现在接口名称和注释上：1，有些接口只有名称，2，方法的实现方式要通过注释来约定

面向接口编程：

程序设计时面向接口的约定而不考虑具体实现

为什么需要接口？接口和抽象类的区别？

接口就是比“抽象类还抽象的抽象类”，可以更加规范的对子类进行约束。全面专业的实现了：规范和具体实现的分离。

接口就是规范，定义的是一组规则，体现了现实世界中“如果你是。。。则必须能。。。”的思想。

接口的本质是契约，就像我们人间的法律一样，制定好后大家都遵守

项目的具体需求是多变的，我们必须以不变应万变才能从内容的开发，此处的“不变”，就是“规范”，因此，我们开发项目往往都是米娜想接口编程！

接口相关规则：

接口中所有的方法都是抽象的

即使没有显式的将接口中的成员用public表示，也是public访问类型的

接口中变量默认用public static final标示，所以接口中定义的变量就是全局静态变量

可以定义一个新的接口，用extends去继承一个已有的接口

可以定义一个类，用implement去实现一个接口中所有方法

可以定义一个抽象类，用implement去实现一个接口中部分方法

如何定义接口？

格式

【访问修饰符】interface 接口名【extends 父接口 1，父接口2】{

常量定义 //总是public static final

方法定义 //总是：public abstract

}

如何实现接口

子类通过implements来实现接口的规范

接口不能创建实例，但是可用于声明引用变量类型

一个类实现了接口，必须实现接口中所有的方法，并且这些方法只能是public的。

java的类只支持单继承，接口支持多继承

c++支持多继承，java支持单重继承

c++多重继承的危险性在于一个雷肯能继承了同一个方法的不同实现，会导致系统崩溃

java中，一个类只能继承一个类，但同时也可以实现多个接口，既可以实现多重继承的效果和功能，也比米哦按多重继承的危险性

class Student extends Person implement Runner ,Flyer

注意：extends必须位于implements之前

抽象类和接口的区别：

1，抽象类中的方法可以有抽象方法，也可以有普通方法，但是接口中只能包含抽象方法

2，抽象类需要使用abstract关键字来修饰，而接口使用interface关键字来修饰

3，子类使用extends关键字来继承抽象类，接口使用implements来实现接口

4，子类继承抽象类的时候必须要实现所有的抽象方法，普通方法可以不重写，而接口中的所有方法必须实现

5，抽象类中可以定义成员变量，而接口中只能定义静态常量

6，抽象类在实现的时候是单继承，而接口时多继承

7，抽象类和接口都不能实例化，但是抽象类中可以有构造方法，而接口中不能有构造方法

8，抽象类中可以实现接口，并且不实现接口中方法，而接口只能继承接口，不能实现接口

注意：在实际项目开发中，如果可以使用接口，尽量使用接口，将单继承的父类留在最关键的地方

内部类--成员内部类

一个java文件中可以包含多个，class，但是只能有一个public class，如果一个类定义在另一个类的内部，此时可以称之为内部类

使用：定义和创建内部类的时候，跟之前的方法不一样，需要在内部类的前面添加外部类来进行修饰

innerClassDemo.InnerClass inner=new InnerClassDemo().new InnerClass();

特点：1，内部类可以方便访问外部类的私有属性

2，外部类不能访问内部类的私有属性，但是如果创建了内部类的对象，此时可以在外部类中访问私有属性

3，内部类中不能定义静态属性

4，当内部类和外部类具有相同的私有属性的时候，在内部类中访问的时候可以直接访问内部类的属性，如果需要访问外部类的属性，那么需要添加外部类类名。this。属性（外部类类名。属性--为静态属性）

注意事项：1，外部类不能直接使用内部类的成员和方法

2，如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，需使用this关键字

分类：

匿名内部类：当定义了一个类，实现了某个接口的时候，在使用过程中只需要使用一次，没有其他用途，其实考虑到代码简洁，可以考虑不创建具体的类，而采用new interface（）（添加未实现的方法），就叫做匿名内部类。适合只需要使用一次的类，安卓使用的比较多

public class NoNameClassDemo {

//这是一个main方法，程序的入口

public static void main(String[] args) {

System.out.println("有一万行代码");

new Thread(new Runnable() {//实际上new了一个接口的实现

@Override

public void run() {

}

});

System.out.println("有一万行代码");

}

}

静态内部类：在内部类中可以定义静态内部类，使用static关键字进行修饰，使用规则

语法：new外部类类名。内部类（）。方法名

外部类类名。内部类 内部类对象名=new 外部类类名。内部类类名

public class StateClass {

private int id;

public void test(){

System.out.println("test");

}

static class InnerClass{

private String name ;//

public void show(){

System.out.println("show");

}

}

//这是一个main方法，程序的入口

public static void main(String[] args) {

InnerClass innerClass=new StateClass.InnerClass();

}

}

方法内部类：

方法内部类是指：将内部类定义在外部类的方法中

注意事项：

1，方法内部类不能在外部类的方法以外的地方使用，所以方法内部类不能使用访问控制符和static修饰符

使用时应注意，只能在方法中创建对象，因此class的作用就是当前方法

public class Method {

public void show(){

System.out.println("show");

class Im{

private String name;

public void test(){

System.out.println("test");

}

}

}

}

总结：抽象类和抽象方法

----抽象类不能被实例化

----可以有0-多个抽象方法

----非抽象类必须重写父类的所有抽象方法

final修饰符

----修饰的类，不能在被继承

----修饰的方法，不能被子类重写

----修饰的变量将编程常量，只能在初始化的时候进行赋值

继承：

符合is --a关系

使用extends关键字

代码复用

方法重写的规则

方法名相同

参数列表不同

返回值类型相同或者是其子类

访问权限不能严与父类

super关键字来访问父类成员

super只能出现在子类的方法和构造方法中

super调用构造方法时，只能是第一句

super不能访问子类的private成员

垃圾回收机制：

对象空间分配：

使用new关键字创建对象即可

对象空间的释放：

传统的c/c++语言，需要程序员负责回收一经分配内存。显式回收垃圾回收的缺点：

程序忘记及时回收，从而导致内存泄漏，降低系统性能

程序错误回收程序核心类库的内存，导致系统崩溃

-java语言不需要程序员直接控制内存回收，有JRE在后台自动回收不在使用的内存，称为垃圾回收机制

可以提高编程效率

保护程序的完整性

其开销影响性能。java虚拟机必须跟踪程序中有用的对象，确定哪些是无用的。

垃圾回收机制关键点：

垃圾回收机制只回收JVM堆内存里的空间对象

对其他物理连接，比如数据库连接，输入流输出流，socket连接无能为力

现在的JVM有多重垃圾回收实现算法，表现各异

垃圾回收发生具有不可预知性，程序无法精确控制垃圾回收机制执行

可以将对象的引用变量设置为null，按时垃圾回收机制可以回收该对象

程序员可以通过system。gc （）或者Runtime.getRunTime().gc（）来通知系统进行垃圾回收，会有一些效果，但是系统是否进行垃圾及回收依然不确定

垃圾回收机制回收任何对象之前，总会调用它的finalize()方法（如果覆盖该方法，让一个新的引用变量重新引用该对象，则会重新激活对象）。

永远不要主动调用某个对象的finalize()方法,应该交给垃圾回收机制调用。

异常：

注意：

1，相同的代码在运行的时候，根据输入的参数或者操作不同，有可能会发生异常，有可能不会发生异常，应该在写代码的过程中尽可能的保持代码的正确性，不要到处是bug

2，如果要解决代码中出现的异常，需要天剑非常复杂的代码逻辑来进行判断，回事代码变得非常臃肿，因此，使用异常机制来处理异常问题

3，在异常的处理过程中，要尽可能的将详细的异常信息进行输出，e.printStackTrace();打印异常的对战信息，可以从异常信息对最后一行进行追踪

异常处理的方式;

捕获异常：try{代码逻辑}catch(Exception e){异常处理逻辑}；

try{代码逻辑}catch（具体的异常Exception e）{异常处理逻辑}catch（具体的异常）；

可以针对每一种具体的异常做相应的更丰富的处理

注意：当时用多重的catch的时候，一定要注意相关异常的顺序，像子类放在最前面的catch，父类

放在后面的catch

执行过程中可能出现的情况：

1，正常执行，只执行try中的代码

2，遇到异常情况，会处理try中异常代码之前的逻辑，后面的扩机不会执行，最后指向catch中的

3，使用多重catch的时候，会遇到异常子类不匹配的情况，此时依然会报错，因此建议在catch的最后将异常的父类写上。

声明异常：

抛出异常：