自学笔记

1.LINUX常用命令

https://www.runoob.com/linux/...

2.SQL常用函数

https://www.runoob.com/mysql/...

3.如何连接数据库

1.Java 连接 MySQL 需要驱动包，最新版下载地址为：http://dev.mysql.com/downloads/connector/j/，解压后得到 jar 库文件，然后在对应的项目中导入该库文件。
2.要访问数据库，首先要加载数据库的驱动程序（只需要在第一次访问数据库时加载一次），然后每次访问数据时创建一个Connection对象，接着执行操作数据库的SQL语句，最后在完成数据库操作后销毁前面创建的Connection对象，释放与数据库的连接。
3.具体代码如下：

import java.sql.*;  //导入Java.sql包
public class Conn { //创建类Conn
 static Connection con;  //声明Connection对象
 // MySQL 8.0 以下版本 - JDBC 驱动名及数据库 URL //static final String JDBC_DRIVER = "com.mysql.jdbc.Driver"; //static final String DB_URL = "jdbc:mysql://localhost:3306/RUNOOB";
 // MySQL 8.0 以上版本 - JDBC 驱动名及数据库 URL static final String JDBC_DRIVER = "com.mysql.cj.jdbc.Driver";
    static final String DB_URL = "jdbc:mysql://localhost:3306/RUNOOB?useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=UTC";
    // 数据库的用户名与密码，需要根据自己的设置
 static final String USER = "root";
    static final String PASS = "123456";
    public Connection getConnection() { //简历返回值为Connection的方法
 try {
            Class.forName("com.mysql.cj.jdbc.Driver");  //加载数据库驱动类
 System.out.println("数据库驱动加载成功");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        try {
            con = DriverManager.getConnection(DB_URL,USER,PASS);    //通过访问数据库的URL获取数据库连接对象
 System.out.println("数据库连接成功");
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return con;
    }
    public static void main(String[] args) {    //主方法
 Conn c = new Conn();                    //创建本类对象
 c.getConnection();                      //调用链接数据库的方法
 }
}

运行结果

4.多态

一句话解释多态：多态就是一个事物多种形态，就是同一符号或者名字在不同情况下具有不同解释的现象。

多态是同一个行为具有多个不同表现形式或形态的能力。

多态就是同一个接口，使用不同的实例而执行不同操作，如图所示：

4.1.如何实现多态

** 1.抽象类 **
在解决实际问题时，一般将父类定义为抽象类，需要使用这个父类进行继承与多态处理。回想继承和多态原理，继承树中越是在上方的类越抽象，如鸽子类继承鸟类、鸟类继承动物类等。在多态机制中，并不需要将父类初始化对象，需要的只是子类对象，因此在Java语言中抽象类不可以实例化对象，因为动物类不能抽象出任何一种具体的动物，但是它的子类就可以，如鸽子类就可以抽象出鸽子。

抽象类的语法如下：

public abstract class Test{
    abstract void testAbstract();//定义抽象方法
}

** 2.接口 **
接口是抽象类的延申，可以将它看作是纯粹的抽象类，接口中所有的方法都没有方法体。

接口的语法如下：

public interface drawTest{
    void draw();//接口内的方法，省略abstract关键字
}

接口与抽象类的区别

相同点：
（1）都不能被实例化
（2）接口的实现类或抽象类的子类都只有实现了接口或抽象类中的方法后才能实例化。

不同点：
（1）接口只有定义，不能有方法的实现，java 1.8中可以定义default方法体，而抽象类可以有定义与实现，方法可在抽象类中实现。
（2）实现接口的关键字为implements，继承抽象类的关键字为extends。一个类可以实现多个接口，但一个类只能继承一个抽象类。所以，使用接口可以间接地实现多重继承。
（3）接口强调特定功能的实现，而抽象类强调所属关系。
（4）接口成员变量默认为public static final，必须赋初值，不能被修改；其所有的成员方法都是public、abstract的。抽象类中成员变量默认default，可在子类中被重新定义，也可被重新赋值；抽象方法被abstract修饰，不能被private、static、synchronized和native等修饰，必须以分号结尾，不带花括号。
（5）接口被用于常用的功能，便于日后维护和添加删除，而抽象类更倾向于充当公共类的角色，不适用于日后重新对立面的代码修改。功能需要累积时用抽象类，不需要累积时用接口。

5.多线程

一个线程是进程中的执行流程，一个进程中可以同时包括多个线程，每个线程也可以得到一小段程序的执行时间，这样一个进程就可以具有多个并发执行的线程。即，并发完成的每一件事情称为线程。

实现线程的两种方式：

• 继承Thread类

完成线程真正功能的代码放在类的run()方法中，当一个类继承Thread类后，就可以在该类中覆盖run()方法，将实现该线程功能的代码写入run()方法中，然后同时调用Thread类中的start()方法执行线程，也就是调用run()方法。
例子如下：

public class TheradTest extends Thread{
    private int count = 10;
    public void run(){
        while(true){
            System.out.print(count + " ");
            if (--count == 0){
                return;
            }
        }
    }
    public static void main(String[] args) {
        new TheradTest().start();
    }
}

• 实现Runnable接口

如果一个类需要继承其他类（非Thread类），而且还要使当前类实现多线程，那么可以通过Runnable接口来实现。
通过Runnable接口的类，然后实例化该类的对象，这样就建立了Runnable对象；接下来使用相应的构造方法创建Thread实例；最后使用该实例调用Thread类中的start()方法启动线程。
例子如下：

class RunnableDemo implements Runnable {
   private Thread t;
   private String threadName;
   
   RunnableDemo( String name) {
      threadName = name;
      System.out.println("Creating " +  threadName );
   }
   
   public void run() {
      System.out.println("Running " +  threadName );
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Thread: " + threadName + ", " + i);
            // 让线程睡眠一会
            Thread.sleep(50);
         }
      }catch (InterruptedException e) {
         System.out.println("Thread " +  threadName + " interrupted.");
      }
      System.out.println("Thread " +  threadName + " exiting.");
   }
   
   public void start () {
      System.out.println("Starting " +  threadName );
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}
 
public class TestThread {
 
   public static void main(String args[]) {
      RunnableDemo R1 = new RunnableDemo( "Thread-1");
      R1.start();
      
      RunnableDemo R2 = new RunnableDemo( "Thread-2");
      R2.start();
   }   
}

6.String 为什么是不可变的? StringBuffer 和 StringBuilder 的区别是什么?

• String 类中使⽤ final 关键字修饰字符数组来保存字符串，private final byte[] value，所以 String 对象是不可变的。
• StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。

由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。
在使用 StringBuffer 类时，每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，所以如果需要对字符串进行修改推荐使用 StringBuffer。

7.== 与 equals(重要)

== : 它的作⽤是判断两个对象的地址是不是相等。即，判断两个对象是不是同⼀个对象(基本数据类型==⽐较的是值，引⽤数据类型==⽐较的是内存地址)。
equals() : 它的作⽤也是判断两个对象是否相等。但它⼀般有两种使用情况：
情况 1：类没有覆盖 equals() ⽅法。则通过 equals() ⽐较该类的两个对象时，等价于通过“==”⽐较这两个对象。
情况 2：类覆盖了 equals() ⽅法。⼀般，我们都覆盖 equals() ⽅法来⽐较两个对象的内容是否相等；若它们的内容相等，则返回 true (即，认为这两个对象相等)

• String 中的 equals ⽅法是被重写过的，因为 object 的 equals ⽅法是⽐较的对象的内存地址，⽽ String 的 equals ⽅法⽐较的是对象的值。