Java学习笔记_private class-CSDN博客

本文链接：https://blog.csdn.net/weixin_50893467/article/details/126361398

计算机组成和DOS常用命令

1.计算机组成

2.计算机工作原理

计算机数据从输入设备到输出设备，或者到硬盘，都要经过内存，数据存入内存时，需要先在内存中申请空间，然后分配一个地址给这个空间，最后在使用时通过这个地址来获取这个数据

3.常用DOS命令

dir：列出当前目录下所有文件及文件夹

md：新建目录

rd：删除目录

cd：进入指定目录

cd ..：返回上一级目录

cd \：返回根目录

del：删除文件

copy：复制文件

cls：清空DOS界面

exit：退出DOS界面

编程语言概述

1.软件开发

软件即一系列按照特定顺序组织的计算机数据和指令的集合（系统软件和应用软件）

2.Java特点

面向对象、健壮性和完整性、跨平台JVM

3.Java核心机制

JVM虚拟机，可支持Java程序在不同平台上运行（跨平台特性）
垃圾回收机制GC，可自动回收内存

4.Java环境

JDK—Java开发工具包 < JRE—Java运行环境 < JVM—Java虚拟机

5.Java开发步骤

代码写入.Java文件，编译出.class文件，运行.class文件

6.Java程序入口

所有Java程序的执行入口都是main()方法，格式为

public static void main(String[] args){...}

7.Java程序规范

Java严格区分大小写，每个语句都以;结束，括号都是成对的
包名都小写xxxyyyzzz；类名、接口名所有首字母大写XxxYyyZzz；变量名、方法名第一个首字母小写，其余首字母大写xxxYyyZzz；常量名所有字母都大写单词间用下划线连接XXX_YYY_ZZZ

变量和数据类型

1.变量

变量就是一个用来存储数据的“容器”，是内存中的一块空间，存储经常发生变化的量

2.变量的声明和赋值

可以在声明变量的同时赋值，也可以先声明变量，然后再需要的地方进行赋值

3.基本数据类型

数值型：byte、short、int

字符型：char

布尔型：boolean

4.数据类型转换

从小到大，自动类型转换；从大到小，强制类型转换，要注意数据溢出问题和精度丢失问题

5.Scanner类

首先导入java.util.Scanner包，创建一个Scanner类，然后在需要键盘输入的地方利用Scanner类的nextInt()、nextDouble()、next()等方法获取键盘输入的数据

运算符

1.算数运算符

自加自减：i++、i--：先取值，后加减；++i、--i：先运算，后取值

复合赋值：i = i + 2可以简写为i += 2，复合赋值自带数据类型强制转换功能

2.关系用算符

输出结果是boolean型，true或false

3.逻辑运算符

与&、短路与&&、或|、短路或||、非!、异或^

&和&&的区别是使用&，无论左边真假，都要继续把右边算完；使用&&当左边为真时，继续往右边算，当左边为假时，右边不参与运算，直接输出结果假
|和||的区别同理，当左边为真时，右边不参与运算，直接输出结果真

4.三目运算符

条件表达式?表达式1:表达式2;

条件为true，运算结果为表达式1;

条件为false，运算结果为表达式2；

分支选择结构

1.顺序结构

从上到下逐行执行

2.分支结构

if-else语句、switch语句（每个case语句中一般要加break，否则将会把条件匹配的语句之后的所有语句全部输出，直到遇到break或switch语句结束；当变量取值较少且数据类型为byte、short、char、int、String、枚举时建议使用switch语句，因为效率稍高）

循环结构

1.`for`循环

以循环10次为例：

for(int i = 0; i < 10; i++){
    ...
}

2.`while`循环

以循环10次为例：

int i = 0;
while(i < 10){
    ...
    i++;
}

3.`do-while`循环

以循环10次为例：

int i = 0;
do{
    ...
    i++;
}while(i < 10);

4.`while`和`do-while`循环的区别

while先判断是否符合条件，然后再执行循环体；

do-while先执行循环体，再判断是否符合条件，即使条件不满足，循环体也会至少执行一次

5.循环效率

循环嵌套时尽量使外层循环次数小于内层循环次数

6.特殊流程控制语句

break跳出整个循环，continue跳出本次循环，return可以用来结束方法，其后的代码都不能执行

数组的基本操作

1.声明数组并指定长度

//数据类型[] 数组名 = new 数据类型[数组长度]
int[] arr = new int[length];

数组声明后是有默认初值的，默认初值的类型就是声明数组的类型，如int型数组的默认初值是0，String型数组的默认初值是null

方法

1.方法的概念

一段具有特定功能的代码块

2.方法的作用

提高代码的复用率，提高开发效率
使程序易于管理
便于隐藏代码的细节

3.声明方法

修饰符 返回值类型 方法名(参数列表){
    方法体;
}

方法中可以调用方法，但是方法中不能定义方法，在同一个类中方法间可以直接相互调用，不用实例化对象，但是不同类间调用方法必须先实例化一个对象

4.类的访问机制

在同一个类中：类中的方法可以直接访问类中的成员变量（例外：static方法不能访问非static的成员变量）

在不同类中：先创建要访问类的对象，再用对象访问那个类中定义的成员

5.方法的重载（overload）

一个类中允许同名方法存在，只要它的参数列表不同就行（参数个数或数据类型不同）

6.方法形参数可变

如String[] args、String...args,使用方法都是数组的方法，但是第一种至少要输入一个空数组，第二种可以什么都不输入，要注意不可变的形参要放在可变形参之前

7.参数传递

Java里方法的参数传递方式只有一种：值传递。

基本数据类型在参数传递过程中，只是把方法外部实参输入的值复制到方法内部的形参上
引用类型在参数传递过程中，其实是把方法外部实参所代表的对象在堆中的地址复制到方法内的形参上，于是此时实参和形参都保存的是对象在堆中的地址，即实参和形参指向的其实是用一个对象，利用形参来操作对象，当然方法外实参代表的对象也就发生了改变

Java面向对象

类和对象

1.面向过程（POP）

描述一个问题的从头到尾过程，不同问题需要从头到尾重新编程，张三打篮球的过程，李四踢足球的过程

2.面向对象（OOP）

把问题中的各种对象分解开，人、动作、器械三个对象，实例化一个张三的对象，动作是打篮球，器械是篮球；实例化一个李四的对象，动作是踢足球，器械是足球。

面向对象可以更好地在抽象的层面上分析问题，代码可以有很大的复用率

3.面向对象的三大特征

封装（Encapsulation）、继承（Inheritance）、多态（Polymorphism）

4.Java类及类的成员

类class中包含它对应的属性（即成员变量）、行为（即方法）。类可以理解为一个设计图，而对象就是这个设计图对应出的一个个具体的东西。

5.默认赋值

栈内存中的变量需要先幅值后使用，而堆内存中的变量是有默认初值的

6.`==`和`.equals()`方法

==：基本数据类型比较值，两个变量的值相等即为true；引用类型比较引用（地址），两个变量指向同一个对象（地址相同）即为true；用==进行比较时，两边的数据类型必须兼容（相同、可自动转换或有继承关系），否则编译报错
.equals()：所有类都继承了Object类的.equals()方法，也可以重写；只能比较引用类型，一般情况下作用与==相同，两个变量指向同一对象即为true；特殊情况：对于String、File、Date和包装类来说，.equals()方法比较的是变量的类型和内容，而不考虑引用的是否为同一个对象，因为这些类的.equals()方法重写了

封装和隐藏

1.Java包

关键字：package

等同于文件夹的概念，允许多级创建，使用不同包之间的类需要用import先声明，或在引用时把包路径加上

2.封装和隐藏

把不想对使用者公开的属性用修饰符private限定为该类私有，然后通过编写public类型的setXxx()和getXxx()方法来设置属性和获取属性这就是封装和隐藏

3.限定修饰符

修饰符权限范围	同一个类	同一个包	子类	任何地方
`private`	访问
`(default)`	访问	访问
`protected`	访问	访问	访问
`public`	访问	访问	访问	访问

class类只能用public和(default)来修饰，public类可以在任何地方使用，default类只能在同一个包内使用。同一个Java文件中可以写多个class，但是public类型的只能有一个，其它的只能是(default)类的

构造方法

1.构造方法（构造器）

创建对象时，new对象，其实是在那个对象的类中默认构造了一个与类名相同的方法，即类名() {}，这个默认构造方法的访问限定修饰符与类的访问限定修饰符相同

2.显式定义构造方法

若果显式构造了一个方法，那么系统将不再默认构造方法。构造的方法可以直接在方法体中初始化类的属性等，也可以给这个构造方法加入参数，在创建对象时输入值来初始化属性。

3.构造器重载

与方法重载相同，只需参数列表不同即可。构造器的重载就是为了方便调用，可以灵活地创造出不同需要的对象。

继承

1.继承

在父类中写共性的代码，其他不同的子类可以直接继承父类的共性代码，再加入特有的代码，这样做共性代码只需要写一遍，每个子类只需要写自己的特有代码。

继承的出现提高了代码的复用性，同时让类与类之间产生了联系，提供了多态的前提，但不要为了获取其它类中的某个功能而去继承，继承需要有逻辑关系

继承的关键字是extends，子类不是父类的子集，而是父类的扩展

2.访问权限

子类不能直接访问父类中private和默认修饰的属性和方法，可以通过set和get方法来间接访问（如果父类和子类在同一个包里，则默认修饰的属性和方法也可以直接访问）

3.单继承

一个子类只能有一个父类，允许在一条逻辑线上多层的继承

4.方法的重写

在子类中可以根据需要重写从父类中继承来的方法，但只能重写方法体，方法名、参数列表和返回值类型都不能改，重写方法的修饰符不能比被重写的方法更严格，静态修饰符也不能改，且子类方法抛出的异常不能大于父类被重写方法的异常

5.`this`关键字

表示“当前”，可以用来表示当“前类的”，当形参与实参重名时可以用来区分

在类中可以用来在构造方法之间相互调用，必须放在方法体的首行，但不能出现自己调用自己的情况

6.`super`关键字

用于标识父类中的属性、方法和构造器，且不仅限于直接父类

子类的所有构造器必须先访问父类的构造器，当父类的构造器是无参构造器时，子类的所有构造器都会默认访问；当父类没有无参构造器时，子类的构造器必须通过this(参数列表)或super(参数列表)语句来指定调用本类或父类中相应的构造器，且必须放在构造器的第一行

	this	super
访问属性	访问本类中的属性，如果本类中没有此属性，则从父类中继续查找	访问父类中的属性
调用方法	调用本类中的方法，如果本类中没有此方法，则从父类中继续查找	调用父类中的方法
调用构造器	调用本类构造器	调用父类构造器
特殊	表示当前对象	表示引用父类对象

7.`final`关键字

在Java类中声明类、属性和方法时，可以使用关键字final来修饰，表示“最终的”

final标记的类不能被继承；
final标记的方法不能被子类重写；
final标记的变量（成员变量或局部变量）称为常量，只能被赋值一次，且必须在声明的同时或在每个构造器中或代码块中显式赋值。

8.`static`关键字

静态的，加了static关键字的变量是类变量（静态变量），不用实例化就可以使用（类名.属性名），是类的一部分，被所有属于这个类的实例对象所共享；普通的变量是实例变量，只有实例化之后才可以用是实例对象的一部分。同样，static关键字也可以用来修饰方法、代码块、内部类。

使用关键字static修饰的属性和方法就不能再使用this和super了，只能使用类名.属性名

抽象、接口、多态

1.匿名对象

如果一个对象在程序中只需要调用一次，那么就没必要给这个对象命名，直接使用匿名对象即可。

2.内部类

定义在一个类中的类称为内部类，内部类是为外部类服务的，可以访问外部类的一切资源。

3.抽象类

关键字abstract可以声明一个抽象类或抽象方法；

只有方法的定义，没有方法的实现的方法叫抽象方法；

抽象类至少包含一个抽象方法；

抽象类不能被实例化，只能被继承，抽象类的子类必须重写父类的抽象方法，并提供方法体，否则就仍是抽象类

4.接口

接口是抽象方法和常量值的定义集合，是一种特殊的抽象类，通过关键字implements实现接口，它只包含常量和方法的定义，而没有变量和方法的实现。接口可以得到多重继承的效果，一个类可以实现多个接口，接口也可以继承其他接口。

jdk8之后在接口中可以有普通的方法，但是要用default声明。

5.接口的特点

接口中的所有成员变量都是默认public static final修饰的（静态常量），所有方法都是默认public abstract修饰的（抽象方法），接口没有构造器，采用多层继承机制。

在一般的开发实践中，为了方便管理，一般把常量和抽象方法分别写在两个专门的接口中去实现。

6.继承与实现

如果一个类既继承了父类，又实现了接口，那么要先继承，再实现，实现接口的类必须重写接口中所有的方法，否则就要把他声明为一个抽象类

7.多态

方法的重载和重写
对象的多态——可以直接应用在抽象类和接口上

8.对象的多态

Java引用变量有两个类型，编译时类型和运行时类型。编译时类型由声明该变量时使用的类型决定；运行时类型由实际赋给该变量的对象决定。若编译时类型和运行时类型不一致，就出现多态

9.向上转型

子类可以看做是特殊的父类，所以父类类型的引用可以指向子类的对象

10.多态的访问范围

一个引用变量如果声明为了父类的类型，但实际引用的是子类对象，那么该变量就不能再访问子类中添加的属性和方法。属性和方法的访问是在编译时确定的，编译时变量是哪个类型，就可以访问哪个类型的属性和方法

11.虚拟方法调用

方法的调用是在运行时确定的，当父子类间存在方法的重写时，运行时变量是哪个类型，调用的就是哪个类型的方法

12.`Instanceof`操作符

x instanceof A 判断x是否属于A类，返回值是Boolean类型

13.多态的应用场景

设计方法的参数时，当参数类型不明确，可以使用父类来作为参数的数据类型
创建对象时，也可以使用多态来完成程序的解耦
设计方法的返回值时，当返回值的类型不确定，可以使用父来作为返回值的参数类型

异常处理

1.错误`Error`

JVM系统内部错误、资源耗尽等严重情况

2.异常`Exception`

其它因编程错误或偶然的外在因素导致的一般性问题

运行时异常，编译能通过，运行时出现的异常
非运行时异常，编译无法通过，必须要人为处理

3.`Throwable`类

Throwable类是Java异常的根父类，它直接继承了Object类

Throwable有两个子类：Error和Exception

4.捕获异常（抓）

用try{}来括住一段有可能出现异常的代码段，然后用catch{}来抓取异常，要注意这里只能抓取try{}里面捕获的第一个异常，因为出现异常后的代码就不会再执行了，如果不知道可能出现的异常的类型，可以使用异常的父类Exception，后面也可以加一个**finally{}这是在捕获异常时最终一定会执行的代码段**

5.抛出异常（抛）

用throws来抛出异常，让调用者进行捕获和处理，要注意子类重写方法不能抛出比父类方法范围更大的异常。人工抛出异常可以通过throw new Exception语句来抛出一个可能的异常。也可以自定义异常类，但自定义的异常类必须继承Exception类

常用API

1.API

应用程序编程接口，Java中的API指的就是JDK中提供的各种功能的Java类

2.随机数

Random类：需要实例化对象，产生随机整数nextInt()，需要参数来规定产生随机数的范围
Math类：静态方法，产生0~1的随机小数（double）random()
UUID类：静态方法，产生随机32位UUIDrandomUUID()

3.包装类

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

Java提供了自动拆装箱。

Integer类：parseInt()，将字符串转换为整数，parseDouble将字符串转换为小数

4.`Data`类

public Data()从当前时间构造日期时间对象

simpleDateFormat类，格式化Date对象，可以指定日期显示格式

5.数字格式化类

要求小数精度不丢失，建议将小数封装到BigDecimal对象中，调用方法完成数学运算
数字格式化类DecimalFormal类

6.`String`类

length()：获取字符串长度
trim()：去除两端空格
endsWith()：判断是否以指定字符结尾
startsWith()：判断是否以指定字符开头
indexOf()：获取指定字符第一次出现的下标
lastIndexOf()：获取指定字符最后一次出现的下标
contains()：判断字符串中是否包含指定字符
substring()：截取指定下标范围的字符串，含头不含尾
split()：以指定字符做分隔符分割字符串
replace()：替换指定的字符
equalsIgnoreCase()：比较两个字符串是否相同，忽略大小写

集合

1.集合

Java集合类存放于java.util包中，是一个用来存放对象的容器

集合只能存放对象，如果将基本数据类型放入集合，那么它将自动转换为对应的封装类再存入

集合存放的是多个对象的引用，对象本身还是存放在堆中

集合可以存放不同类型、不限数量的数据类型，Jdk5之后增加了泛型，Java集合可以记住容器中对象的数据类型

2.`collection`接口

Collection接口是集合层次中的根接口，JDK不提供任何直接的实现类，而是提供了更具体的子接口Set和List来实现

List接口继承了Collection，用于存储可重复且有序的（存储顺序）的数据，它按元素添加的顺序来存储元素，不会重新排序。提供了按索引访问的方式。List集合在创建时可以传入一个长度参数，尽量一次性创建出容量适合的集合，这样可以提高List集合的性能。
Set接口继承了Collection，用于存储不重复且无序的（添加顺序）的数据，它按自己内部的一个排序机制对存储的元素进行排序。
无论是List还是Set集合中存储的元素类型都是Object，因此从集合中取得元素时必须把它转换为原来的类型。

3.`ArrayList`和`LinkedList`的区别

数据结构不同：ArrayList是Array（动态数组）的数据结构，LinkedList是Link（链表）的数据结构
效率不同：
- 当随机访问List（get和set操作）时，ArrayList比LinkedList的效率更高，因为LinkedList是线性的数据存储方式，需要移动指针从前往后依次查找
- 当对数据进行增加和删除的操作（add和remove操作）时，LinkedList比ArrayList的效率更高，因为ArrayList本质是数组，在其中进行增删操作时，会对操作点之后所有数据的下标产生影响，需要进行数据的移动

4.`ArrayList`和`Vector`的区别

ArrayList和Vector都是使用数组的方式存储数据，此数组的的元素数大于实际存储的数据以便增加和插入元素。他们都允许按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢。

当Vector或ArrayList中的元素超过它的初始大小时，Vector会将它的容量翻倍，而ArrayList只会增加50%的容量，这样ArrayList就有利于节约内存空间。

Vector由于使用了synchronized线程安全，通常性能上较ArrayList差。

5.`HashSet`和`TreeSet`的区别

HashSet基于散列表的方式存放数据（无顺序），可以放入null，但只能放入一个null。
TreeSet是二叉树实现的，TreeSet中的数据是自动排好序的，不允许放入null值

在选择的时候，如果顺序很重要，则可以选择TreeSet，如果操作性能和时间效率很重要的话，则可以选择HashSet。

6.集合与数组的相互转换

数组——>List集合：Arrays.asList()方法

List集合——>数组：toArray()方法

List集合——>Set集合：创建Set集合时直接将List集合作为参数传入

Set集合——>List集合：创建List集合时直接将Set集合作为参数传入

7.`ArrayList`集合

ArrayList是List接口的实现类，List集合的元素是有序的，并且是可重复的，每个元素都有它对应的顺序索引，默认按照元素的存入顺序设置元素的索引

//创建
List<T> list = new ArrayList<T>();
//判断ArrayList集合是否为空
list.isEmpty();
//获取集合长度
list.size();
//添加元素
list.add();
//更改元素
list.set();
//根据下标获取元素
list.get();
//删除元素
list.remove();
//判断集合中是否存在指定元素
list.contains();
//清空集合
list.clear();

8.`Map`接口

Map接口通常用于处理键值映射数据的存储

9.`HashMap`和`HashTable`的区别

HashMap是线程不安全的，效率高；HashTable是线程安全的，效率低
HashMap可以存储null键（只允许存在一个）和null值；HashTable不可以存储null键和null值

10.`HashMap`集合

HashMap是Map接口的实现类。Map集合里保存着两组值，一组值用于保存Map里的Key，另一组用于保存Map里的Value。Map中的Key和Value都可以是任何引用类型，但Key不允许重复，即同一个Map集合中的任意两个Key通过equals()方法比较的返回值都是false。Key和Value之间存在一一对应关系，即通过指定的Key总能找到唯一确定的Value。

//创建
Map<T> map = new HashMap<T>();
//添加元素
map.put();
//判断HashMap集合是否为空
map.isEmpty();
//获取集合长度
map.size();
//删除元素
map.remove();
//根据Key取元素
map.get();
//判断有没有指定的Key
map.contiansKey();
//判断有没有指定的Value
map.contiansValue();
//获取Key集合
Set<T> set = map.keySet();
//获取Value集合
Collection<T> value = map.value();
//Lambda表达式循环
map.forEach((T1 key, T2 value)->{
    ...
});

泛型

1.什么是泛型

泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口和泛型方法。Java语言引入泛型的好处是安全简单。

在没有泛型的情况下，通过对类型Object的引用来实现参数的“任意化”，带来的缺点是要做显式的类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行时才出现异常，这是一个安全隐患。

2.泛型通配符（?）

当需要使用集合作为方法的参数时，如果不知道集合中元素的具体数据类型，就可以使用<?>来表示任何类型，此时传入什么类型参数就是什么类型。

通配符还可以用来做权限限制：

<? extends Person>表示只允许泛型为Person及Person子类的引用调用
<? super Person>表示值允许泛型为Person及Person以上三层父类的引用调用

IO流

1.`File`类

File类是java.io包中唯一能够代表磁盘文件本身的对象，提供了对“文件”或者“目录”的操作。File类定义了一些与平台无关的方法进行文件操作，如建立、删除、查询、重命名等。在File类中包含了大部分文件操作的功能方法，该类的对象可以代表一个具体的文件或文件绝对路径和相对路径。

2.`File`类的构造方法

构造方法	说明
`File(String filename)`	根据文件的路径名创建一个新的`File`对象
`File(String parent, String child)`	根据文件路径名和文件名创建一个新的`File`对象
`File(File parent, String child)`	根据指定目录的`File`对象和文件名创建一个新的`File`对象
`File(URI uri)`	根据`URI`所对应的路径名创建一个新的`File`对象