Java部分基础知识总结_int i=1; string s="hello"; if(s=="hello"){i++;}sys-CSDN博客

本文链接：https://blog.csdn.net/m0_46304107/article/details/109496198

Java基础总结

1、Java起源

Java语言早期由Sun公司开发，后期被甲骨文公司收购。
Java之父–詹姆斯高斯林， Java语言早期名字叫做：Oak，由C++演变而来。

2、Java的三个平台

JavaSE (标准版，用于桌面应用开发)
JavaME (微缩版，用于早期嵌入式开发)
JavaEE (企业版，用于企业级应用开发)

3、Java语言的特点

跨平台性
面向对象
安全性
多线程
健壮性

4、Java语言的特性

封装
- 是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
- 处：将变化隔离；便于使用；提高重用性；安全性。
- 封装原则：将不需要对外提供的内容都隐藏起来，把属性都隐藏，提供公共方法对其访问。
继承
- 继承就是类之间的继承，使用extends来实现，从而实现代码的复用。
多态
- 某一种事物有不同的具体的体现就是多态。
- 多态体现在：重写、重载、对象实例化。
- 多态的好处：提高了程序的扩展性。
- 多态的弊端：当父类引用指向子类对象时，虽然提高了扩展性，但是只能访问父类中具备的方法，不可以访问子类中特有的方法。

5、JDK & JRE & JVM

JDK(Java Development Kit Java开发工具包)，JDK是提供给Java开发人员使用的，其中包含了java的开发工具，也包括了JRE。其中的开发工具：编译工具(javac.exe) 打包工具(jar.exe)、执行工具(java.exe)等。
JRE(Java Runtime Environment Java运行环境) ，包括Java虚拟机(JVM Java Virtual Machine)和Java程序所需的核心类库等，如果想要运行一个开发好的Java程序，计算机中只需要安装JRE即可。
JVM (Java Virtual Machine) 是Java虚拟机，Java程序需要运行在虚拟机上，不同的平台有自己的虚拟机，因此Java语言可以实现跨平台。
JDK>JRE>JVM

6、配置环境变量

为了能够在任何位置都可以找到Java环境。
系统环境变量：PATH: %JAVA_HOME%\bin;
CLASSPATH:%JAVA_HOME%\lib;
验证是否配置成功：进入命令行窗口，执行java -version，成功显示版本号即成功配置。

7、开发工具

Eclipse
MyEclipse
IntelliJ IDEA

8、Java程序的执行过程

java源文件，编译器(javac命令)进行编译。
生成class文件(存放的字节码)。
然后解析器（执行java命令）解析class文件。
最后生成计算机识别的二进制编码。

9、标识符命名规则

可以由数字、字母、下划线、$符号组成，但是不能是关键词，不能以数字开头。不能重复命名。
全局变量(成员变量、类变量)：
- 可以供当前类的多个方法使用；
- 定义在类中；
- 成员变量存在于堆内存中，随着对象的产生而存在，消失而消失。
局部变量：
- 定义在方法中或者方法参数；
- 只能作用于当前方法；
- 没有初始值；
- 局部变量存在于栈内存中，随着所属区域的运行而存在，结束而释放。
常量：
- 只能声明在类中，使用final关键词声明，必须赋初始值，不能再次赋值。

10、注释类型

//	单行注释
/* */	多行注释
/** */	文档注释

11、Java的两种数据类型

引用数据类型：数组、类、接口。
基本数据类型

byte（整型）	1字节	-128(-27)—127(27-1)
short （整型）	2字节	-32768(-2^15)— 32767(2^15-1)
int（整型）	4字节	-2,147,483,648(-231)—2,147,483,647(231 - 1)
long（整型）	8字节	9,223,372,036,854,775,808(-2^63)— 9,223,372,036,854,775,807(2^63 -1)
float（浮点型）	4字节	单精度
double（浮点型）	8字节	双精度（浮点数的默认类型为double类型）
char（字符型）	2字节	字符节
boolean（布尔类型）	1字节	布尔型只有两个取值true和false

级别从低到高：byte,char,short(这三个平级)–>int–>float–>long–>double
自动类型转换：从低级别到高级别，系统自动转的；
强制类型转换：什么情况下使用?把一个高级别的数赋给一个别该数的级别低的变量；
Java中默认整数为int类型，小数为double类型；
字符char是否可以存放一个汉字？可以，因为一个字符占2个字节，一个汉字两个字节；
整型初始值默认0 浮点型默认0.0 布尔类型默认false 引用数据类型默认null

12、Java中数据类型转换

隐式转换：系统默认将其转换为我们需要的数据类型；
强制转换：=号两边数据类型不同时，可以通过,前面加(类型)转换。例如：int j=10;float f=100.123; int j=(int)f;
基本数据类型之间规则：
- 整型之间数据类型强制转换规则：long->int->short->byte
- 浮点型之间：double->float
- char和整型 : 整型->char
- char和浮点型: 浮点型->char
- 浮点型和整型 : (double/float)->(long/int/short/byte) 且小数点舍去

13、算数运算符

+	相加
-	相减
*	相乘
/	相除
%	取余
++	写在前边是先运算出结果赋值后执行其他，写在后边先执行再赋值
- -	写在前边是先运算出结果赋值后执行其他，写在后边先执行在赋值
+=	count = count+5 等于 count +=5;
-=	count = count-5 等于 count -= 5;
*=	count = count *5 等于 count = 5;
/=	count = count /5 等于 count /= 5;

i++ 表示i先参与运算，然后再自身加1
++i 表示i先自身加1，然后再参与运算

14、逻辑运算符

&&	与， &&两边条件必须返回boolean类型，两边同时为true则结果为true
ll	或，两边条件有一个满足true，则结果为true
<	小于
>	大于
>=	大于等于
<=	小于等于
==	等于
!=	不等于

class HelloWorld{
	public static void main(String args[]){
        boolean flag = true;
        boolean flag2 = false;
        // 与 有一个为假，结果就是假
        System.out.println(flag & flag2);
        // 或 有一个是真，结果就是真
        System.out.println(flag | flag2);
        // 非 取反
        System.out.println(!flag);
        // 异或  相同为假，不同为真
        System.out.println(flag ^ flag2)
    }
}

int n=10;
int m=100;
boolean f_2=(n>m)&&((n=100000)<100); 
System.out.println(n);//n的值还是10
boolean f_3=(m>n)||((n=100000)<100); //n的值还是10

15、判断语句&循环语句break&continue

if语句（判断语句）

// 引入我想要的东西
import java.util.Scanner;
public class Text{
	public static void main(String args[]){
		// 创建一个scanner
		// System.in是系统标准输入
		Scanner scanner = new Scanner(System.in);
		//程序会等着程序员输入一个数字
		int i = scanner.nextInt();
		System.out.println(i);
		if (i<4){
			System.out.println("您输入的数字小于4");
		} else if(i >= 4 & i< 10) {
			System.out.println("您输入的数大于4小于10");
		}else {
			System.out.println("您输入的数大于10");
		}
		
	}
}

switch语句（判断语句）

// 引入我想要的东西
import java.util.Scanner;
public class Text{
	public static void main(String args[]){
		// 创建一个scanner
		// System.in是系统标准输入
		Scanner scanner = new Scanner(System.in);
		//程序会等着程序员输入一个数字
		int i = scanner.nextInt();
		switch (i){
			case 1:
				System.out.println("查询话费");
				break;
			case 2:
				System.out.println("查询流量");
				break;
				
		}
		
	}
}

while语句（循环语句）

// 引入我想要的东西
import java.util.Scanner;
public class Text{
	public static void main(String args[]){
		// 一直会执行
		int i = 10;
		while (i> 0){
			System.out.println(i);
			i--;
		}
		System.out.println("执行完了");
	}
}

do while语句（循环语句）

// 引入我想要的东西
import java.util.Scanner;
public class Text{
	public static void main(String args[]){
		// 一直会执行
		int i = 10;
		// 先判断一下是不是满足条件，然后执行
		while (i > 0) {
			i--;
			System.out.println(i);
			
		}
		System.out.println("-----------------------");
		// 先执行一下，然后判断，看看要不要继续执行
		do {
			i--;
			System.out.println(i);
			
		}
		while (i> 0);
		
		System.out.println("执行完了");
	}
}

for语句（循环语句）

import java.util.Scanner;
public class Text{
	public static void main(String args[]){
		for (int i = 0;i < 10;i++){
			System.out.println(i);
		}
	}
}

break和continue

// 引入我想要的东西
import java.util.Scanner;
public class Text{
	public static void main(String args[]){
		// 结束当前循环
	for (int j = 1;j <= 100;j++){
		if(j == 10){
			break;
		}
		System.out.println(j);
	}
	System.out.println("------------------");
// 跳过本次循环，继续执行下一次循环
	for (int j = 1;j <= 100;j++){
		if(j == 10){
			continue;
		}
		System.out.println(j);
		}
	}
}
// for循环可以打标签，break 标签名可以打断任何标签
flag:for (int i = 1;i<= 100;i++){
    for (int j = 1;j <= 100;j++){
        if(j == 10){
			break flag;
        System.out.println(j);    
		}
    }
}

break 表示退出整个循环或者判断
continue 只能用于循环体中，表示退出当前循环，继续下一次循环

16、数组

先定义、开辟空间、赋值在使用
java中数组长度不可变
数组下标从0开始

// 类型[] 名字 = new int[3];
int[] nums = new int[3];
nums [0] = 1
nums [1] = 2
nums [2] = 3
// 定义和赋值在一起
int[] nums = {1,2,3,4};

如何不通过第三个变量交换两个变量的值

int a=10;
int b=20;
a=a+b;//a:30 b:20
b=a-b;//a:30 b:10
a=a-b;//a:20 b:10

二维数组：

String[][] items=new String[2][3];
//items[0]={"","",""};错误的
// items[0]=new String[4];对

长度查询

public class ArrayText{
	public static void main(String args[]){
		int[] nums = new int[3];
		nums[0] = 1;
		nums[1] = 2;
		nums[2] = 3;
		int i = nums.length;
		System.out.println(i);
	}
}

根据下标查询内容

public class ArrayText{
	public static void main(String args[]){
		int[] nums = {1,5,68,4,9,22};
			System.out.println(nums[2]);
	}
}

根据内容查询下标

public class ArrayText{
	public static void main(String args[]){
		int[] nums = {1,5,68,4,9,22};
		int target = -1;
		for(int i = 0;i < nums.length;i++){
			if (nums[i] == 68){
					target = i;
                	break;
			}
		}
		System.out.println(target);
	}
}

遍历

public class ArrayText{
	public static void main(String args[]){
		int[] nums = {1,5,68,4,9,22};
		for(int i = 0;i < nums.length;i++){
			System.out.println(nums[i]);
		}
	}
}

求数组中最大

public class ArrayText{
	public static void main(String args[]){
		int[] nums = {1,5,68,4,9,22};
		int max = nums[0];
		for(int i = 1;i < nums.length;i++){
			if(nums[i] > max){
				max = nums[i];
			}
		}
		System.out.println(max);
	}
}

求数组中最小

public class ArrayText{
	public static void main(String args[]){
		int[] nums = {1,5,68,4,9,22};
		int min = nums[0];
		for(int i = 1;i < nums.length;i++){
			if(nums[i] < min){
				min = nums[i];
			}
		}
		System.out.println(min);
	}
}

数组中位置互换

public class ArrayText{
	public static void main(String args[]){
		int[] nums = {1,5,68,4,9,22};
		int temp = nums[3];
		nums [3] = nums[0];
		nums [0] = temp;
		
		
		for(int i = 0;i < nums.length;i++){
			System.out.println(nums[i]);
		}
		
	}
}

冒泡排序

public class ArrayText{
	public static void main(String args[]){
		int[] nums = {1,5,68,4,9,22};
		for (int j = 0;j < nums.length-1;j++)
			for (int i = 0;i < nums.length-1;i++){
				if(nums[i]>nums[i+1]){
					int temp = nums[i];
					nums[i] = nums[i+1];
					nums[i+1] = temp;
					
				}
			}
		}
		
		for(int i = 0;i < nums.length;i++){
			System.out.println(nums[i]);
		}
		
	}
}

选择排序

public class ArrayText{
	public static void main(String[] args){
		int[] nums = {1,5,2,3,9,45,21,15};
		int min = nums[0];
		for (int i = 0; i < nums.length;i++){
			if(nums[i] < min){
				min = nums[i];
			}
		}
		for (int i = 0;i < nums.length;i++){
			System.out.println(nums[i]);
		}
	}
}

public class ArrayText{
	public static void main(String args[]){
		int[] nums = {1,5,68,4,9,22};
		for(int j = 0;j < nums.length-1;j++){
			int min = j;
			for (int i = j+1;i < nums.length;i++){
				if (nums[i] < nums[min]){
					min = i;
				}
			}
			int temp = nums[j];
			nums[j] = nums[min];
			nums[min] = temp;
		}
		for (int i = 0; i< nums.length; i++){
			System.out.println(nums[i]);
		}
	}
}

17、类：是一类事物的描述，程序中为class

属性：即一类事物具有的共有特点或者特性；程序中为全局变量（成员变量)
方法：一类事物具有的动作
类的定义和使用

class 类名称{
     属性
     方法
}

使用关键字new就可以创建类对象，使用对象.方法，对象.属性就可完成调用
抽象类: abstract
- 抽象类的特点：
  - 1：抽象方法只能定义在抽象类中，抽象类和抽象方法必须由abstract关键字修饰（可以描述类和方法，不可以描述变量）。
  - 2：抽象方法只定义方法声明，并不定义方法实现。非抽象的方法可以定义方法实现
  - 3：抽象类不可以被创建对象(实例化)。
  - 4：只有通过子类继承抽象类并覆盖了抽象类中的所有抽象方法后，该子类才可以实例化。否则，该子类还是一个抽象类。
- 抽象类的细节：
  - 1：抽象类中是否有构造方法？有，用于给子类对象进行初始化。
  - 2：抽象类中是否可以定义非抽象方法？可以。其实，抽象类和一般类没有太大的区别，都是在描述事物，只不过抽象类在描述事物时，有些功能不具体。所以抽象类和一般类在定义上，都是需要定义属性和行为的。只不过，比一般类多了一个抽象方法。而且比一般类少了一个创建对象的部分。
  - 3：抽象关键字abstract和哪些不可以共存？final ,private , static
  - 4：抽象类中可不可以不定义抽象方法？可以。抽象方法目的仅仅为了不让该类创建对象。
  - 5：抽象类中可以有普通的成员变量
  - 6：抽象类中可以有静态方法
接口：interface
- 接口的特点：
  - 1、接口是特殊抽象类，所有方法都是抽象方法，都是public访问权限，数据成员都是public，static，final
  - 不能被实例化，方法abstract关键词可以省略，但实际上还是抽象方法
  - 3、变量都是是常量，省略final关键词
  - 4、接口不能被实例化，只能通过implements来实现接口，一个实现类，可以实现多个接口
  - 5、接口可以继承接口
  - 6、实现以后要重写所有抽象方法，包括接口继承接口中的抽象方法
  - 7、接口中不能有构造方法
- 接口的好处：
  - 1、java由于单继承，接口可以弥补无法多继承的缺点
  - 2、好的程序要求高内聚低耦合，接口可以实现程序的解耦
  - 3、定义一种规范

18、面向对象三个过程

OOA面向对象分析
OOD面向对象设计
OOP面向对象编程

19、主方法的分析

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

1）保证该类的独立运行。
2）它是程序的入口。
3）它被jvm调用。
- Public：访问权限最大。
- static：不需要对象，直接类名即可。
- void：主方法没有返回值。
- main：主方法特定的名称。
- (String[] args)：主方法的参数，是一个字符串数组类型的参数，jvm调用main方法时，传递的实际参数是 new String[0]。

20、Java内存的总结

Java分了5片内存
- 1：寄存器。
- 2：本地方法区。
- 3：方法区。
- 4：栈。
- 5：堆。
栈：存储的都是局部变量 ( 方法中定义的变量，方法上的参数，语句中的变量 )；只要数据运算完成所在的区域结束，该数据就会被释放。
堆：用于存储数组和对象，也就是实体。啥是实体啊？就是用于封装多个数据的。
- 1：每一个实体都有内存首地址值
- 2：堆内存中的变量都有默认初始化值。因为数据类型不同，值也不一样。
- 3：垃圾回收机制。

21、IO流

流：
- 流是一组有序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。
Java中流的分类：
- 按照数据流向分：
  - 输入流：相对于内存，向内存中写入；
  - 输出流：相对于内存，从内存往外读；
- 按照流的数据传输的格式：
  - 字节流：以字节为单位读取；一般用于读写文件,读写诸如图象或声音等的二进制数据。
  - 字符流：以字符为单位读取；一般用于读写文件中文本内容。

22、XML解析

XML是一种可拓展文本标记语言；
常用于：数据存储、作为项目配置文件，系统之间数据传输的某种数据格式；
解析方式有：
- DOM
  - jdk自带的解析方式，事件驱动，不灵活，解析大文件效率低
- SAX
  - jdk自带的解析方式，树形结构方式解析操作xml，灵活，大文件效率高
- JDOM
  - 第三方工具包
- DOM4J：第三方工具包，最常用的一种解析方式

23、JDBC数据库连接

java提供的一组操作数据库的API；
常用接口有：
- Connection、
- ResultSet、
- PreparedStatement、
- Statement
下面是一般的jdbc连接执行流程代码示例
- 加载驱动
- 打开连接
- 执行查询
- 处理结果
- 清理环境

import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;

public class JDBCtest {

    public static void main(String[] args) {
        String sql = "SELECT * from student";
        // 当前的数据库链接；
        Connection connection = null;
        // 用于向数据库发送sql语句
        Statement statement = null;
        // 结果集，封装了从数据库查询的数据
        ResultSet resultSet = null;

        try {
            Class.forName("com.mysql.jdbc.Driver");
            connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/dbName", "root", "password");
            statement = connection.createStatement();
            resultSet = statement.executeQuery(sql);
            while (resultSet.next()) {
                System.out.print(resultSet.getInt("id") + " ");
                System.out.print(resultSet.getString("name") + " ");
                System.out.print(resultSet.getString("password") + " ");
                System.out.print(resultSet.getString("email") + " ");
                System.out.println();
            }
        } catch (Exception e) {
            System.out.println(e.getMessage());
        } finally {
            try {
                resultSet.close();
                statement.close();
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }

        }
    }

}