202402150597

第一章

1.Java是一门简单的、面向对象的优秀编程语言,它具有跨平台性、可移植性、安全性、健壮性、编译和解释性、高性能和动态性等特点,支持多线程、分布式计算与网络编程等高级特性。

2.Java面向对象程序设计方法的特点:抽象、继承、多态。

3.JDK:是Java并发环境和运行环境，是所有Java应用程序的基础，它包括一组API和JRE，API是构建Java应用程序的基础，而JRE是运行Java应用程序的基础。

JVM：是一个虚拟的用于执行字节码文件的虚拟计算机，负责解释运行Java字节码文件，边解释边运行。

JRE:是Java开发的运行环境，试运行Java应用程序的基础，包含了JVM标准实现及Java核心类库。

4.JRE是Java程序的运行环境，JDK是Java开发工具包，包含JRE。JVM是Java能够跨平台的东西，JDK是执行读取命令的。

三者关系：JDK（开发工具，JRE（Java基础类库，JVM))

第二章

2.1 变量与常量

2.1.1关键字和保留字

2.1.2标识符与命名规范

1.标识符只能由字母、数字、下画线、美元符号组成,并且不能以数字开头。

2.Java标识符大小写敏感,长度无限制。

3.标识符不可以是Java关键字和保留字。

2.1.3数据类型

2.1.4变量的定义与赋值

1.变量必须先声明再使用。变量声明的语法如下。

//声明一个变量

int a；(数据类型 变量名)

//一次声明多个变量

int num1 = 2，num2 = 3，num3 = 4；

2.声明一个变量后，必须对其赋值才能使用。

int num1 = 10;

3.变量是可以改变值的量，在声明一个变量之后，它的值就可以被改变任意次。变量名的命名需要遵守小写字母开头的驼峰规则。

2.1.5常量

1.常量:在变量声明语法前加上final关键字。变量可以改变值的量，而常量一旦被赋值，不可改变。

//声明一个常量

final double PI = 3.1415926；

2.1.6变量的类型转换

1.Java中的数据类型转换主要分为两种:自动类型转换(隐式转换)和强制类型转换(显式转换)。

2.自动类型转换，在Java中，占用字节数少的数据类型的值可以直接赋值给占用字节数多的数据类型的变量。

int num1 = 10;

double num2 = num1;

3.强制类型转换，强制性地占用字节数多的数据类型的数据转换成占用字节数少的数据类型的数据，但这个转换可能存在数据精度丢失问题。

int i = 100;

double d = (double) i; // 将int转换为double

byte b = (byte) i; // 将int转换为byte

2.1.7Scanner的使用

1.获取不同类型的变量，需要使用Scanner类

2.Scanner的实例化:Scanner scan = new Scanner(System.in）；

2.2运算符与表达式

1.运算符(算术运算符、赋值运算符、关系运算符、逻辑运算符、位运算符、三元运算符)

2.运算符的优先级

2.3 选择结构

1.if语句:

2.switch语句：一般用于做一些精确值的判断

2.4 循环结构

1.for常用于知道边界，while常用于不知道边界

例:

2.do…while循环

do{

    语句或语句块

} while

至少执行一次，之后再判断表达式是否成立，成立则再次执行循环体，否则，循环结束。

2.5 方法

1.要使用方法时，必须先声明该方法，才能在其代码中调用。

修饰符 返回值类型 方法名（参数类型 参数名1，参数类型 参数名2，...）{

//方法体；

return 返回值；

}

2.方法重载:方法名字相同，参数个数和类型不同（只在小括号即入参。）

2.6数组

1.声明数组:(1)数组的元素类型 数组名字[ ];

(2)数组的元素类型[ ] 数组名字；

2.动态初始化数组:数组名字 = new 数组元素的类型[数组元素的个数]；

2.7 JVM中的堆内存与栈内存

1.虚拟机栈:保存正在运行的方法。

堆:保存引用类型的数据实体。

对于变量来说，在哪出生就在哪里

对数据类型来说，引用类型在堆里

基本类型变量在哪（类->堆，方法->栈)

第三章

3.2 面向对象编程

1.java使用class关键字定义一个类。（public class 类名{1.成员变量2.成员方法3.构造器4.代码块5.内部类}）

2.类:是对象的抽象，代表了此类对象所具有的共属性和行为，是抽象的概念上的定义，在类的内部再定义类，里面的类叫做内部类，外面的类叫外部类。

3.对象:是类的实例。是对事物的抽象，是实际存在的事务的个体。

4.成员变量:也称字段，是类中定义的变量，用于存储对象的状态

变量的作用域:指程序代码能够访问的该变量的区域，如果超出该区域，编译会报错。

3.成员变量：在类体中定义，可以加修饰符，可以不进行初始化

局部变量:在方法体中定义，不可以加修饰符，使用前必须进行初始化。

3.3 构造方法

1.作用：初始化一个类的对象并返回这个对象的地址块

[修饰符] 方法名 ([参数列表]){

//方法体

}

2.构造器分类

3.4 this关键字

1.this: 代表了当前对象的地址，可以访问当前对象的成员变量和成员方法。(谁调用了方法就是它，解决重名的问题)

2.this只能使用于构造方法中，调用本类的构造，如果括号内有形参，则调用本类的与之相对参数的构造方法

3.5 static关键字

1.static:被static修饰的成员属于类(被它修饰的所有永远出现早)，不被static修饰的成员属于对象。

//不使用static关键字访问对象的属性:

public class Test{

public static void main(String[ ] args){

  Person p = new Person();

 p.name = "张三"; }}//调用方式:对象.成员

class Person{

String name;

int age;

}//需要先创建Person对象才能设置对象属性String name，int age

使用static

public class Test{

 public static void main(String[ ] args){

 Person.name = "张三"; }//调用方式:类.成员

 class Person{

static String name;

 int age; }//使用static关键字修饰的变量可以通过类名.属性名直接访问

2.静态方法不能使用类的非静态变量

public class Test{

int age = 18;//非静态变量

static String name = "张三";//静态变量

public static void main(String[] args){//静态方法

age = 19;//错误，静态方法不能直接访问非静态变量

name = "李四";}}

3.静态方法可以直接调用静态方法，但是调用普通方法只能通过对象的实例(属性)才能调用。

4.非静态方法必须在类的对象被创建后才能调用。可以直接访问类中的任何成员，无论是静态或者非静态。

3.静态代码块:在类被加载的时候运行且只运行一次

public class Test{

static{

System.out.println("我被调用了");//静态代码块

}

public static void main(String[] args){

}}

3.6包

1.把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用

创建包  package 包名称.子包名称

第四章

4.1 封装

1.封装:将对象的状态(成员变量)和行为(成员函数)打包在一起，并对外隐藏实现细节

(1)隐藏实现细节(2)提供公共的访问模式(3)提高了代码的复用率(4)提高了安全性

1.default(在一个包里可见，跨包不可见) protected(被包下的子类访问、给子类开通跨包）

2.get()方法获取变量的值，set()方法为变量赋值，对变量进行封装。

4.2 继承(extends)

1.继承的核心：重写方法

Java只允许类的单继承，一个类只能有一个父类，但可以有多个子类

继承的语法格式：

  [修饰类] class 子类名 extends 父类名{

//程序核心代码}

2.使用继承：子类属性一般都是新增

3.父类没有这个方法是新增，有这个方法是覆盖

4.继承中：方法能改、访问修饰符、返回值类型能改，方法名、形参列表不能改

5.父类方法是private或static修饰，不能重写

4.3 super关键字

1.super可访问父类中被子类覆盖的方法和属性。

this和super：

4.4 final关键字

1.final修饰的东西不能改变

2.final修饰的是变量名，所以是变量保存的值不变，而不是对象是体内的数据不能改变。

3.final类不能被继承，即不能子类。

4.5 object类

1.子类无法继承父类的所有成员。

2.所有的类都继承了Object类是为了让所有的类存在共性。

3.Object类中的 toString ( )方法返回该对象的字符串表示。

4.6 多态

1.多态性:一个数组中可以同时有父类对象和子类对象，运用方法也不用区分方法名

Teacher s = new Teacher();

People p = new Teacher();

2.多态是建立在继承的概念基础，父类引用指向子类对象实体的时候，JDK会把这个实体当成父类对象实体使用。

3.多态解决的问题：提高代码的复用率，提高兼容性。

4.多态的范围::仅限于成员方法，其它的不涉及多态。

5.静态方法不允许重写，成员属性、静态属性、静态方法不能覆盖，只和成员方法有关。

6.在多态中，左边是引用，右边是对象实体，编译看左边，运行看右边。

和多态无关时，编译和运行都看左边。

4.7 抽象类

1.父类的某些方法强制子类必须重写时，用抽象类机制。

2.抽象类是结果，抽象方法是原因。

3.抽象类里可以有抽象方法，也可以有非抽象方法，非抽象方法不可以有抽象方法

4.抽象类不能直接new，因为它new对象了，就调用了抽象方法，矛盾

5.抽象方法的访问修饰符不能private

6.抽象类不会因为不能new对象导致没有构造

7.静态机制解决的

 问题1：让对象和对象直接能有通讯的能力

 问题2：让某些属性，可以直接通过类名访问，简化访问，提高计算效率和空间使用率

4.8 接口

1.类无法多继承，新发明一个机制叫接口。

2.一个类通过关键字implement声明自己实现的一个或多个接口。如果实现多个接口，用逗号隔开接口名。

3，接口中方法访问权限都是public，重写时不可省略public，否则就降低了访问权限

4.接口每新增一个方法，都强制所有子类实现，解放方法是提供default机制

5.接口和类不同：接口的静态方法只能用接口名访问

6.静态属性/方法：共享的属性/方法，只有一份。

7.接口的属性是常量，不能有变量

例：String name = "ll";//省略了public static final

例：void eat();省略了public abstract

4.9 内部类

1.在一个类的内部，可以细化进行分类，且这些局部只有当前类会用到，这时使用内部内机制。

内部类是定义在另一个类中的类:

public class Test{

private int internal;

private boolean beep;

public class TimePrinter implents ActionListener{

  public void action Performed (ActionEvent event){

   if(beep)//可以访问所在的外部类的变量

  Toolkit.getDefault Toolkit().beep();}}

2.内部类分：成员内部类、静态内部类、局部内部类、匿名内部类。

3.成员内部类：因为成员属性或成员方法都通过对象访问，所以成员内部类也通过对象访问。

4.成员内部类不能用static修饰属性或方法。

5.静态内部类：不能通过对象访问。

6.临时表达一个复杂数据会用到局部内部类。

7.匿名内部类实现了接口，重写了该接口中全部的抽象方法，同时还进行了实例对象的创建，完成了参数的传递。

第五章

5.1 异常的概述

1.代码不能100%执行时，java语言会用到异常处理机制。

2.ArithmeticException是类名，java.lang.ArithmeticException是全限定类名

3.某行代码无法执行时，会产生一个对象用户保存错误信息(异常对象)，

处理方法：当前方法处理->调用这个方法的方法->交给JVM

JVM的处理:在控制台打印一堆红色字体(打印异常对象)

4.代码异常时，用try ...catch语句处理异常，将可能出现的异常操作放在try...catch的try部分

5.某行代码不能正常运行时，抛出一个异常对象(这个对象可抛)，

"可抛的对象"：Throwable();

Throwable throwable = new Throwable();

Throwable两个子类:Error和Exception

Error:从程序角度解决不了问题，让JVM处理:在控制台把异常对象打印出来

Exception:从编码的角度处理

Exception的子类:编译期异常、运行时异常(继承了RuntimeException)

编译期异常:方法可能会抛出一个编译期异常，那这个方法必须处理这个异常，例:IOException等。

运行时异常:方法可能会抛出一个运行时异常，但方法不需要声明也不需要捕获它。例:ArithmeticException等。

5.2 异常处理

1.处理异常的方式：

方式一：通过try...catch发形式主动解决

方式二:在方法的小括号右边写:throws异常类名(当方法不处理时，交给调用这个方法的调用方去处理)

throw和throws的区别:

throw是在语句中使用；throws是在声明方法时使用

throws抛出异常对象:throws抛出异常类(可多个类)

第六章

6.1 包装类

1.

包装类的好处：(1)可以表达"没有数据";(2)还赠送了两个字符串和数字互转的方法。

包装类的缺点：(1）占用的空间更大了；(2）消耗的计算资源更大

2.基本数据类无法表达"没有数据"的概念，因此使用包装类来替代基本数据类型

int num = 10；//自动装箱

Integer i = Integer.valueOf(num);//基本数据类型转换成Integer对象类型

int newNum = i.intValue();//Integer对象类型转换为基本数据类型

3.

基本数据类型：byte short int long float double boolean char

 包装类：    Byte  Short Integer Long  Float Double Boolean Character

4.java提供 BigInteger 类表示无限大的整数，  BigDecimal表示无限大的小数。

6.2 String类

1.String类

特点：因为value被final，所以value的取值不能变，每次字符串对象修改值的时候，其实是字符串引用重新连接新的对象，而不是value修改

优点：修改字符串变量的时候不会影响其他变量对该字符串实体的引用

 缺点：会产生大量无引用的对象实体，造成一定程度的内存泄漏

6.3StringBuffer类与StringBuilder类

1.StringBuilder类

 特点：value没有被final，所以每次修改值，都是在修改value数组

 优点：不会产生多余的对象，概率性增加无引用的数组，内存泄漏的问题大大缓解

 缺点：修改会影响其他引用

2.StringBuffer类

特点：value没有被final，所以每次修改值，都是在修改value数组

优点：不会产生多余的对象，概率性增加无引用的数组，内存泄漏的问题大大缓解

缺点：修改会影响其他引用

4.Builder和Buffer的区别：

StringBuilder：速度快、线程不安全

StringBuffer：速度相对慢、线程安全

6.5其他常用类

1.Math类

2.Random类:获取一个随机数

3.UUID类:是通用唯一识别码(Universally Unique Idenyifier)的缩写，其目的是让分布式系统中的所有元素都能有唯一的辨识信息，而不需要通过中央控制端做辨识信息的指定

4.枚举类

修饰符 enum 枚举类名 {

枚举值1，枚举值2，枚举值3，...

}

public enum Season {

SPRING,SUMMER,AUTUMN,WIDTER

}