《Java系列-学习相关》Java详细入门教程_java的入门教程

一、JAVA环境配置

1.1 jdk安装

选择合适得jdk文件->安装在C盘下得Programs中
1

1.2 环境配置

在计算机属性高级系统设置中配置环境变量:
->JAVA_HOME=C:\Programs\Java\jdk1.8.0_25  一些Java开发工具直接通过查找JAVA_HOME扎到Java路径
->Path=%JAVA_HOME%\bin     帮助找到jdk的bin路径下可执行文件
->CLASSPATH=;%JAVA_HOME%\lib   类加载路径
1
2
3
4

1.3 HelloWorld

//创建txt文档，修改后缀为java：
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("HelloWorld");
    }
}
1
2
3
4
5
6

1.4 控制台测试

win+r
cmd
cd /d E:\BigData\202103\Day001\code
javac HelloWorld.java
java HelloWorld
1
2
3
4
5

二、命名基础

cd : 切换目录（chance directory）
eg:cd /lixi/
cd .. : 返回上一级目录
c: -> 切换到c盘
d: -> 切换到D盘

dir ： 查看文件目录下的所有的子文件或者子目录
rd ： 删除目录
del ： 删除文件
exit ： 推出dos窗口
notepad ： 打开记事本
mspaint ： 打开画图
1
2
3
4
5
6
7
8
9
10
11
12

三、Java基础语法

1 特性

1. oop(面向对象)
2. 跨平台
3. 开源免费
4. 健壮性
5. 安全性
6. 垃圾回收机制（gc）：自动帮助回收内存中使用完毕的程序。System.gc()建议jvm可以去回收垃圾。
1
2
3
4
5
6

2 环境变量(理解)

JAVA_HOME:因为后期有工具底层使用java源码开发，会需要调用JAVA_HOME去寻找JDK
PATH：系统会去PATH指定的路径下寻找命令
CLASSPATH：类加载的路径
1
2
3

2.1 HelloWorld

public class HelloWorld {
	public static void main(String[] args) {
		System.out.println("Hello Ketty");
	}
}
1
2
3
4
5

2.2 CLASSPATH

• 配置环境变量的

CLASSPATH=.;%JAVA_HOME%\lib
1

%JAVA_HOME%\lib:

这个配置是为了让我们在需要使用java的原生类的时候直接去调度

2.3 public

public class HelloWorld
被public修饰的class，他的类名必须和xxx.java文件的文件名称相同
1
2

3 注释：批注和解释（会用）

注释在编译的时候并不会被编译成class

3.1 3种

// : 单行注释

/* */ ：多行注释

/** */ ： 文本注释

public class Demo2 {
	/**
	 * 入口方法
	 */
	public static void main(String args[]) {
		// int a = 0;
	}
	
	/*
	 * 说
	 */
	public void speak() {
		
	}
	
	/**
	 * 欢迎学习
	 */
	public void welcome() {
		
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

javadoc Demo2.java 生成API文档，index.html

4 进制（了解）

4.1 进制的种类

2进制：逢二进一，1，0
8进制：逢八进一，0，1，2，3，4，5，6，7
10进制：逢二进一，0，1，2，3，4，5，6，7，8，9
16进制：逢g进一，0，1，2，3，4，5，6，7，8，9，a，b，c，d，e，f
1
2
3
4

5 标识符（理解）

5.1 什么是标识符

任何给java取名称的都叫做标识符
1

5.2 标识符的命名规则

1. 字母、下划线、数字、$
2. 数字一定不能开头
3. 标识符不能和关键字重名
4. 区分大小写
5. 长度无限(一般超过15个字符)
6. 见名知意
7. 中文，但是不让用（乱码），编码和解码
8. 驼峰命名：
类的命名：大驼峰》HelloWorld
方法/函数/变量：小驼峰》helloSiri
常量：全大写，单词之间使用下划线连接》BLUE_WATER
1
2
3
4
5
6
7
8
9
10
11

6 关键字(了解)

在java中被赋予了特殊含义的单词，全部都是小写

保留字：goto、const

7 8种简单类型/基本类型(记忆)

布尔类型：boolean，表示真假，只有true和false

整数类型：byte、short、int、long

浮点/小数类型：float/double

字符类型：char

7.1 整数类型

• 取值范围

// 0000 0000 --》 -128 ~ 127 --》 -2^7 ~ 2^7 - 1
// 1short = 2byte --》 -2^15 ~ 2^15 - 1
// 1int = 4byte --》 -2^31 ~ 2^31 - 1
// 1long = 8byte --》 -2^63 ~ 2^63 - 1
1
2
3
4

• 隐式转换

public class Demo4 {
	/**
	 * 1bit 
	 * 1byte = 8bit
	 * 1kb = 1024byte      ---->   1k = 1000byte
	 * 1mb = 1024kb
	 * 1gb = 1024mb
	 * 1tb = 1024gb
	 * 1pb = 1024tb
	 * 1zb = 1024pb
	 * ...
	 */
	public static void main(String args[]) {
		// 0000 0000 --》 128 ~ 127 --》 -2^7 ~ 2^7 - 1
		// 1short = 2byte --》 -2^15 ~ 2^15 - 1
		// 1int = 4byte --》 -2^31 ~ 2^31 - 1
		// 1long = 8byte --》 -2^63 ~ 2^63 - 1
		byte b = 1; //0000 0001
		System.out.println(b);
		
		long l = 123; // int，隐式转换
		long l2 = 1L; // long, 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0001
		
		int i = 1;
		short s = 1;
		
		if(b == l2) System.out.println("------"); //b: 0000 0000 0000 0000 0000 0000 0000 0001
												  //l2 ：0000 0000 0000 0000 0000 0000 0000 0001
		char c1 = 'a'; // 97
		System.out.println(c1 + 1); // 98
		
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

​ 两个数值类型通过运算符进行计算的情况下，两个变量会通过隐式转换为int类型进行计算(两个变量在转换的过程中不能损失精度)

7.2 小数类型

public class Demo5 {
	public static void main(String args[]) {
		float f = 9.0F; // 单精度
		Double d = 9.0; // 双精度
		int i = 9;
		// 9.0 --》 0.8999999999999
		System.out.println(i == d);
	}
}
1
2
3
4
5
6
7
8
9

7.3 char

char c1 = 'a';
char c2 = '中'; // unicode
System.out.println(c2+100);
1
2
3

字符只能在声明的时候写一个单词或者一个汉字

java底层对于字符的处理采取的是unicode编码，所以支持的范围特别的广泛

7.4 boolean

true和false

boolean isok = true;

if(isok) System.out.println("hello world");
1

8 除开8种简单类型，其他的都是引用类型/复杂类型

String

数组

枚举

接口

类

。。。

9 练习

a=1, b=2

写程序将他们的值互换

import java.util.Scanner;
public class Demo6 {
	public static void main(String args[]) {
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入a的值：");
		int a = scan.nextInt();
		System.out.println("请输入b的值：");
		int b = scan.nextInt();
		System.out.println("a = " + a + ", b = " + b); // a = 1, b = 2
		System.out.println("a和b的值互换之后的结果为：");
		// 利用第三个变量
		int temp = a;
		a = b;
		b = temp;
		System.out.println("a = " + a + ", b = " + b); // a = 1, b = 2
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

10 常量和变量（记住）

10.1 常量：不可变的值

1、2、3、4
"abc"
true
false
1
2
3
4

字面值常量：以上的都是

自定义常量：

final static 数据类型 常量名 = 值

e.g.

final static int NUM = 1;
NUM = 2;
C:\teach\hzbigdata2101\day002\code>javac Demo7.java
Demo7.java:4: 错误: 需要<标识符>
        NUM = 2;
           ^
1
2
3
4
5
6

10.2 变量：可变的值

int i = 1;
i = 2;

int i2 = i;
1
2
3
4

数据类型 变量名 = 值/地址

• 局部变量

只要不是直接定义在类中的都是局部变量，局部只在局部生效
1

• 全局变量

定义在类中的，方法外/初始化块的就是全局变量
1

public class Demo8_Student {
	
	public static int i = 2; // 全局变量
	
	public static void main(String args[]) {
		//int i = 1; // 局部变量
		qphone();
		System.out.println(i);
	}
	
	public static void qphone() {
		System.out.println(i);
	}
}

public class Demo9_Student {
	
	public static int i; // 全局变量
	
	public static void main(String args[]) {
		//int i = 1; // 局部变量
		System.out.println(i);
	}
	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

• 总结

1. 声明位置不同：
局部变量的作用域在方法或语句块中，全局变量在整个类中

2. 是否由默认初值
局部变量必须得自定义初始值，全局变量不用，有默认初值
1
2
3
4
5

10.3 内存简介（了解）

1. 栈内存：Stack，连续的内存空间，先进后出，主要存放局部变量
2. 堆内存：Heap，不连续的内存空间，存放对象，对象的实例。new出来的都放在这里
3. 方法区（Method），其实他是在堆空间之内，存放类的信息，静态的变量和方法，常量池

四、练习一：单例设计模式、静态工厂、装饰者设计模式

1. 单例设计模式

1.1 懒汉式设计模式

public class Singleton{
    private Singleton(){}
    public static Singleton single = null;
    public static Singleton getInstance(){
        if(single == null){
            single = new Singleton();
        }
        return single;
    }
}
1
2
3
4
5
6
7
8
9
10

1.2 饿汉式设计模式

public class Singleton{
    private Singleton(){}
    public static Singleton single = new Singleton();
    public staticc Singleton getInstance(){
            return single;
    }
}
1
2
3
4
5
6
7

2. 静态工厂设计模式

public class ShopFactory{
    public static ShopService getService(){
        return new ShopServiceImpl();
    }
    public static DB getShopDB(){
        return new MyDB();
    }
}
1
2
3
4
5
6
7
8

3. 装饰者设计模式

public class Student{
    public void study(){
        System.out.println("数学");
    }
}

public class College extends Student{
    private Student student;
    
    private College(Student student){
        this.student = student;
    }
    
    public void study(){
        System.out.println("高数");
        Student.study();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

五、练习二：IO流

实现功能：

指定一个目录，从该目录和该目录的子目录下寻找后缀名为.java的代码文件

并输出每一行的代码

package day014;

import java.io.*;

public class M_text2 {
    public static void main(String[] args) throws IOException {
        File file = new File("E:\\BigData\\bd\\202103\\code\\text");

        FindCode(file);

    }

    public static void FindCode(File file){


        File[] fs = file.listFiles();

        for (File files : fs) {

            if (files.isFile() && files.getName().endsWith(".java")) {
                System.out.println("1");

                getCode(files);

            } else if (files.isDirectory()) {
                FindCode(files);
                System.out.println("2");
            }

        }


    }

    public static void getCode(File files) {

        try{

            FileInputStream fis = new FileInputStream(files);
            LineNumberReader lineNumberReader = new LineNumberReader(new InputStreamReader(fis));

            String line = null;
            while ((line = lineNumberReader.readLine()) != null) {

                System.out.println(lineNumberReader.getLineNumber() + ", " + line);
            }

            lineNumberReader.close();
            fis.close();


        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

六、练习三：给一个目录，将这个目录中所有的Java文件输出

package day012;

import java.io.File;

public class Demo3 {
    public static void main(String[] args){
        search("E:\\BigData\\bd\\202103\\code");//查找指定目录下的指定文件
    }

    public static void search(String path)//查找方法
    {
        File file = new File(path);

        File[] subFiles = file.listFiles();       //获取指定路径下所有的文件或文件夹对象

        if (null!=subFiles){//如果查找的目录非空
            for (File subFile : subFiles) {//for each循环
                if (subFile.isDirectory())        //如果指定路径下的文件为文件夹则递归寻找，后缀为Java文件则输出名字
                    search(subFile.getAbsolutePath());//递归查找
                else if(subFile.isFile() && subFile.getName().endsWith(".java"))//如果指定路径下的文件是一个文件，获取他的名字并判断猴嘴是不是".java"
                    System.out.println(subFile.getName());//输出查找到目录
            }
        }
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26