Python转java补充知识

目录

• 1. java名词解释
• 2.基础语法之间的差别

• 2.1 循环、条件

• 2.1.1 while
• 2.1.2 for
• 2.1.3 if
• 2.1.4 switch case
• 2.1.5 三目运算符
• 2.1.6 break、continue

• 2.2 Java 关键字

• 3. 类、实例

• 3.1 类

• 3.1.1 修饰符
• 3.1.2 Number & Math 类
• 3.1.3 String 类

• 判断String相等
• 类方法
• 转换
• 分割
• 查找
• StringBuilder/StringBuffer

• 3.2 实例（对象）

• 3.2.1 创建对象：
• 3.2.2 调用对象变量、方法：
• 3.2.3 对象内存图

• 3.3 抽象类（abstract）

• 3.3.1
• 3.3.2 继承抽象类注意
• 3.3.3 作用
• 3.3.4 特征和注意事项
• 3.3.5 final和abstract是什么关系？

• 3.4 常量

• 3.4.1 命名规范
• 3.4.2 说明

• 3.5 内部类

• 3.5.1 局部内部类
• 3.5.2 匿名内部类

• 4.继承（extends关键字）

• 4.1 语法：
• 4.2 优点：
• 4.3 特点
• 4.4 继承后：成员变量、成员方法的访问特点
• 4.5 重写

• 4.5.1 定义
• 4.5.2 应用场景
• 4.5.3 重写注释
• 4.5.4 注意事项和基本要求

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

• 5. 封装

• 5.1 什么是封装
• 5.2 封装的优点
• 5.3 标准javabean

• 6. 多态

• 6.1 定义
• 6.2 语法
• 6.3 多态中成员访问特点
• 6.4 多态的前提
• 6.5 优点
• 6.6 多态下引用数据类型的类型转换

• 7. 枚举

• 7.1 定义格式
• 7.2 注意

• 8. API

• 8.1 接口（interface）

• 8.1.1 接口定义
• 8.1.2 接口类实现（implements）
• 8.1.3 接口调用步骤

• 8.2 常用API

• 8.2.1 Object
• 8.2.2 Objects
• 8.2.3 StringBuilder
• 8.2.4 Math
• 8.2.5 System
• 8.2.6 BigDecimal

• 9. JDBC

• 9.1 操作流程
• 9.2 代码步骤
• 9.3 JDBC API详解

• 9.3.1 注册驱动（DriverManager）
• 数据库连接（getConnection）
• ResultSet对象

• 10.构造器

• 构造器作用
• 修饰符
• this关键字
• 构造器和方法（函数）的区别：

• 11.static关键字

• static是什么？
• static关键字使用注意事项
• static关键字使用方法

• 12. final关键字

• final的作用
• 注意事项

• 13. 设计模式
• 14. 抛出异常

1. java名词解释

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

2.基础语法之间的差别

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 关键字

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

3. 类、实例

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

3.1 类

3.1.1 修饰符

访问控制

3.1.2 Number & Math 类

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

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

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

8.2.3 StringBuilder

8.2.4 Math

8.2.5 System

8.2.6 BigDecimal

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类型的参数： 列的名称

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

构造器作用

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

修饰符

修饰符用来定义类、方法或者变量，通常放在语句的最前端。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、调用：
构造方法：只有在对象创建的时候才会去调用，而且只会调用一次。
一般方法：在对象创建之后才可以调用，并且可以调用多次。

static是什么？

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

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

static关键字使用注意事项

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

static关键字使用方法

static关键字的四种用法

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

final的作用

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

注意事项

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

JAVA抛出异常的三种形式