【Java快速入门】-- 基础

java入门基础

概述

• 强类型静态语言
• 编译型语言，运行性能比较高
• 运行时内存安全，拥有一套GC机制
• 后端语言
• 主要web，爬虫等场景

环境安装

• 前往官网下载jdk并安装

$ java -version
openjdk version "17.0.2" 2022-01-18
OpenJDK Runtime Environment Temurin-17.0.2+8 (build 17.0.2+8)
OpenJDK 64-Bit Server VM Temurin-17.0.2+8 (build 17.0.2+8, mixed mode, sharing)

• 配置vscode环境
  • 安装language support for java插件然后重启ide
• 配置包管理
  • 下载安装maven
  • mvn帮我们可以快速构建项目，打包项目,详细mvn使用请参考
  • 加入环境变量

$ mv -f apache-maven-3.8.4 /usr/local/

• 编辑~/.bash_profile

export MAVEN_HOME=/usr/local/apache-maven-3.8.4
export PATH=${PATH}:${MAVEN_HOME}/bin

$ source ~/.bash_profile

• 验证

$ mvn -v
Apache Maven 3.8.4 (9b656c72d54e5bacbed989b64718c159fe39b537)
Maven home: /usr/local/apache-maven-3.8.4
Java version: 17.0.2, vendor: Eclipse Adoptium, runtime: /Library/Java/JavaVirtualMachines/temurin-17.jdk/Contents/Home
Default locale: zh_CN_#Hans, platform encoding: UTF-8
OS name: "mac os x", version: "10.15.7", arch: "x86_64", family: "mac"

• 配置国内源

$ vim /usr/local/apache-maven-3.8.4/conf/settings.xml
...
<localRepository>~/.m2/repository</localRepository> # 本地存储仓库

... # 阿里云镜像源
<mirror>
  <id>aliyunmaven</id>
  <mirrorOf>*</mirrorOf>
  <name>阿里云公共仓库</name>
  <url>https://maven.aliyun.com/repository/public</url>
</mirror>
...

• 第三方库查询地址
  • 国内阿里仓库
  • 官方仓库
  • 高级工具

创建第一个项目

• 创建项目

$ mvn archetype:generate
...
Choose archetype:
1: internal -> org.apache.maven.archetypes:maven-archetype-archetype (An archetype which contains a sample archetype.)
...
6: internal -> org.apache.maven.archetypes:maven-archetype-profiles ()
7: internal -> org.apache.maven.archetypes:maven-archetype-quickstart (An archetype which contains a sample Maven project.)
...
10: internal -> org.apache.maven.archetypes:maven-archetype-webapp (An archetype which contains a sample Maven Webapp project.)
Choose a number or apply filter (format: [groupId:]artifactId, case sensitive contains): 7: # 选择默认即可
Define value for property 'groupId': com.xxx # 一般情况使用公司域名
Define value for property 'artifactId': lijc # 定义项目名称
Define value for property 'version' 1.0-SNAPSHOT: : # 定义版本
Define value for property 'package' com.xxx: : # 定义包名
$ tree
.
├── pom.xml # mvn包管理配置文件
├── readme.md
└── src
    ├── main
    │   └── java
    │       └── com
    │           └── xxx
    │               └── App.java # 得到的主程序运行文件
    └── test
        └── java
            └── com
                └── xxx
                    └── AppTest.java # 得到的主程序测试文件

• 指定编译器版本
  • pom.xml

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
<!--        <java.version>1.8</java.version>-->
<!--        <maven.compiler.source>1.8</maven.compiler.source>-->
<!--        <maven.compiler.target>1.8</maven.compiler.target>-->
        <java.version>13</java.version>
        <maven.compiler.source>13</maven.compiler.source>
        <maven.compiler.target>13</maven.compiler.target>
</properties>

• 编译

$ mvn clean package
-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running com.xxx.AppTest
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.018 sec

Results :

Tests run: 1, Failures: 0, Errors: 0, Skipped: 0

• 运行

$ cd target/classes/ && java com.xxx.App
Hello World! # 至此你的第一个包含包管理的项目完成了

mvn项目依赖

• 在java中使用maven来管理项目

• 第三方库查询地址

  • 国内阿里仓库
  • 官方仓库

• 添加依赖

<dependency>
    <groupId>net.dongliu</groupId>
    <artifactId>requests</artifactId>
    <version>5.0.8</version>
</dependency>

• 测试依赖

package com.xxx;

import net.dongliu.requests.Requests;

/**
 * Hello world!
 *
 */
public class App {
    public static void main(String[] args) {
        String resp = Requests.get("https://www.baidu.com/").send().readToText();
        System.out.println(resp);
    }
}

• 添加jar包插件
  • 该插件作用将依赖一起打包为jar，一般需要运行的jar包才需要该插件，如果作为库，则不需要

<build>
        <plugins>
            <plugin>
                <artifactId>maven-assembly-plugin</artifactId>
                <configuration>
                    <appendAssemblyId>false</appendAssemblyId>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                    <archive>
                        <manifest>
                            <!-- 此处指定main方法入口的class -->
                            <mainClass>com.xxx.App</mainClass>
                        </manifest>
                    </archive>
               </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <phase>package</phase>
                        <goals>
                            <goal>assembly</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

        </plugins>
    </build>

变量

• 格式

type identifier [ = value][, identifier [= value] ...] ;

• 示例

package com.xxx;

public class Var1 {
    public static void test() {
        String name = "xiaohong"; // 定义一个字符串变量
        int age = 12; // 定义整型变量
        boolean ok = true; // 定义布尔类型变量
        double d = 3.14; // 定义浮点型变量
        System.out.println(name);
        System.out.format("%s %d %f %b\n", name, age, d, ok);
        // System.out.println(name);

    }
}

运算符

package com.xxx;

public class Comput {
    public static void test() {
        int a = 1;
        a++; // ++ 运算符
        System.out.println(a);
        a--; // -- 运算符
        System.out.println(a);
        a = a * 2; // * 乘法运算符
        System.out.println(a);
        a = a / 2; // / 除法运算符
        System.out.println(a);
        a += 10; // += 运算符
        System.out.println(a);
        a = a % 2; // 求余运算符
        System.out.println(a);
        System.out.println(a > 1); // >= == > <= < !=
        a = 10;
        System.out.println(a >> 2); // 位运算 >> << >>> ~ ~ | &

        System.out.println(a > 1 && true);// 逻辑运算符 && || !
    }
}

布尔类型

package com.xxx;

public class Bool {
    public static void test() {
        boolean ok = true;
        System.out.println(ok);
    }
}

数字类型

package com.xxx;

public class Number {
    public static void test() {
        // 定义int类型
        int a = 12;
        System.out.println(a);
    }
}

指针或内存地址或引用

package com.xxx;


public class Point {
    public static void change(String[] arr) {
        arr[0] = "c";
    }

    public static void test() {
        // 在java中没有指针说法，但是可以说处处都是引用
        String[] arr = { "a", "b" }; // 定一个数组对象
        change(arr); // 改变对象的元素
        System.out.println(arr[0]); // 输出发生变化，说明本身java都是引用传递（除基本类型外）
    }
}

字符串类型

package com.xxx;

public class String1 {
    public static void test() {
        // 定义字符串
        String s = "中国"; // new String() String类型是一个对象
        System.out.println(s.length());
        // 字符串拼接
        s += " hello";
        s.concat("!!");
        System.out.println(s);
        // 格式化字符串
        int num = 1;
        String new_s = String.format("%d %s", num, s);
        System.out.println(new_s);
        System.out.println(new_s.lastIndexOf("hello1")); // 查询子字符串出现的位置，不存在返回-1
    }
}

数组或元组类型

package com.xxx;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;

public class Arr {



    public static void test() {
        // 格式type[] name
        // Arrays 提供数组类的基本方法
        String[] arr = { "abc", "hello","a" }; // 定义一个固定数组
        System.out.println(Arrays.deepToString(arr)); // 展开为字符串并输出
        System.out.println(arr[0]); // 常规数组获取数据方式
        System.out.println(arr.length); // 获取数组长度

        Arrays.sort(arr);
        System.out.println(Arrays.deepToString(arr));
        // 格式ArrayList<type> name
        // ArrayList提供动态数组的方法
        ArrayList<String> arrl = new ArrayList<>();
        arrl.add("hello");
        arrl.add("world");
        System.out.println(arrl.toString()); // 转字符串并输出
        System.out.println(arrl.size()); // 获取动态数组大小
        System.out.println(arrl.toArray()[0]); // 动态数组获取数据方式
        System.out.println(arrl.get(0)); // 动态数组获取数据方式
        arrl.remove(0); // 删除第一个元素
        System.out.println(arrl.toString()); // 转字符串并输出

        // LinkedList提供链表操作
        LinkedList<String> arrll = new LinkedList<>();
        arrll.add("hello");
        arrll.add("world");
        System.out.println(arrll.toString()); // 转字符串并输出
        System.out.println(arrll.size()); // 获取动态数组大小
        System.out.println(arrll.toArray()[0]); // 动态数组获取数据方式
        System.out.println(arrll.get(0)); // 动态数组获取数据方式
        arrll.remove(0); // 删除第一个元素
        System.out.println(arrll.toString()); // 转字符串并输出
    }
}

对象类型

package com.xxx;

// 接口可以理解抽象类，就像一个模具一样
// 接口中所有的方法必须是抽象方法，接口包含类要实现的方法

interface B {
    public String name();
}

// 抽象类
// 与普通类没什么区别，仅仅是不能实例化，仅仅只能继承
abstract class A {
    public String name() {
        return "A class";
    }
}
// class C extends A{
class C implements B {
    private int age; // 私有属性
    public String name; // 公有属性
    protected int sex; // 受保护的属性，只能实例对象访问
    // 构造方法

    C(String name) {
        this.name = name;
        this.sex = 1;
        this.age = 20;
    }
    @Override
    public String name() {
        // TODO Auto-generated method stub
        // 这里覆盖接口的方法
        return "C class";
    }
    // 静态方法: 类直接调用
    static void printHello() {
        System.out.println("hello");
    }
    // 类方法：实例对象调用
    void printName(){
        System.out.println(this.name);
    }
}

public class Obj {
    public static void test() {
        C c = new C("china");
        c.printName();
        System.out.println(c.sex);
        System.out.println(c.name());
        C.printHello();


    }
}

枚举类型

package com.xxx;

enum Color {
    red,green,white
}

public class Enum1 {
    public static void test() {
        System.out.println(Color.red); 
    }
}

变量作用域

map/集合/向量类型

package com.xxx;

import java.util.HashMap;
import java.util.HashSet;

public class Collection {
    public static void test() {
        // HashMap
        HashMap<String,String> person = new HashMap<>();
        person.put("name", "xiaohong"); // 添加一组键值对
        person.put("age", "123");
        System.out.println(person);
        System.out.println(person.get("age")); // 根据键取值
        person.remove("age"); // 根据键删除值
        System.out.println(person);
        System.out.println(person.size());
        person.put("age", "123");
        System.out.println(person.keySet());
        System.out.println(person.values());

        // HashSet
        HashSet<Integer> score = new HashSet<>();
        score.add(1); // 添加一个元素
        score.add(10);
        score.add(4);
        System.out.println(score);
        score.remove(4); // 移除元素
        System.out.println(score);

    }
}

继承或多态

package com.xxx;

import java.util.function.Supplier;

interface A1 {
    public void eat(); // 具体方法实现由用户定义
}

interface A2 {
    public void read(); // 具体方法实现由用户定义
}

abstract class All implements A1, A2 {
    String name;
    All(String name) {
        this.name = name;
    } // 构造函数 
    // 继承接口，可以使用多继承
    @Override
    public void eat() {
        // TODO Auto-generated method stub
        System.out.println("eat...");

    }
    @Override
    public void read() {
        // TODO Auto-generated method stub
        System.out.println("read...");
    }
}

public class Extends extends All {
    
    Extends(String name) { // 构造方法
        super(name); // 调用父类方法
        //TODO Auto-generated constructor stub
        super.eat(); // 调用父类其他方法
    }

    // 继承类，只能是单继承
    public static void test() {
        // 在java中类的继承仅仅支持单继承，但是多继承可以使用接口来实现
        new Extends("xiaohong");
    }

}

条件或循环

package com.xxx;

public class IfWhile {
    public static void test() {
        // 条件判断
        int a = 10;
        if (a == 10) {
            System.out.println("等于");
        } else if (a < 10) {
            System.out.println("小于");
        } else {
            System.out.println("大于");
        }
        // 循环
        String[] arr = {"1","2","0"};
        // 根据元素遍历数组
        for (var each : arr) { 
            System.out.println(each);
        }

        // 根据索引遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        // while条件循环
        while (a < 20) {
            a++;
            System.out.println(a);
        }
        
    }
}

错误处理

package com.xxx;
import java.lang.Exception;
class MyException extends Exception {
    // 自定义错误
}

public class Exception1 {


    public static void test() {
        try {
            int a = 1 / 0;
        } 
        catch (Exception e) { // 捕获异常
            // TODO: handle exception
            System.out.println(e);

            try {
                throw new Exception("新的错误"); // 抛出新的异常
            } catch (Exception e1) {
                System.out.println(e1);
            }
        } 
        finally {
            System.out.println("ok");
        }
        
    }
}

并发机制

package com.xxx;
import java.util.ArrayList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

import net.dongliu.requests.Requests;
// 业务类
class Bussiness {
    public void deal(String url) {
        // 业务主要逻辑
        String resp = Requests.get(url).send().readToText();
        System.out.println(resp);
        
    }
}

// 方法一：直接继承线程类，并重写run方法
// start():①启动线程 ②调用当前线程的run()方法
class TestThread extends Thread {
    private String url;
    private String desc;

    TestThread(String url,String desc) {
        // 构造函数
        super();
        this.url = url;
        this.desc = desc;
    }

    @Override
    public void run() {
        // 重载run方法
        // TODO Auto-generated method stub
        new Bussiness().deal(this.url);;
        System.out.println(this.getName());
        System.out.println(this.desc+Thread.currentThread());

    }

    
}

// 方法二：实现Runnable接口
// start():① 启动线程  ② 调用线程的run() --->调用Runnable接口实现类的run()
class TestRunable implements Runnable {
    private String url;
    private String desc;

    TestRunable(String url,String desc) {
        // 构造方法
        super();
        this.url = url;
        this.desc = desc;
    }

    @Override
    public void run() {
        // 重载run方法
        // TODO Auto-generated method stub
        new Bussiness().deal(this.url);
        ;
        System.out.println(Thread.currentThread().getName());
        System.out.println(this.desc + Thread.currentThread());

    }
}

// 方法三：线程池，实现Runnable接口
// 使用ThreadPoolExecutor来启动线程

public class Thread1 {
    public static void test() {
        // 整个实例中，是一个以爬虫为案例的测试
        ArrayList<String> urls = new ArrayList<>();
        urls.add("https://www.baidu.com/");
        urls.add("https://www.baidu.com/");
        urls.add("https://www.baidu.com/");
        urls.add("https://www.baidu.com/");
        urls.add("https://www.baidu.com/");
        urls.add("https://www.baidu.com/");
        // 方法一：直接继承线程类，并重写run方法
        for (String url : urls) {
            new TestThread(url,"继承Thread: ").start();
        }
        // 方法二：实现Runnable接口,并用Thread启动线程
        for (String url : urls) {
            new Thread(new TestRunable(url,"实现Runnable: ")).start();
        }
        // 方法三：线程池，实现Runnable接口
        ExecutorService pool = Executors.newFixedThreadPool(10); // 初始化线程池，并设置池大小
        ThreadPoolExecutor executor = (ThreadPoolExecutor) pool; // 将线程池转为线程执行器
        executor.setCorePoolSize(5); // 设置核心池大小
        for (String url : urls) {
            executor.execute(new TestRunable(url, "实现线程池: "));
        }
        System.out.println("ok");
        System.out.println(executor.isTerminated()); // 查看执行器是否终止
        executor.shutdown();

        
    }
}

特性机制

• 在java中，也可以通过范型来表达抽象的类，以达到通用

package com.xxx;


class TestT<T> {
    // T是范型代表符号
    private T sex;

    TestT(T sex) {
        // 构造方法
        this.sex = sex;
    }

    public void printSex() {
        // 类方法
        System.out.println(this.sex.getClass() == String.class); // 获取属性的类型
        System.out.println(this.sex);
    }
}

public class F {
    public static void test() {
        TestT<String> f1 = new TestT<String>("男");
        f1.printSex();
        TestT<Integer> f2 = new TestT<Integer>(1);
        f2.printSex();
    }
}