Java基础知识点学习

JAVA基础知识点学习

一、Java三大版本

1、Java2标准版(J2SE)：占领桌面(桌面程序、控制台开发)

2、Java2移动版(J2ME)：占领手机(手机、小家电)、嵌入式开发

3、Java2企业版(J2EE)：占领服务器(web端、服务器开发)、企业级开发

二、Java特性与优势

1、简单性

2、面向对象

3、可移植性：跨平台运行

4、高性能

5、分布式

6、动态性：放射

7、多线程

8、安全性

9、健壮性

三、JDK、JRE、JVM概念

1、JDK：Java Development Kit：Java开发者工具

2、JRE：Java Runtime Environment：Java运行时环境

3、JVM：Java Virtual Machine：Java虚拟机

四、Java程序运行机制

1、编译型和解释型

2、过程：源程序(.java文件)—>Java编译器—>字节码(.class文件)—>类加载器—>字节码校验器—>解释器—>操作系统平台

五、Java基础语法

1、Java中的注释有三种

1.1、单行注释：//

1.2、多行注释：/....../

1.3、文档注释：/**

* @Author liqing

* @Date 2023\10\28 19:46:23

**/

2、标识符

2.1、所有的标识符都应该以字母(a-z或A-Z)、美元符($)、下划线(_)开始。

2.2、首字符之后可以是字母(a-z或A-Z)、美元符($)、下划线(_)或数字的任何字符组合。

2.3、不能使用关键字作为变量名、方法名或类名。

2.4、标识符大小写敏感。

2.5、可以使用中文命名，但一般不建议，也不建议拼音命名，很low。

2.6、合法标识符举例：age、$salary、_value。

2.7、非法标识符举例：123abc、-salary、#abc。

3、数据类型

3.1、Java是一种强类型语言(C++)，即要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用。

3.2、弱类型语言：VB、JS

3.3、Java的数据类型分为两大类：

3.4、扩展：

3.4.1、位：bit，计算机内部数据储存的最小单位，用b表示

字节：byte，计算机数据处理的基本单位，用B表示

1字=2字节、1字节=8位

字符：计算机中使用的字母、数字、字和符号。

3.4.2、整数型：二进制以0b开头，八进制、十进制以0开头，十六进制以0x开头

3.4.3、浮点型：float：接近但不等于，最好完全避免使用浮点数进行比较，用数字工具类BigDecimal类

3.4.4、字符：所有的字符本质还是数字，用Unicode编码表示，1个字符最多用2个字节表示，最大Unicode码值为65536，用int强制转换

转义字符：\t：制表符(Tab键)，\n：换行

3.5、类型转换：

3.5.1、运算中，不同类型的数据先转化到同一类型，再进行运算。

3.5.2、精度顺序：

低—————————————————————>高

byte、short、char—>int—>long—>float—>double

3.5.3、强制类型转换：高—>低，格式：(要强转的类型)被强转的变量

自动类型转换：低—>高

3.5.4、注意点：不能对布尔类型进行转换

不能把对象类型转换为不相干的类型

在把高容量转换成低容量时，强转可能存在内存溢出或精度丢失问题

操作比较大的数时，注意溢出问题

3.5.5、JDK新特性，数字之间可以用下划线分割，例如：10000000—>10_000_000

示例：

int money = 1000000000;
int years = 20;
int total = money*years;//计算结果超出int类型的最大取值范围，计算时溢出
long total2 = money*years;//默认是int，转换前计算出的结果也都是int，所以还是溢出
long total3 = money*((long)years);//解决办法：把一个int类型的数转换为long即可

4、变量

4.1、概念：Java变量是程序中最基本的存储单元，包括变量名、变量类型和作用域

4.2、作用域：

实例变量：写在类里面、方法外面；必须声明，不一定要初始化值，如果不初始化值，则为默认值；

布尔值：默认值是false；整数类型：默认值是int，即0；浮点数类型：默认值是double，即0.0；除了基本类型外，其余的默认值都是null。

类变量：在实例变量前加static关键字。

局部变量：写在方法里，当需要使用该变量时，必须声明和初始化值。

4.3、常量：加上final关键字，初始化后不能再改变的值。

修饰符不存在先后顺序：static final double PI = 3.14;和final static double PI = 3.14;是一样的。

常量名一般使用大写字符。

4.4、变量的命名规范：

类名：首字母大写和驼峰原则，如GoodMan

常量名：大写字母和下划线，如MAX_VALUE

其他均是首字母小写和驼峰原则，如lastName、runDay()

5、运算符

5.1、算术运算符：+、-、*、/、%、++、--

5.2、赋值运算符：=

5.3、关系运算符：>、<、>=、<=、==、!=、instanceof

5.4、逻辑运算符：&&、||、!

5.5、%：取余，21➗10 = 2...1，所以21%10 = 1

5.6、幂运算：用Math.pow(2,3) = 8，即2×2×2 = 8

5.7、++：自增

实例：

a = 1;
b = a++;//先将a值赋值给b，再对a加1,所以b = 1
c = ++c;//先对a加1，再将a值赋值给c，所以c = 2

--(自减)也是如此。

5.8、位运算符：&(与)、|(或)、^、~、>>、<<、>>>

^：异或运算符，两个数相同则为0，两个数不同则为1

~：取反运算符

<<：左移运算符，相当于*2，例如：2<<3，相当于2×2×2×2 = 16

>>：右移运算符，相当于/2

5.9、逻辑运算符中，短路运算，即与运算(&&)

示例：

int c = 5;
boolean d = (c<4)&&(c++<4);
//输出d为false，输出c为5，因为当做与运算时，先判断第一个条件(c<4)是否为真，为真则继续判断下一个条件(c++<4),不为真则下一个条件不做判断了，直接返回false。

5.10、条件运算符： ? :

x?y:z：若x为true，则结果为y，否则结果为z。

5.11、扩展赋值运算符：+=、-=、*=、/=

a+=b—>a=a+b、a-=b—>a=a-b、a×=b—>a=a×b、a/=b—>a=a/b

5.12、字符串连接符：+

例如：int a = 10;//""+a+b，输出为1020

int b = 20;//a+b+""，输出为30

6、包机制

一般利用公司域名倒置作为包名，例如：百度网址：www.baidu.com，所以包名路径可定为com.baidu.www。

7、JavaDoc

7.1、概念：javadoc命令是用来生成自己API文档的

7.2、参数信息：

@author 作者名

@version 版本号

@since 指明需要最早使用的jdk版本

@param 参数名

@return 参数名

@throws 异常抛出情况

7.3、通过Dos命令行生成java API文档：

在需要生成API文档的类所在目录下的Dos命令窗口下执行该命令：

javadoc -encoding UTF-8 -charset UTF-8 Doc.java

设置编码为UTF-8、字符集为UTF-8，都是为了避免中文乱码

8、Java流程控制

8.1、Scanner对象：通过Scanner获取用户输入

8.1.1、创建一个扫描器对象，用于接收键盘数据

Scanner scanner = new Scanner(System.in);
//判断用户有无输入
if(scanner.hasNext()){
    //使用next方法接收
    String str = scanner.next();
}
//凡是属于IO流的类，如果不关闭会一直占用资源，养成用完就关掉的好习惯
scanner.close();        

8.1.2、next()：一定要读取到有效字符后才可以结束输入；

对输入有效字符之前遇到的空白，next()方法会自动将其去掉；

只有输入有效字符后才将其后面输入的空白作为分隔符或结束符；

next()不能得到带有空格的字符串。

8.1.3、nextLine()：以Enter为结束符，即nextLine()方法返回的是输入回车之前的所有字符；

可以获得空白。

8.1.4、接收整数、浮点数输入，用到的方法：hasNextInt()、nextInt()、hasNextFloat()、nextFloat()。

8.2、顺序结构：Java的基本结构就是顺序结构，顺序结构是最简单的算法结构。

8.3、选择结构：if单选择结构(if{})、if双选择结构(if{}else{})、if多选择结构(if{}else if{}else if{}else{})、嵌套if结构(if{if{}})。

8.3.1、switch多选择结构：

switch (expression){
    case value:
        //语句
        break;//可选
    case value:
        //语句
        break;//可选 
    //可以有任意数量的case语句
    default：//可选
        //语句
}

switch语句中的变量类型可以是byte、short、int、char，从jdk7开始，支持String，case标签必须为常量。

case穿透：case后面有break，则匹配成功，执行完成，跳出循环。case后面未写break，则即使匹配成功，执行完成也不会跳出循环，继续执行下面语句。

8.4、break和continue的区别：

break强行退出整个循环；continue终止某次循环

9、方法定义

9.1、格式：

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

方法体

return 返回值；

}

java都是值传递；return相当于终止方法。

9.2、方法重载：在一个类中，有相同的函数名称，但形参不同的函数。

9.2.1、规则：方法名称必须相同；

参数列表必须不同(个数不同、类型不同、参数排列顺序不同等)；

方法的返回类型可以相同也可以不相同；

仅仅返回类型不同不足以成为方法的重载；

9.2.2、实现理论：方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译报错。

9.3、命令行传参：

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

命令：java 类名 参数1 参数2

9.4、可变参数：

9.4.1、jdk1.5开始，java支持传递同类型的可变参数给一个方法；

9.4.2、在方法声明中，在指定参数类型后加一个省略号(...);

9.4.3、一个方法中只能指定一个可变参数，它必须时方法的最后一个参数；

9.4.4、任何普通参数必须在其之前声明；

9.4.5、示例：

public void test(String name,double age,int...i){}

9.5、递归：A方法调用A方法，即自己调用自己。

9.5.1、递归结构包括两部分：

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

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

9.5.2、示例：n! = n×(n-1)×(n-2)×...×1

public static int f(int n){
    if(n==1){
        return 1;
    }else{
        return n*f(n-1);
    }
}

10、数组

10.1、声明数组变量语法：

dataType [] arrayRefVar ;//首选

dataType arrayRefVar [];//效果相同，不是首选

10.2、创建数组语法：dataType [] arrayRefVar = new dataType[arraySize]；

10.3、通过索引方法数组元素，索引从0开始。

10.4、数组长度：arrayRefVar .length

10.5、内存分析：

堆：存放new的对象和数组；可以被所有的线程共享，不会存放别的对象引用

栈：存放基本变量类型(会包含这个基本类型的具体数值)；引用对象的变量(会存放这个引用在堆里面的具体地址)

方法区：可以被所有的线程共享；包含了所有的class和static变量

10.6、三种初始化：

静态初始化： int [] a = {1,2,3};

Man [] mans = {new Man(1,1),new Man(2,2)};

动态初始化：int [] a = new int[2];

a[0] = 1;

a[1] = 2;

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

10.7、数组的四个基本特点：

长度是确定的，数组一旦被创建，大小不可改变；

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

元素可以是任何数据类型，包括基本类型和引用类型；

数组变量属引用类型，数组对象本身在堆中的。

10.8、数组的使用：

for each循环：不能取数组下标的具体值进行操作，适用于打印数组

普通的for循环。

10.9、多维数组：可以看成数组的数组。

二维数组：int [] [] a = new int[2] [5];//两行五列数组

10.10、Arrays类：数组的工具类：java.util.Arrays

常用方法：给数组赋值：通过fill方法。

对数组排序：通过sort方法，按升序。

比较数组：通过equals方法，比较数组中元素值是否相等。

查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作。

10.11、冒泡排序：时间复杂度为O(n^2)

10.12、稀疏数组：当一个数组中大部分元素为0，或者为同一值得数组时，可以使用稀疏数组来保存该数组。

稀疏数组的处理方式：记录数组一共有几行几列，有多少个不同值；把具体不同值得元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模。

示例：

原始数组 稀疏数组：共6行，7列，8个不同值

0 0 0 22 0 0 15 行 列 值

0 11 0 0 0 17 0 6 7 8

0 0 0 -6 0 0 0 0 3 22

0 0 0 0 0 39 0 0 6 15

91 0 0 0 0 0 0 1 1 11

0 0 28 0 0 0 0 1 5 17

2 3 -6

3 5 39

4 0 91

5 2 28

11、面向对象编程(OOP)、面向对象(OO)

11.1、面向过程与面向对象的区别：

11.1.1、面向过程思想：步骤清晰简单，第一步做什么，第二步做什么，适合处理一些较为简单的问题，是具体的。

11.1.2、面向对象思想：分类的思维模式，是抽象的。

11.2、oop的本质是：以类的方式组织代码，以对象的组织(封装)数据。

11.3、抽象：对同一个目标的共有的属性(特征)和方法(功能/行为)进行抽取、归纳、总结。所以抽象不是了解和解决全部问题，而是选择公共的部分，忽略一个主题中与当前目标无关的哪些地方。从认识论角度考虑是先有对象后有类。对象是具体的事物；类是抽象的，是对对象的抽象。

11.4、三大特性：封装、继承、多态

11.5、break与return区别：

break：跳出switch，结束整个循环；

return：结束一个方法，并返回值。

11.6、静态方法是和类一起加载的，而非静态方法是类实例化后才存在的。

11.7、对象：使用new关键字创建对象，创建对象时，会分配内存空间，还会给创建好的对象进行默认的初始化和对类中构造器的调用。

11.8、构造器的两个特点：必须和类的名字相同；必须没有返回类型，也不能写void。

无参构造：使用new关键字，本质是在调用构造器；用来初始化值。

有参构造：一旦定义了有参构造，无参就必须显示定义(前提是使用到无参构造时)。

11.9、创建对象内存分析：

11.10、封装：隐藏对象的属性和实现细节，控制成员属性的访问和修改权限，通过特定公开的方法暴露给外面访问。该露的露，该藏的藏(对一些对象进行抽象成类)。

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

11.10.2、属性私有：用private修饰，通过统一的公有set、get方法调用私有属性。

11.10.3、意义：提高程序的安全性。保护数据；隐藏代码的实现细节；统一接口；系统可维护性增强。(对对象、类进行封装)

11.11、继承：子类继承父类的成员和方法，使得子类也能具有父类相同的行为。对类的抽象，关键字extends，子类(派生类)，父类(基类)。

11.11.1、所有的类，都默认直接或间接继承Object类。

11.11.2、子类继承了父类，就会拥有父类的全部方法和属性(前提是 不是被private修饰)。

11.11.3、Java中类只有单继承，没有多继承。

11.11.4、super：调用父类的方法；this：调用本类的方法。子类的无参构造方法中，默认调用了父类的无参构造方法，并且必须要在子类构造方法的第一行。

注意：Java类之间只能实现单继承，接口之间可以多继承。

11.12、方法的重写：子类可以重写(覆盖)父类的方法，通过父类引用变量调用该方法时，根据实际对象的类型，会调用子类中的方法。父类的引用指向子类，例如：B b = new A();B是父类，A是子类(A extends B)。

11.12.1、对于静态方法而言，方法的调用只和左边(声明引用变量)有关，因为静态方式是属于类的，不属于实例的。

11.12.2、对于非静态方法而言，体现了子类的方法重写，@Override：重写的注释。

11.12.3、总结：重写需要有继承关系，子类重写父类的方法。

11.12.4、特点：

方法名必须相同；

参数列表必须相同；

修饰符：用private修饰的方法不能被重写，用static修饰的方法也不能被重写，范围可以扩大但是不能缩小(public>protected>default>private：从大到小);

抛出异常：范围可以缩小但不能扩大(FileException<Exception：从小到大)；

11.12.5、重写：子类的方法和父类必须一致，而方法体不同。

11.12.6、为什么需要重写：父类的功能，子类不一定需要，或者不一定满足。

11.13、多态：同一个行为具有多个不同的表现形式或者形态，如一个类的方法在不同的情况有不同的表现形式。

11.13.1、多态需要满足的三个条件：有继承、有重写、有父类引用指向子类对象。最终多态体现为父类引用可以指向子类对象：父类类型 变量名 = new 子类类型()。

11.13.2、多态的三种表现形式：普通类多态、抽象类多态、接口多态

11.13.3、多态的编译和运行：

成员变量：编译和运行都看左边

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

11.13.4、不能重写的情况：

被static修饰的方法，是静态方法，是属于类的，而不属于实例，所以不能被重写；

被final修饰的方法，不能被重写；

被private修饰的方法，不能被重写。

11.14、instanceof关键字：判断两个类是不是父子关系。

11.14.1、格式：boolean result = object instanceof class。

11.14.2、参数说明：result ：布尔类型；object：必选项。任意对象表达式；class：必选项。任意已定义的对象类。

11.14.3、说明：

如果 object 是 class 的一个实例，则返回 true。

如果 object 不是指定类的一个实例，或者 object 是 null，则返回 false；

类的实例包含本身的实例，以及所有直接或间接子类的实例。

11.14.4、规则:

左边的对象实例不能是基础数据类型；

左边的对象实例和右边的类不在同一个继承树上；

null用instanceof跟任何类型比较时都是false；

11.15、static关键字：

11.15.1、静态变量：用static修饰的变量。

11.15.2、静态方法：用static修饰的变方法。

11.15.3、示例：

public class Person{
    {
        匿名代码块;//随对象创建而执行，并在构造方法前执行，一般用于赋初始值。
    }
    static{
        静态代码块;//随类加载时而执行，只执行一次。
    }
    public person(){
        无参构造方法;
    }
}

11.15.4、静态导入包：import static java.lang.Math.random;

11.16、抽象类：使用abstract关键字修饰类，抽象类只能单继承。

11.16.1、抽象方法：使用abstract关键字修饰方法，只有方法名字，没有方法的实现。

11.16.2、特点：

不能new抽象类，只能靠子类去实现它；

抽象类中可以写普通的方法；

抽象方法必须在抽象类中。

11.17、接口：使用interface关键字修饰，接口可多继承。

11.17.1、接口中的所有定义的方法其实都是抽象的(public abstract)。

11.17.2、接口中定义的变量都是常量(public static final)。

11.17.3、接口实现类 implements 接口1,接口2...{

重写接口1中的方法；

重写接口2中的方法；

...

}

11.17.4、接口不能被实例化，接口没有构造方法。

注意：在jdk1.8之前，接口中的方法不能有方法实现体，而jdk1.8及jdk1.8以后，接口中的方法可以有方法实现体。

11.18、内部类：在一个类的内部再定义一个类。

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

11.18.2、成员内部类：

Outer outer = new Outer();

OuterInner inner = outer.new Inner();

inner.in();

成员内部类能获取外部类的私有属性、私有方法。

11.18.3、静态内部类：在成员内部类前用static修饰符。

静态内部类无法访问外部类的方法、属性，如果需要访问，则必须在外部类的方法、属性加上static进行修饰。

注意：一个java文件可以有多个class，但是只能有一个public class。

11.18.4、局部内部类：定义在外部类的方法中。

11.18.5、匿名内部类：没有名字初始化类，不用将实例保存到变量中。例如：new Apple().eat();

11.19、异常：程序运行中出现的不期而至的各种状况，比如：文件找不到、网络连接失败、非法参数等。

11.19.1、分类：检查性异常、运行时异常、错误。

检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如：要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。

运行时异常：运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。

错误：错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。

11.19.2、结构：

11.19.3、异常处理机制：

抛出异常：throw、throws

捕获异常：try、catch、finally

异常处理的五个关键字：try、catch、finally、throw、throws

示例：

try{//监控异常区域
    
}catch(){//捕获异常，如果需要捕获多个异常，则需要从小到大
    
}catch(){//捕获异常
    
}catch(){//捕获异常
    
}finally{//处理异常善后工作
    
}
​
//如果方法中处理不了该异常，则需要throws用在方法上抛出异常，再处理的话，就向上抛出异常，写在类上
public void test() throws ArithmeticException{
    throw new ArithmeticException();//throw：主动抛出异常，一般用在方法中
}