Java学习知识总结

Java知识总结

一、Java的版本概述：

​​​​​​​1、Java是一直排名在前三的语言，Java是一门面向对象的编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。

   其长期支持的版本有：Java 8、Java 11、Java 17。

2、JDK安装在官网上安装其中格外重要的是他的文件夹bin存放了各种工具命令如：javac和Java等等。

3、环境变量的配置步骤：文件夹里右键选择属性--高级设置中的环境配变量--在系统变量当中新建JAVA_HOME下面输入地址中不带bin，再打开path新建地址移至最顶部。

4、JDK:全称：Java Development kit，Java开发工具包，分为JVM、核心类库、开发工具。

   JRE：全称：Java Runtime Environment，Java运行环境，分为JVM、核心类库、运行工具。

注释：JVM是Java程序运行的地方，核心类库：Java写好的东西，开发工具：javac、jdb、jhat。

5、书写HelloWorld：在盘上新建一个文件夹命名HelloWorld.java并且输入代码public class HelloWorld{

                      public static void main(String[] args){

                                    System.out.println("HelloWorld");

}

}win+r输入cmd现在后缀填入哪个盘：再回车先输入javac HelloWorld.java回车再输入java HelloWorld即可。

6、安装idea：官网上安装

7、先建立一个Project再新建一个module再src中新建package再建立一个Java class。该软件会自动跳出代码所以记住缩写即可如编写HelloWorld：psvm，sop右键运行即可。

二、面向过程学习：

二、1运算符学习：

1.1基本数据类型 ：  

Long 在数值后面要加一个L做后缀，float数据值加一个F做后缀。Boolean只有true和false。

大小关系：double>float>long>int>short>byte.

1、运算符：​​​​​​​

1. （1）运算符的基本概念：对字面量或者变量进行操作的符号，分为算术运算符 、自增自减运算符、赋值运算符、关系运算符、逻辑运算符、三元运算符。（2）算术运算符：在代码中，如果有小数参与运算，结果有可能不精确的。
2. 整数参与计算结果只能得到整数。用‘/’时要想得到小数可以将除数或者被除数其中一个或两个变成小数即可。
3. 数据转换的两种方式：隐式转换和强制转换。Double+into不行需要转换成相同的数据类型。隐式转换（自动类型提升）：取值范围小的数值转换到取值范围大的数值，系统会自动的进行转换。double>float>long>int>short>byte.     Byte short char 在进行数据转换时都会先转换成int在相加减，从左到右相加减。
4. 强制转换：取值范围大的数值转换到取值范围小的数值，需要我们自己手动进行变换，格式：目标数据类型 变量名=（目标数据类型）被强转的数据，double a；int b=（int）a；注意byte转换会出错可能。byte a=10;byte b=20;byte c=(byte)(a+b);  或者int c=a+b;
5. 字符串拼接操作：当“+”操作中出现字符串时，这个“+”是字符串连接符，将前后的数据进行拼接产生一个新的字符串，从左到右进行执行，“”表示字符串，不加的表示算数，如1+99+“的”=100的。输出sout（“我的年龄是：”+ age）；结果我的年龄是8；age=8；1+2+“abc”+2+1=3abc21;与c语言不同他是输出要加上+；字符串只有加法运算没有*/-%；
6. 字符相加：字符加字符，字符加数字通过ASCII字符代码表来进行想加减；

只要有字符串参加就是一个拼接操作，‘a’+“a”=aa；1+‘a’=98；a97；A65；

整数运算想要小数要加上浮点数即float，double,10.0;

7、自增自减：基本用法：++ --，无论放在变量的前端也可以放在变量的后端，单独写一行结果是一样的即性质都是一样的都是给变量加1或者减1与c++学习的不同。当进行运算赋值时跟c++一样的用法（一般情况下用的比较少）。

（1）赋值运算符：=、-=、+=、*=、/=、%=，都相当于包含了一种强制转换。

（2）关系运算符（比较运算符）：==相等、!=不相等、>=、<=、>、<，都是boolean类型，结果true和false。

（3）逻辑运算符：

a.&（且）、|（或）、^（用得少）（相同false不同为true）、！（取反只写一次或者不写）。

b.短路逻辑运算符:&&、||运行结果和&|一样但是起到短路的效果即当左边的表达式能确定最终的结果右边就不会运行了。（用的多）

用的最多的是&&、||、！。

8、三元运算符（三元表达式）：

格式:关系表达式？表达式1：表达式2；（从左到右开始若前面为假则执行第二个）。

int c=a>b？a:b；（a>b则等于a否则b）

小括号优先于一切所以以后想谁开始运算就加小括号。

二.2判断语句：

1. If（判断）的三种格式：
2. （1）if（关系表达式）{语句体；}

注释：先进行关系表达式的判断若true则执行语句体。如果否就执行其他的语句。

注意：{最好写在if（）后面紧跟着不要另起一行，最好{}不要省略，对于一个布尔类型的变量进行判断直接把变量卸载小括号里不写==、=。

（2）if(关系表达式){语句体1；

}else{

语句体2；}

if的嵌套： If(x范围){

If(){}}（用的比较多）

（3）if(关系表达式){语句体1；

}else{

语句体2；}

……

else{语句体 n+1；}

2、Switch语句：

(1).switch（表达式）{

case 值1:

语句体1；

break;

……

default:

语句体n+1；

break；}

注意：case后面的值只能是字面量不能是变量，且不能重读。

(2)default不一定是写在最下面可以是任意位置也可以省略一般不建议。

(3)case穿透：无break，则会一直执行下去直到结束（适用于case重复）。

（4）case ->sout也算是一种输出，后面不加break。

（5）

或者case 1:

                               Case 2:sout;break;

二、3循环语句:

1. 循环的分类：for\while\do……while。

• for(初始化语句；条件判断语句；条件控制语句)       for(int i=1;i<10;i++)

{循环体语句；}                                     {sout();}

• while(条件判断语句){

循环体语句；

条件控制语句；}

两者的区别：aa.运行规则一样。

bb.for循环中，控制循环的变量如i归属for循环的语法结构，循环结束后就不能再次被访问while相反。

cc.for知道循环次数和范围while只知道循环的结束条件。

二、4数组：

1. 数组的定义：是一种容器，可以用来存储同种数据类型的多个值。结合隐式转换。

double>float>long>int>short>byte.如int当中只能用int或者比他小的。

格式一：数据类型[] 数组名       int  []  array

格式二：数据类型 数组名 []      int array[]（常用）

2、数组的创建：（1）静态完整格式：数据类型[] 数组名=new 数据类型[]{元素1……}；

                              int  []  array=new int[]{1,2,3};

（2）静态简化格式：数据类型[] 数组名={元素1……}；

                               int  []  array={1,2,3};

(3)动态初始化：数据类型[] 数组名=new 数据类型[]

                                int  []  array=new int[20]；

                                array[0]=  

区别：动态：只明确元素的个数不明确具体数值；静态：手动指定数组元素，系统计算长度。

3、数组的异常：当访问了数组中不存在的索引，会引发索引越界异常。

如int []a={1,2,3};

Sout(a[10])发生错误。

4、数组的遍历：将数组中所有的内容取出来取出来之后可以（打印、求和、判断……）

注意：指的是取出数据的过程，不是就是打印。

int []a={1,2,3};

i<=2或者i<a.length;

5、数组的拷贝：

（1）浅复制：在Java中，数组是引用类型，直接赋值或使用Arrays.copyOf方法进行复制时，只是复制了引用，并没有创建新的数组副本。这就是所谓的浅复制。

public class ArrayCopyExample {

    public static void main(String[] args) {

        // 原始数组

        int[] originalArray = {1, 2, 3, 4, 5};

        // 浅复制

        int[] shallowCopy = new int[originalArray.length];

        for (int i = 0; i < originalArray.length; i++) {

            shallowCopy[i] = originalArray[i];

        }

        // 修改原始数组中的元素

        originalArray[0] = 100;

        // 输出副本数组，验证浅复制结果

        System.out.println(Arrays.toString(shallowCopy)); // 输出：[1, 2, 3, 4, 5]

    }

}

（2）深复制：在Java中，数组是引用类型，直接进行赋值操作只是复制了引用，使得两个变量引用同一个数组。如果需要创建一个数组的副本，即进行深拷贝，可以使用       System.arraycopy()方法或者通过循环遍历数组元素手动复制。

psvm{

//定义原始数组

Int [] arr={1,2, 3,4,5,6};

//调用方法拷贝数组

Int [] copyArr=copyOfRange(arr,from:3,to:7);

//遍历copyArr

for(int i=0;i<copyArr.length;i++){

Sout(copyArr[i]+” ”);}}

Public static int[] copyOfRange(int [] arr,int from,int to){

//定义数组

Int [] newArr=new int[to-from];

//伪造索引思想

int index=0;

for(int i=from;i<to;i++){

 //格式：数组名【索引】=数据值；

newArr[index]=arr[i];

idex++;}

return newArr;

二、5方法：

1. 方法的定义：把一些代码打包在一起的过程。

     定义格式：

                  public static 返回值类型 方法名（参数）{

方法体；

return 返回值；}

（1）最简单的方法定义和调用格式：        public static void 方法名（）{          

方法体（就是打包起来的代码）；}

或者格式：方法名（）；

注意：方法必须先定义后调用，否则程序报错。

（2）带参数的方法的定义和调用：aa.单个参数：public static void 方法名（参数）{……}

                                                                    int number

bb.多个参数格式：public static void 方法名（参数1，参数2，……）{……}

注意：方法调用时，参数的数量与类型必须与方法定义中小括号里面的变量一一对应。

cc.形参：形式参数，指方法定义中的参数。

dd.实参：方法调用中的参数。

注意：方法调用时，是实参形参必须一一对应。

(3)带返回值的方法的定义和调用：

public static 返回值类型 方法名（参数）{方法体；

return 返回值；}

A.直接调用：方法名（实参）；

B.赋值调用：整数类型 变量名=方法名（实参）；

C.输出调用：sout（方法名（实参））；

D.方法不调用就不执行

E.方法与方法之间是平级关系，不能互相嵌套

F.方法的编写顺序和执行顺序无关

G.方法的返回值类型为void，表示该方法没有返回值没有返回值的方法可以省略return语句不写。如果要编写return，后面不能跟具体的数据。

H.Return关键字：方法没有返回值:可以省略不写。如果书写，表示结束方法

方法有返回值:必须要写。表示结束方法和返回结果

2、方法的调用：方法定义后并不是直接运行的，需要手动调用才能执行的过程。

3、方法的重载：在同一个类中，定义了多个同名的方法，这些同名的方法具有同种功能。每个方法具有不同的参数类型。

简单即：同一个类中，方法名相同，参数不同的方法，与返回值无关。

参数不同：个数、类型、顺序不同。

4、基本数据类型和引用数据类型的区别：

基本数据类型：变量中存储的是真实的数据，数据值是存储在自己的空间中，特点：赋值给其他变量，赋的真实的值。

引用数据类型：变量中存储的是地址，数据值是存储在其他的空间中，特点：赋值给其他变量，赋的地址值。

三、面向对象的学习

三、1封装

1、面向对象和面向过程的区别：面向过程编程是一种以过程为中心的编程思想，它将一个复杂的任务分解成一系列顺序执行的步骤，即函数或子程序。在面向过程编程中，重点在于如何通过函数来组织和执行这些步骤。数据和操作数据的过程通常是分离的，数据通常作为函数的参数传递。 面向对象编程则更加强调数据和操作数据的方法结合在一起，也就是对象。对象是类的实例，包含数据（属性）和操作这些数据的方法（函数）。在OOP中，程序是由相互协作的对象组成的，每个对象都有自己的职责和功能。类是创建对象的模板，它定义了对象的结构和行为。继承、封装和多态是面向对象编程的三大特性。面向过程关注的是执行的步骤，而面向对象关注的是数据和操作数据的对象。面向对象提供了更高层次的抽象，使得代码更易于维护和扩展。

2、类：是对象共同特征的描述。

对象：是真实存在的具体东西。

注意：Java中必须先设计类才能获得对象，类一般一开始要大写，可以有多个类但只有一个是public。

对象的构造：类名 对象名=new 类名（）；       public class Student{修饰符 类名（参数）{方法体；}

            Phone p=new Phone();

3、熟悉命名规范：总结起来，类命名规范包括使用驼峰命名法、选择有意义的名字、使用名词或名词短语、避免过长的类名、使用单数形式、避免使用缩写、遵循编程语言的命名约定、避免使用关键字、使用名词修饰词的组合、保持一致性等。通过遵循这些规范，可以使类名更加具有描述性、易懂、易用，并提高代码的可读性和可维护性。

4、理解面向对象中基本数据类型和引用数据类型：

同上。

5、理解this关键字：（1）就近原则（2）this作用：可以区别成员变量和局部变量

6、理解成员和局部的概念：成员变量：类中方法外的变量。

                         局部变量：方法中的变量。

三、2继承

1. 类之间的继承：Java中提供一个关键字extends，用这个关键词可以让一个类和另一个类建立起继承关系。当类与类之间，存在相同的内容，并满足子类是父类中的一种。继承是面向对象的三大特征之一，可以让类跟类之间产生子父关系。可以把多个子类中重复的代码抽取到父类当中，子类可以直接使用，减小代码冗杂提高代码的复用性。
2. 继承方式：Java继承分为单继承和多重继承。单继承是指一个子类最多只能有一个父类。多继承是一个子类可以有二个以上的父类。
3. 继承的结构：public class 子类 extends 父类{}
4. 子类和父类之间的关系：Student称为子类（派生类），Person称为父类（基类或超类）

子类可以的到父类的属性和行为，子类可以使用，子类可以在父类的基础上新增其他的功能，子类更强大。

三、3多态

1. 什么是多态：同类型的对象，表现出不同的形态；表现形式：父类类型 对象名称=子类对象；前提：（1）有继承关系（2）有父类引用指向子类对象  Fu f=new Zi();（3）有方法重写
2. 理解接口与抽象类之间的关系与区别：

1. 联系：抽象类和接口都不能被实例化。如果要实例化，则抽象类变量必须指向某一个实现其所有抽象方法的子类对象，接口变量必须指向某一个实现其所有抽象方法的实现类对象。 未能实现抽象类或接口中的所有方法时，抽象类子类或接口实现类都必须是抽象类。
2. 区别：

三、4常用API：

1、string：Java.lang.String.类代表字符串，Java程序中的所有字符串文字都为此类的对象。字符串的内容是不会改变的，它的对象在创建后是不能被更改的。

2、ArrayList：操作数组的工具，ArrayList就是动态数组，用MSDN中的说法，就是Array的复杂版本，它提供了动态的增加和减少元素，实现了ICollection和IList接口，灵活的设置数组的大小等好处。

四、其他

1、理解static静态方法及变量：

（1）静态变量：表示静态，是Java中的一个修饰符，可以修饰成员方法，成员变量；被static修饰的成员变量叫做静态变量；特点：被该类所有对象共享；调用方式：类名调用；对象名调用。

（2）静态方法：特点：多用在测试类和工具类中，javabean类中很少用；调用方式：类名调用；对象名调用。

2、理解final修饰的常类：方法：表明该方法是最终方法，不能被重写；类：最终类不能被继承；变量叫做常量，只能被赋值一次；

3、理解代码块：局部、构造、静态；

（1）局部作用：提前结束变量的生命周期（已淘汰）

（2）构造作用：抽取构造方法中的重复代码（不够灵活）

（3）静态作用：数据的初始化（重点）

4、理解内部类：定义：在一个类的里面在定义一个类，内部类表示的事物是外部类的一部分，其单独出现没有任何意义。

特点：可以直接访问外部类的成员，包括私有；外部类要访问内部类的成员必须创造对象。

内部类分为：成员、静态、局部、匿名（重点）；

（1）写在成员位置的属于外部类的成员；成员内部类可以被一些修饰符所修饰如private\protected\public\static\默认；

在成员内部类里面，JDK16之前不能定义静态变量，JDK 16开始才可以定义静态变量。

获取成员内部类对象：（1）在外部类中编写方法，对外提供内部类的对象

直接创建格式：外部类名.内部类名 对象名=外部类对象.内部类对象。

1. 静态：静态内部类只能访问外部类中的静态变量和静态方法

格式：外部类名.内部类名 对象名=new 外部类名.内部类名（）；

调用非静态方法的格式：先创建对象再用对象调用。

调用静态方式的格式：外部类名.内部类名.方法名（）

将内部类定义在方法里面就叫做局部内部类，类似于方法里面的局部变量。

外界是无法直接使用，需要在方法内部创建对象并使用。

该类可以直接访问外部类的成员，也可以访问方法内的局部变量。

（3）匿名：本质上就是隐藏了名字的内部类，可以在成员位置也可以在局部位置

格式：new 类名或者接口名（）{重写方法；}

细节：包含了继承或实现，方法重写，创建对象，整体就是一个类的子类对象或者接口的实现类对象。

使用场景：当方法的参数是接口或者类时，以接口为例，可以传递这个接口的实现类对象，如果实现类只要使用一次，就可以用匿名内部类简化代码。