JavaSE核心内容以及MySQL数据库基础内容

最新推荐文章于 2024-07-18 20:13:39 发布

再拼一次吧

最新推荐文章于 2024-07-18 20:13:39 发布

阅读量957

点赞数 23

文章标签： java 开发语言

本文链接：https://blog.csdn.net/fxbsdl/article/details/139969200

版权

❤️❤️❤️❤️

一、Java概述

1、发展历程

1996年1月，Sun公司发布了Java的第一个开发工具包*（JDK 1.0）*，这是Java发展历程中的重要里程碑，标志着Java成为一种独立的开发工具。
1999年6月，Sun公司发布了第二代Java平台（简称为Java2）的3个版本：J2ME（Java2 Micro Edition，Java2平台的微型版），应用于移动、无线及有限资源的环境；J2SE（Java 2 Standard Edition，Java 2平台的标准版），应用于桌面环境；J2EE（Java 2Enterprise Edition，Java 2平台的企业版），应用于基于Java的应用服务器。Java 2平台的发布，是Java发展过程中最重要的一个里程碑，标志着Java的应用开始普及。
2005年6月，在Java One大会上，Sun公司发布了Java SE 6。此时，Java的各种版本已经更名，已取消其中的数字2，如J2EE更名为JavaEE，J2SE更名为JavaSE，J2ME更名为JavaME。
2007年3月起，全世界所有的开发人员均可对Java源代码进行修改。
2009年，甲骨文公司宣布收购Sun。2014年，甲骨文公司发布了Java8正式版

2、定义

Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++难以理解的指针等概念、因此Java语言具有三大特征：继承、封装、多态。Java语言作为静态面向对象编程语言的代表，极大地实现了面向对象理论，允许程序员以优雅方式进行复杂的编程特征。

3、编程开发

开发环境
1. JDK（Java Development Kit）称为Java开发包或Java开发工具，是一个编写Java的Applet小程序和应用程序的程序开发环境。JDK是整个Java的核心，包括了Java运行环境（Java Runtime Environment），一些Java工具和Java的核心类库*（Java API）*。不论什么Java应用服务器实质都是内置了某个版本的JDK。主流的JDK是Sun公司发布的JDK，除了Sun之外，还有很多公司和组织都开发了自己的JDK，例如，IBM公司开发的JDK，BEA公司的Jrocket，还有GNU组织开发的JDK [13] 。
2. JRE*（JAVA Runtime Environment）*是JavaSE API子集和Java虚拟机这两部分的统称，是支持Java程序运行标准环境。JDK默认集成JRE，但是运行普通Java程序只需安装JRE。
开发工具
1. Eclipse：一个开放源代码的、基于Java的可扩展开发平台。
2. NetBeans：开放源码的Java集成开发环境，适用于各种客户机和Web应用。
3. [IntelliJ IDEA](https://baike.baidu.com/item/IntelliJ IDEA)：在代码自动提示、代码分析等方面的具有很好的功能。
4. MyEclipse：由Genuitec公司开发的一款商业化软件，是应用比较广泛的Java应用程序集成开发环境

二、Java基础知识

1、注释

// 单行注释

/* */ 多行注释

/** */ 文档注释

2、关键字

定义：被Java语言赋予了特殊含义，用做专门用途的单词

特点：关键字中所有字母都为小写

关键词数量多，不需要死记硬背，在学习的过程中进行背记

JavaSE中常用到的关键字

用于定义数据：

byte->short->int->long->float->double->char->boolean->void

流程控制的关键字

if~else、switch、case、default、while、do、for、break、continue、return

访问权限修饰符的关键字

private、protect、public

定义类、函数、变量修饰符的关键字

abstrct、final、static、synchronized

类与类关系的关键字

extends、implements

定义建立实例以及引用实例、判断实例的关键字

new、this、super、instanceof

异常处理的关键字

try、catch、finally、throw、throws

用于包的关键字

package、import

其他修饰符（JavaSE中基本不会用到）

native 、strictfp、transient、volatile、assert

保留字：const 、goto现有版本尚未使用

3、标识符

概念：Java对各种变量、方法、和类等要素命名时使用的字符序列称为标识符。

定义合法标识符规则：

1、由26个英文字母大小写，0-9，_或$组成

2、数字不能开头

3、不可以使用关键字和保留字，但能包含关键字和保留字

4、Java严格区分大小写

5、长度无限制

6、标识符能包含空格

4、Java变量

变量时程序中最基本的存储单元，程序执行中数值是可变的

🤠🤠变量要先声明，再赋值，最后实用

5、数据类型

6、Unicode编码

一种编码，将世界上所有的符号都纳入其中。这个编号范围从0x000000到0x10FFFF（十六进制），有110多万，每个字符都有一个唯一的Unicode编码，一般写成16进制，在前面加上u+

如 ”马“的Unicode编码是U+9A6C.

Java底层采用Unicode编码来存储字符

7、数据类型String

String是引用数据类型，""表示一个字符串，可以包含0个或多个字符

+在String类型中起到连接作用

8、基本数据类型转换

boolean类型不能进行转换

规则：

小范围可以自动转为大范围

大范围强制转换为小范围（精度可能会丢失）

9、运算符

10、控制语句

 if (/*判断表达式*/){
      //执行语句
        }
        
        if (/*判断表达式*/){
          //执行语句
        }else {
          //执行语句
        }


        if(/*判断表达式*/){
               //执行语句
        }else if (/*判断表达式*/){
              //执行语句
        }
        /* ... 等等*/

        int i;
        switch (i){
            case 1:{
                      //执行语句
            }break;
            case ......//等等其他情况
        }

循环语句(重复执行某些动作)

for


while


do...while


/*从循环次数角度分析
do-while循环至少执行一次循环体语句。
for和while循环先判断循环条件语句是否成立，然后决定是否执行循环体。
如何选择
遍历有明显的循环次数（范围）的需求，选择for循环
遍历没有明显的循环次数（范围）的需求，选择while循环
如果循环体语句块至少执行一次，可以考虑使用do-while循环
本质上：三种循环之间完全可以互相转换，都能实现循环的功能/*

break 跳出当前循环

continue：用在循环语句体中，用于终止某次循环过程，跳过循环体中 continue 语句下面未执行的循环，开始下一次循环过程

11、Java中的方法

方法类似与其他语言的函数，方法是解决一类问题步骤的组合，表式一种功能和行为，可以减少代码的重复书写，简化代码，减少冗余

在JAVA 中方法必须定义在类中不能独立存在

方法声明格式：

三、数组

1、概述

1、概念：相同数据类型元素的集合

2、作用：存储数据

2、常用操作

 1 public class TestArray {
 2     public static void main(String[] args) {
 3         /**
 4          * 1. 数组的初始化
 5          */
 6         // 1.1 数组的静态初始化
 7         int[] array1 = { 1, 3, 5, 6, 7, 2, 4, 10 };
 8 
 9         // 1.2 数组的动态初始化
10         int[] array2 = new int[5];
11         array2[0] = 1;
12         array2[1] = 2;
13         array2[2] = 7;
14         array2[3] = 3;
15         array2[4] = 4;
16 
17         /**
18          * 2. 数组的遍历
19          */
20         // 2.1 for循环打印数组
21         for (int i = 0; i < array2.length; i++) {
22             System.out.print(array2[i]);
23         }
24 
25         // 2.2 foreach打印数组
26         for (int i : array2) {
27             System.out.print(i);
28         }
29 
30         /**
31          * 3. 数组排序
32          */
33 
34         // 3.1 冒泡排序
35         for (int i = 0; i < array2.length; i++) {
36             for (int j = i + 1; j < array2.length; j++) {
37                 // 1. 比较相邻元素，将较大的数冒泡
38                 if (array2[i] > array2[j]) {
39                     // 2. 交换
40                     int temp = array2[i];
41                     array2[i] = array2[j];
42                     array2[j] = temp;
43                 }
44             }
45         }
46         for (int i : array2) {
47             System.out.println(i);
48         }
49 
50         // 3.2 选择排序
51         for (int i = 0; i < array2.length; i++) {
52             int min = i;
53             for (int j = i; j < array2.length; j++) {
54                 // 1. 找到最小的数
55                 if (array2[j] < array2[min]) {
56                     // 2. 将最小的数赋值给min
57                     min = j;
58                 }
59             }
60             // 3. 交换两个数的位置
61             int temp = array2[i];
62             array2[i] = array2[min];
63             array2[min] = temp;
64         }
65         for (int i : array2) {
66             System.out.println(i);
67         }
68 
69         // 3.3 反转排序
70         for (int i = 0; i < array2.length / 2; i++) {
71             // 将第i位元素与array2.length-1-i位元素交换
72             int temp = array2[i];
73             array2[i] = array2[array2.length - 1 - i];
74             array2[array2.length - 1 - i] = temp;
75         }
76         for (int i : array2) {
77             System.out.println(i);
78         }
79 
80         // 3.4 插入排序
81         for (int i = 0; i < array2.length; i++) {
82             int j = i;
83             int tmp = array2[i];
84             for (; j > 0 && tmp < array2[j - 1]; j--) {
85                 // 1. 将大于待排序的数向后移
86                 array2[j] = array2[j - 1];
87             }
88             // 2. 交换
89             array2[j] = tmp;
90         }
91         for (int i : array2) {
92             System.out.println(i);
93         }
94      }
95 }

3、Arrays工具类

 1 package pers.mj;
 2 
 3 import static org.hamcrest.CoreMatchers.instanceOf;
 4 
 5 import java.util.Arrays;
 6 import java.util.List;
 7 
 8 import org.junit.Test;
 9 
10 public class Demo {
11     @Test
12     public void test() {
13 
14         int[] array1 = { 1, 3, 5, 2, 4 };
15         int[] array2 = { 3, 2 };
16 
17         // 1. 排序
18         Arrays.sort(array2);
19         for (int i : array2) {
20             System.out.print(i);
21         }
22 
23         // 2. 二分法查找
24         System.out.print(Arrays.binarySearch(array2, 3));
25 
26         // 3. 数组元素比较
27         System.out.println(Arrays.equals(array1, array2));
28 
29         // 4. 数组元素填充
30         Arrays.fill(array2, 1);
31         for (int j : array2) {
32             System.out.println(j);
33         }
34         
35         /**
36          * aslist详解
37          *    1. 该方法适用于对象型数据的数组（String、Integer...）
38          *    2. 该方法不建议使用于基本数据类型的数组（byte,short,int,long,float,double,boolean）
39          *    3. 该方法将数组与List列表链接起来：当更新其一个时，另一个自动更新
40          *    4. 不支持add()、remove()、clear()等方法
41          */
42 
43         // 1、对象类型(String型)的数组数组使用asList()，正常
44         String[] strings = { "aa", "bb", "cc" };
45         List<String> stringList = Arrays.asList(strings);
46         System.out.print("1、String类型数组使用asList()，正常：  ");
47         for (String str : stringList) {
48             System.out.print(str + " ");
49         }
50         System.out.println();
51 
52         // 2、对象类型(Integer)的数组使用asList()，正常
53         Integer[] integers = new Integer[] { 1, 2, 3 };
54         List<Integer> integerList = Arrays.asList(integers);
55         System.out.print("2、对象类型的数组使用asList()，正常：  ");
56         for (int i : integerList) {
57             System.out.print(i + " ");
58         }
59         System.out.println();
60 
61         // 3、基本数据类型的数组使用asList()，出错
62         int[] ints = new int[] { 1, 2, 3 };
63         List intList = Arrays.asList(ints);
64         System.out.print("3、基本数据类型的数组使用asList()，出错(输出的是一个引用，把ints当成一个元素了)：");
65         for (Object o : intList) {
66             System.out.print(o.toString());
67         }
68         System.out.println();
69 
70         System.out.print("   " + "这样遍历才能正确输出：");
71         int[] ints1 = (int[]) intList.get(0);
72         for (int i : ints1) {
73             System.out.print(i + " ");
74         }
75         System.out.println();
76 
77         // 4、当更新数组或者List,另一个将自动获得更新
78         System.out.print("4、当更新数组或者List,另一个将自动获得更新：  ");
79         integerList.set(0, 5);
80         for (Object o : integerList) {
81             System.out.print(o + " ");
82         }
83         for (Object o : integers) {
84             System.out.print(o + " ");
85         }
86         System.out.println();
87 
88     }
89 }

四、面向对象

1、概述

概念：面向对象也即OOP(Object Oriented Programming)，是一种编程思想，它以对象作为基本的单元来构建系统，具有三大特征和五大原则。
三大特征：
1. 封装：隐藏对象的属性和实现细节，仅对外提供公共访问方式，提高安全性。
2. 继承：提高代码复用性，是实现多态的前提。
3. 多态：父类或接口定义的引用变量指向子类或具体实现类的实例对象，提高了代码的拓展性。

2、封装

访问权限

3、方法的重载和重写

重载：方法名相同，参数列表不同

重写：方法名，返回值，参数列表都相同，只有执行的Java代码不同，构造方法和使用final、static修饰的方法不能被重写

方法重载和重写的代码实现

 1 package pers.mj;
 2 
 3 public interface Override {
 4     /**
 5      * 方法的重载：方法名相同，参数列表不同
 6      */
 7     public void query(int id);
 8 
 9     public int query(int id, String username);
10 
11 }
12 
13 class Test implements Override {
14     /**
15      * 方法的重写：方法的所有东西都一样，只有方法实体不同。
16      */
17     public void query(int id) {
18         System.out.println("我重写了接口的方法");
19 
20     }
21 
22     public int query(int id, String username) {
23         System.out.println("我也可以重写父类的方法");
24         return 0;
25     }
26 
27 }

4、继承

子承父类，父类通用，子类更具体

继承代码实现

 1 /**
 2  * 1. 将类中重复的部分提取成为父类
 3  */
 4 public class Animal {
 5     private String name;
 6     private String food;
 7 
 8     public Animal(String name, String food) {
 9         this.name = name;
10         this.food = food;
11     }
12 
13     public void eat() {
14         System.out.println(name + "正在吃" + food);
15     }
16 }
17 
18 /**
19  * 2. 子类继承父类，对父类进行扩展
20  */
21 public class Cat extends Animal {
22 
23     public Cat(String name, String food) {
24         super(name, food);
25     }
26 }
27 public class Dog extends Animal{
28 
29     public Dog(String name, String food) {
30         super(name, food);
31     }
32 }
33 
34 /**
35  * 3. 测试
36  */
37 public class TestExtends{
38     public static void main(String[] args) {
39         Animal cat = new Cat("三三", "鱼");
40         cat.eat();
41         Animal dog = new Dog("二哈", "香肠");
42         cat.eat();
43     }
44 }

5、多态

1、核心：提高代码的的维护性和可扩展性

2、实现多态的三个必要条件：继承、重写、父类引用指向子类对象（向上转型）

3、多态的实现方法：重写、接口、抽象类和抽象方法

多态代码实现

 1 /**
 2  * 1. 创建动物类，定义动物吃什么的方法
 3  */
 4 class Animals {
 5     private String name;
 6     private String food;
 7     
 8     public Animals(String name, String food) {
 9         super();
10         this.name = name;
11         this.food = food;
12     }
13 
14     public void eat() {
15         System.out.println(this.name + "会吃" + this.food);
16     }
17 }
18 
20 /**
21  * 2. 创建Cat类来实现吃的功能
22  */
23 class Cat extends Animals{
24     public Cat(String name, String food) {
25         super(name, food);
26     }
27 
28     @Override
29     public void eat() {
30         super.eat();
31     }
32 }
33 
35 /**
36  * 3. 通过向上转型和向下转型实现多态
37  */
38 public class Test01 {
39     public static void main(String[] args) {
40         // 向下转型
41         Animals animals = new Cat("三三", "鱼");
42         animals.eat();
43         // 向上转型
44         Cat cat = (Cat) animals;
45         cat.eat();
46     }
47 }

6、抽象类

核心思想：让代码有更强的可扩展性
特点
1. 抽象类不能实例化对象。
2. 如果一个类包含抽象方法，那么该类必须是抽象类
3. 任何子类必须重写父类的抽象方法(具体实现)，或者声明自身为抽象类
4. 抽象类中的抽象方法只有方法声明，没有方法体
5. 构造方法和static修饰的方法不能声明为抽象方法
代码实现

 1 /**
 2  * 1. 创建员工抽象类
 3  */
 4 abstract class Employees {
 5     // 成员变量
 6     private String name;
 7     private String address;
 8     private Integer number;
 9 
10     // 构造方法
11     public Employees(String name, String address, Integer number) {
12         System.out.println("Employees.Employees()");
13         this.name = name;
14         this.address = address;
15         this.number = number;
16     }
17 
18     // 定义信息抽象函数
19     public abstract void call();
20    
21     // 省略getter 和 setter方法
22     ......
23     }
24 }
25 
26 class Salary extends Employees {
27     private Double salary;
28 
29     public Salary(String name, String address, Integer number, Double salary) {
30         super(name, address, number);
31         this.salary = salary;
32         System.out.println("Salary.Salary()");
33     }
34 
35     // 2. 重写父类的抽象方法
36     @Override
37     public void call() {
38         System.out.println(super.getNumber() + "是" + super.getName() + "的电话，他住在" + 
39         super.getAddress() + "他现在的工资是" + this.salary);
40     }
41 }
42 
43 public class Test {
44     public static void main(String[] args) {
45         // 3. 抽象类的对象必须由子类去实例化
46         Employees emp = new Salary("孙悟空", "花果山", 1234, 222.66);
47         emp.call();
48     }
49 }

7、接口

特点
1. 接口不能实例化对象，没有构造方法
2. 接口中的方法只能是抽象方法，默认使用public abstract修饰
3. 接口中的变量只能是常量，默认使用public static final修饰
4. 接口支持多继承，但接口不是被继承了，而是被实现了
接口和抽象类的区别
1. 接口中的方法只能是抽象方法，而抽象类中的方法可以是普通方法，构造方法和抽象方法
2. 接口中的变量只能是常量，而抽象类中的方法可以是任意类型
3. 接口中不能含有静态代码块和静态方法，而抽象类中可以有
4. 一个类可以实现多个接口，但一个类只能继承一个抽象类

 1 /**
 2  * 1. 创建Animal接口
 3  */
 4 interface Animal {
 5     // 定义睡觉抽象方法
 6     void sleep();
 7 
 8     // 定义吃饭抽象方法
 9     void eat();
10 }
11 
12 /**
13  * 2. 创建Dog接口继承Animal接口
14  */
15 interface Dog extends Animal {
16     // 定义游泳抽象方法
17     void swim();
18 }
19 
20 /**
21  * 3. 创建HaShiQi接口继承Dog和Animal接口，实现多继承
22  */
23 interface HaShiQi extends Dog, Animal {
24     // 定义拆家抽象方法
25     void demolishedFamily();
26 }
27 
28 /**
29  * 4. 创建测试类来实现接口，并且复写所有抽象方法
30  */
31 public class TestAnimal implements HaShiQi {
32 
33     @Override
34     public void swim() {
35         System.out.println("哈士奇会游泳");
36     }
37 
38     @Override
39     public void sleep() {
40         System.out.println("哈士奇会睡觉");
41     }
42 
43     @Override
44     public void eat() {
45         System.out.println("哈士奇喜欢吃苦瓜");
46     }
47 
48     @Override
49     public void demolishedFamily() {
50         System.out.println("哈士奇会拆家");
51     }
52 
53     public static void main(String[] args) {
54         // 使用多态实例化对象
55         HaShiQi dog = new TestAnimal();
56         dog.eat();
57         dog.sleep();
58         dog.demolishedFamily();
59         dog.swim();
60     }
61 }

五、常用类及API

1、Java API

是对Java预先定义的类或接口功能和函数功能的说明文档，目的是提供给开发人员进行使用帮助说明。

2、Object类

根基类，每个类都使用Object作为超类（父类），所以对象都继承实现了这个类的方法

equals方法，在Object中默认使用==比较，比较的是对象地址，然而在其他类中，对equals方法进行了重写，调用这个方法 x.equals(y) 判断x和y的内容是否相等，而不是比较地址

3、Arrays类

是操作数组工具类，里面定义了常见数组的静态方法

在文章上面有一个Arrays类的代码展示，可以进行翻阅查看，这里就不再重复书写😂😂😂😂

4、基本数据类型分装类

自动装箱：基本类型自动转换为包装类型

自动拆箱：包装类型自动转换为基本类型

5、String类

● 构造方法
public String()
public String(String str)
public String(byte[] bytes)
public String(char[] value)


● 判断功能
boolean equals(Object obj)
boolean equalsIgnoreCase(String str)
boolean contains(String str)
boolean isEmpty()
boolean startsWith(String prefix)
boolean endsWith(String suffix)


●获取功能
int length()
char charAt(int index)
int indexOf(String str)
int indexOf(String str,int fromIndex)
String substring(int start)
String substring(int start,int end)



● 转换功能
byte[] getBytes()
char[] toCharArray()
static String valueOf(char[] chs)
String toLowerCase()
String toUpperCase()
String concat(String str)
Stirng[] split(分割符)


● 替换功能
String replace(char old,char new)
String replace(String old,String new)
replaceAll(String regex, String replacement)
replaceFirst(String regex, String replacement)
● 去除字符串两空格
String trim()

6、StringBuffer类和StringBuilder类

● 添加功能
public StringBuffer append(String str)
public StringBuffer insert(int offset,String str)
● 删除功能
public StringBuffer deleteCharAt(int index)
public StringBuffer delete(int start,int end)
● 替换功能
public StringBuffer replace(int start,int end,String str)
● 反转功能
public StringBuffer reverse()
● 截取功能
public String substring(int start)
public String substring(int start,int end)
● 截取功能和前面几个功能的不同
返回值类型是String类型，本身没有发生改变
● StringBuilder类功能和StringBuffer功能完全一致, StringBuffer是线程
安全的

三者的区别：

String：是字符常量,适用于少量的字符串操作的情况

StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况

StringBuffer ：适用多线程下在字符缓冲区进行大量操作的情况

7、Math类

数学类，常用的数学方法

package com.ffyc.javaapl.Mathdemo;

public class Math1 {
    public static void main(String[] args) {
        System.out.println(Math.abs(-1));//Math.abs()求求绝对值
        System.out.println(Math.sqrt(9.0));//Math.sqrt()开方
        System.out.println(Math.max(5,2));//求最大值
        System.out.println(Math.floor(9.9));//向下取整9.0
        System.out.println(Math.ceil(9.1));//向下取整10.0
        System.out.println(Math.round(9.1));//9
        System.out.println(Math.round(9.5));//Math.round()四舍五入取整 10
        System.out.println(Math.random());//在0-1之间随机数，0<=random<1
        System.out.println(Math.pow(2,3));//pow(double a, double b) a^b 8 幂次方
    }
}

8、Random类

产生随机数

代码实现

import java.util.Random;

public class Random1 {
    public static void main(String[] args) {
        Random random=new Random();
        System.out.println(random.nextBoolean());//随机产生一个boolean值
        System.out.println(random.nextInt());//在int型范围内产生一个随机值
        System.out.println(random.nextInt(3));//在0-2内产生一个随机值
    }
}

9、Date类/Calender类/SimpleDateFormat类

Date类代表当前系统时间

Date类代码实现

import java.util.Date;

public class Datedemo1 {
    public static void main(String[] args) {
        Date date=new Date();//创建一个date对象，程序运行是会将当前时刻存入
        System.out.println(date);
        System.out.println(date.getYear()+1900);//return normalize().getYear() - 1900;
        System.out.println(date.getMonth()+1);// return normalize().getMonth() - 1
        System.out.println(date.getDate());//
        System.out.println(date.getTime());//时间戳，自1970 1.1 0：0：0到程序运行时刻的毫秒值 1708844950270
        Date date2=new Date(1708844950270L);
        System.out.println(date2);//new Date(long date),传入一个毫秒值，返回一个时刻
    }
}

Calender类是一个抽象类，在实际使用时实现特定的子类对象。创建对象过程对程序员来说是透明的，只需要使用getInstance方法创建

Calender类代码实现

import java.util.Calendar;

public class Calenderdemo1 {
    public static void main(String[] args) {
        Calendar calendar=Calendar.getInstance();//getInstance子类
       // System.out.println(calendar);

        System.out.println(calendar.get(Calendar.YEAR));//获取年份
        System.out.println(calendar.get(Calendar.MONTH)+1);//获取月份
        System.out.println(calendar.get(Calendar.DAY_OF_MONTH));
        System.out.println(calendar.get(Calendar.DAY_OF_WEEK_IN_MONTH));


    }
}

SimpDateFormat类

日期格式话类

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

public class SimpleDateFormdemo1 {
    public static void main(String[] args) throws ParseException {
        //把字符串日期转换为date对象
        String s="2024-2-29 12:12:12 星期三";
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-mm-dd HH:mm:ss E");
        Date date=sdf.parse(s);
        System.out.println(date);
      //  把date对象转换为字符串日期
        Date date1=new Date();
        SimpleDateFormat sdf1=new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss E");
        String s1=sdf1.format(date1);
        System.out.println(s1);


    }
}

10、BigInteger类/BigDecimal类

BigInteger类型的数字范围较Integer，Long类型的数字范围要大得多，它支持任意精度的整数，也就是说在运算中 BigInteger 类型可以准确地表示任何大小的整数值而不会丢失任何信息

import java.math.BigDecimal;
import java.math.BigInteger;

public class BigIntergedemo1 {
    public static void main(String[] args) {
        BigInteger a1=new BigInteger("11111111111111111111111111111111");
        BigInteger a2=new BigInteger("99999999999999999999999999999999");
        BigInteger a3=a1.add(a2);
        BigInteger a4=a1.multiply(a2);
        System.out.println(a1);
        System.out.println(a2);
        System.out.println(a3);
        System.out.println(a4);
    }
}

BigDecimal类

比double 和folat精确度要高得多

import java.math.BigDecimal;
import java.math.RoundingMode;

public class BigDecimaldemo1 {
    public static void main(String[] args) {
        BigDecimal a1=new BigDecimal("0.3");
        BigDecimal a2=new BigDecimal("0.1");
        System.out.println(a1.add(a2));
        BigDecimal a3=new BigDecimal("10");
        BigDecimal a4=new BigDecimal("3");
        System.out.println(a3.divide(a4,2, RoundingMode.HALF_UP));//a3/a4，a4是除数，scale是保留小数的位数，RoundingMode是舍入模式

    }
}

六、集合

七、IO

一、简介

流的概念：流是有起点和终点的一组有顺序的字节集合，作用是进行数据传输
流的分类
1. 按照数据流向不同可以分为输入输出流；
2. 按照处理数据单位不同可以分为字节流和字符流
输入流和输出流的作用
1. 输入流：程序从数据源读取数据
2. 输出流：将数据从程序中写入指定文件
字节流和字符流的作用
1. 字节流：以字节为单位处理所有类型数据
2. 字符流：以字符为单位处理纯文本文件

二、体系结构

三、IO流常用方法

四、序列化和反序列话

对象序列化：把对象转换为字节序列(二进制数据)的过程
对象反序列化：把字节序列恢复为对象的过程

八、异常

1、概述

1、java.lang.Throwable类是Java程序执行过程中发生的异常事件对应的类的根父类

2、常见的异常：

/*int [] a=new int[2];
 a[3]=5;//ArrayIndexOutOfBoundsException 数组索引越界*/
 /*String s="abc";
 s.charAt(3);//StringIndexOutOfBoundsException 字符串索引越界*/
 /*int e=9,b=0;
 int c=e/b;//ArithmeticException 算数运算异常*/
 /* Object s=new Integer(9);
 String s1=(String) s;// ClassCastException 类型转换异常*/
 //Integer.parseInt("abc"); //NumberFormatException 数字格式化异常
 //String s=null;
 //s.length();//NullPointerException 使用 null 中的方法或属性，一般有称为空指针
异常

3、异常处理语法

4、自定义异常

代码显示：

public class Demo8 {
    public static void main(String[] args) {

            char c=level(101);

    }

    public static char level(int score)  {
        if (score<0 || score >100){
            throw new ScoreException("分数不合法");
        }
        if (score>=90 && score<=100){
            return 'A';
        }else {
            return 'B';
        }

    }
}
class ScoreException extends RuntimeException {
    public ScoreException(String message) {
        super(message);
    }
}

九、网络编程

一、简介

概述
1. 计算机网络：多台算机之间实现信息传递和资源共享的的计算机系统
2. 网络编程：不同计算机之间使用网络进行数据交换
三要素
1. IP：每个设备在网络中的唯一标识
2. 端口号：每个程序在设备上的唯一标识
3. 协议：在网络中进行数据交换要遵守的规则
UDP与TCP的区别
1. UDP：面向无连接，数据不可靠，速度快，适用于高速传输和对实时性要求较高
2. TCP：面向连接，数据可靠，速度略低，适用于可靠传输

TCP建立连接代码演示：

客户端

import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;

public class Client {
    public static void main(String[] args) {
        //创建客户端
        try {
            Socket socket = new Socket("192.168.31.229",6666);
            OutputStream outputStream=socket.getOutputStream();
            String s="你好服务器";
            outputStream.write(s.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

服务器端

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

public class Recever {
    public static void main(String[] args) throws IOException {
        //接受
        DatagramSocket datagramSocket=new DatagramSocket(6666);

        byte [] bytes=new byte[100];
       while (true){
           DatagramPacket datagramPacket=new DatagramPacket(bytes,bytes.length);
           datagramSocket.receive(datagramPacket);//真正接受
           String s=new String(datagramPacket.getData(),0,datagramPacket.getLength());
           String s2=s.toUpperCase();

           System.out.println(s.toUpperCase());
       }
    }
}

UDP建立连接代码演示：

服务器端

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Sever {
    public static void main(String[] args) {
        try {
            ServerSocket serverSocket=new ServerSocket(6666);
            System.out.println("服务器启动成功");
            //监听客户端是否发送连接请求到服务器
            Socket socket=serverSocket.accept();//阻塞了，监听客户端的连接
            System.out.println("有客户端连接");
            //后续操作
            InputStream inputStream=socket.getInputStream();
            byte [] bytes=new byte[100];
            int size=inputStream.read(bytes);
            String s=new String(bytes,0,size);
            System.out.println(s);
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("服务器启动失败，端口被占用");
        }
    }
}

客户端

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.util.Scanner;

public class send {
    public static void main(String[] args) throws IOException {
        //发送
        DatagramSocket datagramSocket=new DatagramSocket();
        //数据包
        /*
         public DatagramPacket(byte buf[], int offset, int length,
                          InetAddress address, int port) {
        setData(buf, offset, length);
        setAddress(address);
        setPort(port);
    }
         */

        Scanner sc=new Scanner(System.in);
        while (true){
            String s=sc.nextLine();
            byte [] bytes=s.getBytes();
            DatagramPacket datagramPacket=new DatagramPacket(bytes,0,bytes.length, InetAddress.getByName("127.0.0.1"),6666);
            datagramSocket.send(datagramPacket);
            System.out.println("发送完成");

        }

    }
}

十、线程

1、概述

程序: 为实现某种功能,使用计算机语言编写的一系列指令的集合.
指的是静态的代码(安装在电脑上的那些文件)

进程: 也是称为程序,但是是运行中的程序.
进程是操作系统进行资源分配的最小单位

线程: 进程可以进一步细化为线程,就是进程中一个最小的执行单元(任务),
   是cpu进行调度的最小单元.
       例如:qq中的一个聊天窗口

2、进程和线程的关系

一个进程中可以包含多个线程(一个QQ可以有多个聊天窗口)
   一个线程只能隶属于一个进程(QQ聊天窗口只能属于QQ进程)
   一个进程中至少包含一个线程(主线程 java中的main方法就是用来启动主线程的)
   在主线程中可以创建并启动其他线程
   一个进程的线程共享该进程的内存资源

3、生命周期

4、java中线程创建方式

方式1:继承Thread
方式2:实现Runnable接口 new Thread类对象

/*
创建线程方式一：
继承java.long.thread类，重写run（）方法
线程中的要执行的任务要写在run方法中
 */
public class MyThread  extends Thread{

    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            System.out.println("MyThread:"+i);
        }
    }
}

/*
创建线程方式二：

实现Runnable的接口，只先创建要执行的任务
优点：1 Java是单继承，一旦继承一个类就不能在继承其他类，避免单继承的局限性
     2 适合多线程来处理一份资源是使用
 */
public class Task implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("Task:"+i);
        }
    }
}

多线程的概念
在一个程序中可以创建多个线程执行.

多线程优点:
提高程序执行效率 3个任务可以在不同的线程中同时执行
   提高了cpu的利用率
   改善程序结构, 例如将一个大的任务拆分成若干个小任务执行

多线程缺点:
线程多了,占用内存
   cpu开销就变大了 (扩充内存,升级cpu)

   多个线程访问操作同一个共享的数据(例如买票抢购秒杀.....)

   如何解决多线程操作共享数据的问题:

排队+锁在关键的步骤处,多个线程只能一个一个的执行.

十一、jdbc

jdbc连接数据库步骤:
  1.在项目添加jar文件
  2.加载驱动类  Class.forName("com.mysql.cj.jdbc.Driver");
  3.建立与数据库的连接,获得连接对象
4.发送sql
          Statement st = connection.createStatement();
  5.如果执行查询操作,  接收包装查询结果

6.关闭与数据库连接
            rs.close();
            ps.close();
            connection.close();

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

public class Demo1 {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        Class.forName("com.mysql.cj.jdbc.Driver");//加载驱动类
        //建立与数据库的连接，获得连接对象
        String url="jdbc:mysql://127.0.0.1:3306/schooldb?serverTimezone=Asia/Shanghai";
        String user="root";
        String password="root";
        Connection connection= DriverManager.getConnection(url,user,password);
        //发送sql
        Statement st =connection.createStatement();
        st.executeUpdate("insert into major(name)values('数学')");
        // 关闭
        st.close();
        connection.close();
    }
}

数据库MySQL

1、数据库

DB：数据库方便数据的存储和管理，它将数据按照特定的规则存储在磁盘上, 就是一个存储数据的仓库。

DBMS ：数据库管理系统（ DataBase Management System ）又称为数据库软件或数据库产品，用于创建或管理DB 。

2、MySQL数据库

🤣MySQL是一个关系型数据库管理系统，由瑞典MySQL AB 公司开发，目前属于 Oracle旗下产品。MySQL 流行的关系型数据库管理系统。

🤣 MySql是一种关系数据库管理系统。

🤣MySql软件是一种开放源码软件, 你可以修改源码来开发自己的 Mysql 系统。

🤣MySql数据库服务器具有快速、可靠和易于使用的特点。

🤣 MySql 使用标准的 sql 语言 , 并且支持多种操作系统 , 支持多种语言

3、MySQL常用命令

查看当前所有的数据库：show databases;
选择指定的库：use 库名
查看当前的所有表：show tables;
查看其他库的所有表：show tables from 库名;
查看mysql版本 select version();

4、sql语言

🤣结构化查询语言(Structured Query Language) 简称 SQL ，是一种特殊目的的编程语言，是一种数据库查询和程序设计语言，用于存取数据以及查询、更新和管理关系数据库系统.

🤣SQL优点：

不是某个特定数据库供应商专有的语是言，几乎所有 DBMS 都支持 SQL

简单易学，灵活使用可以进行非常复杂和高级的数据库操作

DDL：数据 ( 结构 )定义语言，是用于创建和修改数据库表结构的语言。

常用语句有;create、alter、drop、rename

DML：数据操纵语言，常用语句有insert、delete、update。

DQL：数据查询语言查询是使用频率最高的一个操作，可以从一个表中查询数据，也可以从多个表中查询数据。

查询语法：select 查询列表 from 表名 where 约束条件

查询的列表可以是：表中的字段、常量、表达式、函数

查询的结果是一个虚拟的表格

特定列查询:select column1,column2 from table
全部列查询: select * from table
算数运算符:+ - * /
排除重复行: select distinct column1,column2 from table
查询函数：select 函数; / 例如version()

函数 : 类似于 java 中的方法，将一组逻辑语句事先在数据库中定义好 , 可以直接调用

分类：

单行函数：如 concat 、 length 、 ifnull 等

分组函数：做统计使用，又称为统计函数、聚合函数、组函数

关联查询

多表关联-左外连接：left join

select 查询列表 from 表1 left join 表2 on 表1.column1 = 表2.column2

多表关联-右外连接：right join

select 查询列表 from 表2 righ join 表21on 表1.column1 = 表2.column2

子查询

含义：出现在其他语句中的 select 语句，称为子查询或内查询；外部的查询语句，称为主查询或

外查询

分类：

按子查询出现的位置：

from 后面：支持表子查询

where ：支持标量子查询，列子查询

按功能、结果集的行列数不同：

标量子查询（结果集只有一行一列）

列子查询（结果集只有一列多行）

表子查询（结果集一般为多行多列）

再拼一次吧

关注

23
点赞
踩
28

收藏

觉得还不错? 一键收藏
打赏
0
评论
JavaSE核心内容以及MySQL数据库基础内容

Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++难以理解的指针继承封装多态。Java语言作为静态面向对象编程语言的代表，极大地实现了面向对象理论，允许程序员以优雅方式进行复杂的编程特征。1、概念：相同数据类型元素的集合2、作用：存储数据概念：面向对象也即OOP(Object Oriented Programming)，是一种编程思想，它以对象作为基本的单元来构建系统，具有三大特征和五大原则。封装：隐藏对象的属性和实现细节，仅对外提供公共访问方式，提高安全性。
复制链接

扫一扫