Python转java补充知识

java 学习笔记指路
基础知识

Python转java补充知识
Java中常见的名词解释

前端

【黑马程序员pink老师前端】HTML
【黑马程序员pink老师前端】JavaScript基础大总结
【黑马程序员pink老师前端】JavaScript函数与作用域
【黑马程序员pink老师前端】JavaScript对象

数据库

【黑马程序员数据库】数据库基础大总结
【黑马程序员数据库】数据库引擎
【黑马程序员数据库】数据库索引

SQL编程

【牛客】SQL刷题篇入门篇
【牛客】SQL刷题篇进阶篇

Java 框架

spring框架学习
Mybatis-plus 快速入门
Maven基础
Zookeeper初认识
HTTP简介
Tomcat
Servlet
vue入门

1. java名词解释

先看下这个大佬写的吧，感觉有点多，等我学差不多了来精简一下

2.基础语法之间的差别

	Python	java
单行注释	#	//
多行注释	''' '''	/* */
区分大小写	不区分	区分（尤其是调用方法的时候首字母看看是不是大写）
与或非	按位与& 按位或`	逻辑与and 逻辑或or` 逻辑非not
判等	==	基本数据类型 ==，string判相等 equals()
打印	print	printf主要是继承了C语言的printf的一些特性，可以进行格式化输出；print就是一般的标准输出，但是不换行；println和print基本没什么差别，就是最后会换行

2.1 循环、条件

2.1.1 while

while( 布尔表达式 ) {
  //循环内容
}

对于 while 语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。

do {
       //代码语句
}while(布尔表达式);

2.1.2 for

for(初始化; 布尔表达式; 更新) {
    //代码语句
}

• 最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
• 然后，检测布尔表达式的值。如果为 true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。
• 执行一次循环后，更新循环控制变量。
• 再次检测布尔表达式。循环执行上面的过程。

2.1.3 if

if(布尔表达式)
{
   //如果布尔表达式为true将执行的语句
}

if(布尔表达式){
   //如果布尔表达式的值为true
}else{
   //如果布尔表达式的值为false
}

if(布尔表达式 1){
   //如果布尔表达式 1的值为true执行代码
}else if(布尔表达式 2){
   //如果布尔表达式 2的值为true执行代码
}else if(布尔表达式 3){
   //如果布尔表达式 3的值为true执行代码
}else {
   //如果以上布尔表达式都不为true执行代码
}

2.1.4 switch case

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

2.1.5 三目运算符

针对这种复杂的IF-ELSE结构，有一种简便的运算方法，即三目运算符。a条件判断?true则a=c:false则有a=d,举个🌰。
a>0:1:2;
当a大于0的时候a=1,否则a=2，这样子是不是方便了很多呢。

2.1.6 break、continue

必须在循环里才能用 else里不能用
break 跳出最里层的循环，并且继续执行该循环下面的语句。
continue 立刻跳转到下一次循环的迭代。

2.2 Java 关键字

类别	关键字	说明
访问控制	private	私有的
	protected	受保护的
	public	公共的
	default	默认
类、方法和变量修饰符	abstract	声明抽象
	class	类
	extends	扩充,继承
	final	最终值,不可改变的
	implements	实现（接口）
	interface	接口
	native	本地，原生方法（非 Java 实现）
	new	新,创建
	static	静态
	strictfp	严格,精准
	synchronized	线程,同步
	transient	短暂
	volatile	易失
程序控制语句	break	跳出循环
	case	定义一个值以供 switch 选择
	continue	继续
	default	默认
	do	运行
	else	否则
	for	循环
	if	如果
	instanceof	实例
	return	返回
	switch	根据值选择执行
	while	循环
错误处理	assert	断言表达式是否为真
	catch	捕捉异常
	finally	有没有异常都执行
	throw	抛出一个异常对象
	throws	声明一个异常可能被抛出
	try	捕获异常
包相关	import	引入
	package	包
基本类型	boolean	布尔型
	byte	字节型
	char	字符型
	double	双精度浮点
	float	单精度浮点
	int	整型
	long	长整型
	short	短整型

变量引用 super 父类,超类 this 本类 void 无返回值 保留关键字 goto 是关键字，但不能使用 const 是关键字，但不能使用

3. 类、实例

与Python中不同.py之间的函数使用都需要import不同。在java中，不同文件夹（包）下的类使用前才需要导入包，同一个包下不需要。

3.1 类

3.1.1 修饰符

访问控制

修饰符	当前类	同一包内	子孙类(同一包)	子孙类(不同包)	其他包
public	Y	Y	Y	Y	Y
protected	Y	Y	Y	Y/N	N
default	Y	Y	Y	N	N
private	Y	N	N	N	N

3.1.2 Number & Math 类

Integer、Long、Byte、Double、Float、Short 都是抽象类 Number 的子类

Java 的 Math 包含了用于执行基本数学运算的属性和方法，如初等指数、对数、平方根和三角函数。

序号	方法	描述
1	xxxValue()	将 Number 对象转换为xxx数据类型的值并返回。
2	compareTo()	将number对象与参数比较。
3	equals()	判断number对象是否与参数相等。
4	valueOf()	返回一个 Number 对象指定的内置数据类型
5	toString()	以字符串形式返回值。
6	parseInt()	将字符串解析为int类型。
7	abs()	返回参数的绝对值。
8	ceil()	返回大于等于( >= )给定参数的的最小整数，类型为双精度浮点型。
9	floor()	返回小于等于（<=）给定参数的最大整数 。
10	rint()	返回与参数最接近的整数。返回类型为double。
11	round()	它表示四舍五入，算法为 Math.floor(x+0.5)，即将原来的数字加上 0.5 后再向下取整，所以，Math.round(11.5) 的结果为12，Math.round(-11.5) 的结果为-11。
12	min()	返回两个参数中的最小值。
13	max()	返回两个参数中的最大值。
14	exp()	返回自然数底数e的参数次方。
15	log()	返回参数的自然数底数的对数值。
16	pow()	返回第一个参数的第二个参数次方。
17	sqrt()	求参数的算术平方根。
18	sin()	求指定double类型参数的正弦值。
19	cos()	求指定double类型参数的余弦值。
20	tan()	求指定double类型参数的正切值。
21	asin()	求指定double类型参数的反正弦值。
22	acos()	求指定double类型参数的反余弦值。
23	atan()	求指定double类型参数的反正切值。
24	atan2()	将笛卡尔坐标转换为极坐标，并返回极坐标的角度值。
25	toDegrees()	将参数转化为角度。
26	toRadians()	将角度转换为弧度。
27	random()	返回一个随机数。

3.1.3 String 类

判断String相等

s1.equals(s2)//boolean
s1.equalsIgnoreCase(s2)//忽略大小写

类方法

length() ：返回此字符串的长度。
concat(String str) ：将指定的字符串连接到该字符串的末尾。
charAt(int index) ：返回指定索引处的 char值。
indexOf(String str) ：返回指定子字符串第一次出现在该字符串内的索引。
substring(int beginIndex) ：返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。
substring(int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到endIndex-1截取字符串。

转换

char[] toCharArray() ：将此字符串转换为新的字符数组。
replace(CharSequence target, CharSequence replacement) ：将与target匹配的字符串使用replacement字符串替换。
String toUpperCase()：字符串全部转成大写
String toLowerCase()：字符串全部转成小写

分割

String[] split(String regex) ：将此字符串按照给定的正则表达式（regex）拆分为字符串数组。

查找

boolean contains(CharSequence s): 判断字符串中是否包含指定字符。

StringBuilder/StringBuffer

StringBuild和StringBuffer是字符串变量，是可更改的。
区别：在线程上，StringBuilder是线程不安全的，StringBuffer是线程安全的；但StringBuilder在单线程上比StringBuffer快。
方法：
reverse()：反转
toString()：转成String
append()：尾部添加，添加什么都可以
insert（int offset,String str）：将str插入到当前字符串中offset指向的位置上；
delete（int start,int end）：将当前字符串中从start（包含）开始到end（不包含）之间的内容移除；
replace（int start,int end , String str）：将当前字符串中start到end（不包含）之间的内容全部用str的内容替换；
substring（）/indexOf（）：同String

3.2 实例（对象）

3.2.1 创建对象：

类名 对象变量 = new 类名();

3.2.2 调用对象变量、方法：

对象.成员变量; 对象.成员方法(…);

3.2.3 对象内存图

3.3 抽象类（abstract）

抽象类是半成品类，没有完成的类； 抽象方法 ：没有代码，只有方法的定义，抽象类不能创建实例，主要用来被继承。

修饰符 abstract class 类名{  }
修饰符 abstract 返回值类型 方法名称(形参列表);

3.3.1

3.3.2 继承抽象类注意

一个类如果继承了抽象类，那么这个类必须重写完抽象类的全部抽象方法。否则这个类也必须定义成抽象类。

3.3.3 作用

可以被子类继承、充当模板的、同时也可以提高代码复用。

3.3.4 特征和注意事项

有得有失: 得到了抽象方法，失去了创建对象的能力。
抽象类为什么不能创建对象？
类有的成员（成员变量、方法、构造器）抽象类都具备
抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
一个类继承了抽象类必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类。
不能用abstract修饰变量、代码块、构造器。

3.3.5 final和abstract是什么关系？

互斥关系。abstract定义的抽象类作为模板让子类继承，final定义的类不能被继承。抽象方法定义通用功能让子类重写，final定义的方法子类不能重写。

3.4 常量

3.4.1 命名规范

英文单词全部大写，多个单词下划线连接起来

3.4.2 说明

使用了public static final修饰的成员变量，必须有初始化值，而且执行的过程中其值不能被改变。

3.5 内部类

定义在类内部、方法内部或局部代码块内部的类，用来辅助外部实例运算，封装局部数据，或局部
的运算逻辑。

3.5.1 局部内部类

局部定义的类型，类似于局部变量，有作用范围，只能在局部代码块内使用这种类型
局部内部类中，使用外面的局部变量，必须加 final，jdk1.8，缺省。

3.5.2 匿名内部类

Weapon w = new Weapon() {...};

{} - 匿名类
new - 新建匿名类的实例
Weapon - 父类型
() - super()，可传参数super(1,2,3)

4.继承（extends关键字）

4.1 语法：

public class 子类 extends 父类{}

4.2 优点：

• 继承就是java允许我们用extends关键字，让一个类和另一个类建立起一种父子关系。
• 提高代码复用性，减少代码冗余，增强类的功能扩展性。

4.3 特点

• 子类继承父类，子类可以得到父类的属性和行为，子类可以使用，但是子类不能继承父类的构造器。
• Java中子类更强大
• 子类们相同特征（共性属性，共性方法）放在父类中定义。
• 子类独有的的属性和行为应该定义在子类自己里面。
• Java是单继承模式：一个类只能继承一个直接父类。
• Java中所有的类都是Object类的子类，要么直接继承了Object , 要么默认继承了Object , 要么间接继承了Object
• 子类可以继承父类的私有成员，只是不能直接访问。

4.4 继承后：成员变量、成员方法的访问特点

• 在子类方法中访问成员（成员变量、成员方法）满足：就近原则，子类局部范围没有找子类成员范围、子类没有找父类、父类没有就报错！
• 如果子父类中出现了重名的成员，此时如果一定要在子类中使用父类通过super关键字，指定访问父类的成员。格式：super.父类成员变量/父类成员方法

4.5 重写

4.5.1 定义

在继承体系中，子类出现了和父类中一模一样的方法声明，我们就称子类这个方法是重写的方法。

4.5.2 应用场景

当子类需要父类的功能，但父类的该功能不完全满足自己的需求时。子类可以重写父类中的方法。

4.5.3 重写注释

• @Override是放在重写后的方法上，作为重写是否正确的校验注解。
• 加上该注解后如果重写错误，编译阶段会出现错误提示。
• 建议重写方法都加@Override注解，代码安全，优雅！

4.5.4 注意事项和基本要求

• 重写方法的名称和形参列表应该与被重写方法一致。
• 私有方法不能被重写。
• 子类重写父类方法时，访问权限必须大于或者等于父类被重写的方法的权限。

4.6 继承后：子类构造器的特点

子类中所有的构造器默认都会先访问父类中无参的构造器，再执行自己。
怎么调用：子类构造器的第一行语句默认都是：super()，不写也存在。
如果父类中没有无参数构造器，只有有参构造器，会报错。因为子类默认是调用父类无参构造器的。可以通过书写 super(…)，手动调用父类的有参数构造器。

5. 封装

5.1 什么是封装

• 面向对象的三大特征之一，合理隐藏，合理暴露。
• 一般会把成员变量使用private隐藏起来。
• 通过getter和setter方法暴露其访问。

5.2 封装的优点

• 加强了程序代码的安全性。
• 适当的封装可以提升开发效率，同时可以让程序更容易理解与维护。

5.3 标准javabean

标准JavaBean须满足如下要求：

1. 成员变量使用 private 修饰。
2. 提供每一个成员变量对应的 setXxx() / getXxx()。
3. 必须提供一个无参构造器（创建类时默认带无参构造器，但是人工创建有参构造器后无参构造器就没了，需要自己创建无参构造器）。

6. 多态

6.1 定义

同类型的对象，执行同一个行为，会表现出不同的行为特征。就是继承之后重写。
案例解释： 比如，小猫、小狗、小猪都是小动物，每种小动物都需要吃东西，所以我们可以统一设置他们都必须吃，但是每种小动物的习性不一样，那这个就可以设置成小动物自己特有的功能，多态对象只能调用父类中定义子类中重写的功能，并不能调用子类的特有功能，这样就实现了代码的统一。

6.2 语法

父类类型 对象名称 = new 子类构造器;
接口     对象名称 = new 实现类构造器;	

6.3 多态中成员访问特点

方法调用：编译看左边，运行看右边。
变量调用：编译看左边，运行也看左边。（多态侧重行为多态）

6.4 多态的前提

有继承/实现关系；
有父类引用指向子类对象；
有方法重写。

6.5 优点

• 在多态形式下，右边对象可以实现解耦合，便于扩展和维护。
• 定义方法的时候，使用父类型作为参数，该方法就可以接收这父类的一切子类对象，体现出多态的扩展性与便利。

6.6 多态下引用数据类型的类型转换

自动类型转换（从子到父)： 子类对象赋值给父类类型的变量指向。
强制类型转换吗（从父到子)

• 此时必须进行强制类型转换：子类 对象变量 = (子类)父类类型的变量
• 作用：可以解决多态下的劣势，可以实现调用子类独有的功能。
• 注意： 如果转型后的类型和对象真实类型不是同一种类型，那么在转换的时候就会出现ClassCastException

Java建议强转转换前使用instanceof判断当前对象的真实类型，再进行强制转换

变量名 instanceof 真实类型

判断关键字左边的变量指向的对象的真实类型，是否是右边的类型或者是其子类类型，是则返回true，反之。

7. 枚举

7.1 定义格式

修饰符 enum 枚举名称{
            第一行都是罗列枚举类实例的名称。
}

7.2 注意

• 枚举类都是继承了枚举类型：java.lang.Enum
• 枚举都是最终类，不可以被继承。
• 构造器都是私有的，枚举对外不能创建对象。
• 枚举类的第一行默认都是罗列枚举对象的名称的。
• 枚举类相当于是多例模式。

8. API

8.1 接口（interface）

应用程序编程接口。极端的抽象类，结构设计工具，用来解耦合

8.1.1 接口定义

public interface 接口名 {
       // 常量
       // 抽象方法
} 

注意事项：

1. 接口中的成员都是public修饰的，写不写都是，因为规范的目的是为了公开化
2. 接口只能定义常量
3. 接口只能定义抽象方法
4. 接口只能继承接口，不能继承普通的类和抽象类
5. 接口是没有构造方法

8.1.2 接口类实现（implements）

实现接口的类称为实现类

修饰符 class 实现类 implements 接口1, 接口2, 接口3 , ... {
}

接口可以被类单实现，也可以被类多实现

8.1.3 接口调用步骤

1. 定义接口
2. 定义接口类实现
3. 调用

8.2 常用API

API的使用步骤

1. 打开帮助文档
2. 点击显示，找到索引，找到输入框，在输入框中输入你要查找的类
3. 看该类的所在包，对于java.lang包（提供了java中的基础类，包括基本Object类、Class类、String类、基本类型的包装类、基本的数学类等等最基本的类）下面的类不需要导包，其他都需要。
   

8.2.1 Object

如果一个类不继承其他类，则默认继承Object类
方法：

1. toString 方法：父类toString()方法存在的意义就是为了被子类重写，以便返回对象的内容信息
2. equals 方法：默认是与另一个对象比较地址是否一样。父类equals方法存在的意义就是为了被子类重写，以便子类自己来定制比较规则。让子类重写，以便比较2个子类对象的内容是否相同。

8.2.2 Objects

方法名	说明
public static boolean equals(Object a, Object b)	比较两个对象的，底层会先进行非空判断，从而可以避免空指针异常。再进行equals比较
public static boolean isNull(Object obj)	判断变量是否为null ,为null返回true ,反之

8.2.3 StringBuilder

8.2.4 Math

8.2.5 System

8.2.6 BigDecimal

9. JDBC

9.1 操作流程

第一步：编写Java代码
第二步：Java代码将SQL发送到MySQL服务端
第三步：MySQL服务端接收到SQL语句并执行该SQL语句
第四步：将SQL语句执行的结果返回给Java代码

9.2 代码步骤

第一步：导入驱动jar包，建议建一个lib文件夹，将jar包都放在一起

第二步：注册驱动
会报错，需要抛出错误throws Exception

Class.forName("com.mysql.jdbc.Driver");

第三步：获取连接

String url="jdbc:mysql://127.0.0.1:3306/kettle_test";
String username="root";
String Password="123456";
Connection conn = DriverManager.getConnection(url, username, password);

第四步：定义SQL语句

String sql = "sql语句" ;

第五步：建立SQL执行对象（Statement）

Statement stmt = conn.createStatement();

第六步：执行SQL

// 执行DDL、DML语句
String sql=stmt.executeUpdate(sql);  
// 执行DQL语句
ResultSet rs = stmt.executeQuery(sql);

第七步：处理返回结果
第八步：释放资源

stmt.close();
conn.close();

9.3 JDBC API详解

9.3.1 注册驱动（DriverManager）

Class.forName("com.mysql.jdbc.Driver"); 就可以加载 Driver 类。加载 Driver 类，静态代码块就会执行 DriverManager 对象的 registerDriver() 方法。registerDriver方法是用于注册驱动的。

数据库连接（getConnection）

DriverManager.getConnection(链接路径, 用户名, 密码)

ResultSet对象

提供的方法

boolean next()

• 将光标从当前位置向前移动一行
• 判断当前行是否为有效行
  方法返回值说明：
• true ： 有效航，当前行有数据
• false ： 无效行，当前行没有数据

xxx getXxx(参数)：获取数据

• xxx : 数据类型；如： int getInt(参数) ；String getString(参数)
• 参数
• int类型的参数：列的编号，从1开始
• String类型的参数： 列的名称

10.构造器

构造器是一种方法，就像人是一种哺育动物。

构造器作用

类中没有定义构造器的时候，默认无参构造器。

修饰符

修饰符用来定义类、方法或者变量，通常放在语句的最前端。Java提供的修饰符主要分为以下两类：

• 访问修饰符
• 非访问修饰符

Java中包含四种访问修饰符，可以使用访问修饰符来保护对类、变量、方法和构造方法的访问：

• default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
• private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
• public : 对所有类可见。使用对象：类、接口、变量、方法
• protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

默认访问修饰符-不使用任何关键字

this关键字

this关键字代表当前对象的地址，不是类。
this.属性名称：指的是访问类中的成员变量，而不是对象中的，用来区分成员变量和局部变量（重名问题）。
this.方法名称：访问本类的成员方法
this(); ：访问本类的构造方法， ()中可以有参数的 如果有参数 就是调用指定的有参构造。this() 不能使用在普通方法中，只能写在构造方法中，必须是构造方法中的第一条语句。

构造器和方法（函数）的区别：

区别

1、功能和作用的不同

• 构造器是用来创建一个对象，同时可以给属性做初始化。
• 方法的作用是仅仅是功能函数，为了执行java代码。

2、修饰符，返回值和命名的不同
构造器和方法在下面三个方便的区别：修饰符，返回值，命名。
和方法一样，构造器可以有任何访问的修饰： public, protected, private或者没有修饰（通常被package 和 friendly调用）. 不同于方法的是，构造器不能有以下非访问性质的修饰： abstract, final, native, static, 或者 synchronized。

3、返回类型
方法必须要有返回值，能返回任何类型的值或者无返回值（void），构造器没有返回值，也不需要void。
4、命名
构造器使用和类相同的名字，而方法则不同。按照习惯，方法通常用小写字母开始，而构造器通常用大写字母开始。
构造器通常是一个名词，因为它和类名相同；而方法通常更接近动词，因为它说明一个操作。

5、调用：
构造方法：只有在对象创建的时候才会去调用，而且只会调用一次。
一般方法：在对象创建之后才可以调用，并且可以调用多次。

11.static关键字

static是什么？

static是 java 语言中常见关键字，就像int,break,while,for等一样，都属于关键字。

在堆中存储在同一个内存空间，不会随着数据的更新开辟新的存储位置。但是不是说一个类只能定义一个static属性

static关键字使用注意事项

1. 静态方法只能访问静态的成员，不可以直接访问实例成员。可以创建实例之后再访问实例成员。
2. 实例方法可以访问静态的成员，也可以访问实例成员。
3. 静态方法中是不可以出现this关键字的。 this代表当前对象的地址，静态方法使用类调的，不是用对象。

static关键字使用方法

static关键字的四种用法

12. final关键字

final 关键字是最终的意思，可以修饰（方法，变量，类）

final的作用

修饰方法：表明该方法是最终方法，不能被重写。
修饰变量：表示该变量第一次赋值后，不能再次被赋值(有且仅能被赋值一次)。
修饰类：表明该类是最终类，不能被继承。

注意事项

• final修饰的变量是基本类型：那么变量存储的数据值不能发生改变。
• final修饰的变量是引用类型：那么变量存储的地址值不能发生改变，但是地址指向的对象内容是可以发生变化的。

13. 设计模式

14. 抛出异常

JAVA抛出异常的三种形式