Java - 标签 - 菠菜眾長https://lruihao.cn/tags/java/Java - 标签 - 菠菜眾長Hugo -- gohugo.iozh-CN1024@lruihao.cn (Lruihao)1024@lruihao.cn (Lruihao)Thu, 15 Aug 2019 18:30:31 +0000Web 开发规则，代码规范https://lruihao.cn/posts/dev-rules/Thu, 15 Aug 2019 18:30:31 +0000Lruihaohttps://lruihao.cn/posts/dev-rules/精神
  • 绝不写死代码，硬编码
  • 不留不要用的、垃圾代码

Git

  • Master 的 BUG 必须最少且趋近于零，为最稳定的版本
  • 每次 Commit 信息应该准确填写。不可模棱两可，eg: 修复 BUG、增加功能
  • 禁止 Commit IDE 的 project data，e.g: .vscode
  • 禁止上传垃圾代码

更多规则详见文档 Commit 规范

分支（Branch）

  • 命名规则：应以此分支主要目的命名（修复什么 BUG，新增特定功能）
  • 合并后的分支应该删除

commit

  • 遵循一个功能一个 commit 的原则

Restful

  • 资源名词站在 API 的角度思考

    • 复数名词：可以复数笔数据，回传结果为 Array

      举例：GET/users 取得多笔使用者资料

      • 刪除，放在复数名词內，让 Router 保持一致性
      • 增加，放在复数名詞內，让 Router 保持一致性

    • 单数名词：仅取得单笔数据，必须指定 PK，两两一组，回传结果为 Object 举例：GET/user/{accont} 取得单笔使用者资料，必须指定 PK

  • URL 中一律不带 id 参数

1
2

正确范例： calendar_manager/calendar/29
错误范例： calendar_manager/calendar/29?id=29

更多规则详见文档 RESTful

命名

  • 命名应根据内容做有意义的命名，让后续维护人员可以顾名思义！
  • 即使不会发生错误，代码英文大小写也需明确区分。

语意

类型 命名规则 说明
属性 (Attribute, Property) 名词 user_name、userName
方法 (Method, Function) 动词 + 名词 getUserName、get_user_name 常見的动词有：get、set、update、delete、remove

字母与分隔

语言 变量 (Variable, Parameter, Argument) 常量 (Constant) 面向对象 - 类名 (Class Name) 面向对象 - 成员 (mebmer)
HTML 全部小写，不同单词以「-」分隔
e.g: user-id
CSS、SCSS 全部小写，不同单词以「-」分隔，CSS 变量以「–」开头，SCSS 变量以「$」开头
e.g: .user-id、–header-height、$header-height
JavaScript 驼峰式命名法
首字小写，不同单字「首字以大写」分隔
e.g: userId		 全部大写，不同单字以「_」分隔 MAX_COUNT 驼峰式命名法
首字大写，不同单字「首字以大写」分隔
一个文件放一个 Class, 文件名即为 Class Name
e.g: User		 驼峰式命名法
公有 (public) : 首字小写，不同单词「首字以大写」分隔
e.g: name, getName
私有 (private): _公有命名规则
e.g: _name,_getName
Vue
Java
PHP 全部小写，不同单词以「_」分隔
e.g: user_id
Python
SQL 由使用者定义的：表名、字段名
全部小写，不同单词以「_」分隔		 SQL 语法、函数全部大写
e.g: SELECT、INSERT INTO

通用

  • 代码编写
  • 每个函数应该使用块注释，注释应包含函数功能说明、参数说明。规则见：JSDoc、JavaDoc
  • 不必要的代码不要写，也应禁止放到注释里面！
  • if-else 的 {} 严禁省略
  • 代码规范、代码排版等可通过 eslint 等工具做统一处理

正确写法

1
2
3
4
5
6

public function test () {
  // do something
  if (a === b) {
    // do something
  }
}

错误写法

1
2
3
4
5
6
7
8

public function test ()
{
  // do something
  if (a === b)
  {
    // do something
  }
}
  • 代码排版
    • 任何代码应该以 2 个 space 为一个缩进做好排版、不可使用 tab
  • 函数 (Function, Methd)
    • 函数声明时需在函数上方加上函数注释，注释应包含函数说明、参数内容（参数类型、参数英文名称、参数说明）、返回值内容（返回值类型、返回值说明）
  • 类 (Class)
    • 一个类（Class）的声明只能存在一个文件
    • 类（Class）的声明文件，文件名必须为类名
  • 其他
    • 连接本地任何其他资源（图片、文件、网站）皆使用相对路径，禁止使用绝对路径，非本地资源除外

HTML

代码编写

  • 禁止在 HTML 使用 <style>、<script>，一律使用外部档案引用方式引用 CSS、JavaScript 文件
  • HTML 标签需成双成对，有头有尾
  • 块级标签：<tag></tag>
  • 单标签：<tag />
  • 禁止使用已被 HTML 舍弃的旧标签、属性，如：
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

<!-- html tag -->
<center>
<font>
<basefont>
<s>
<strike>
<u>
<listing>
<plaintext>
<xmp>
<!-- html attribute -->
align
bgcolor
color

CSS

CSS 的定义应该独立一个 CSS 文件，禁止使用 <style> 或 style 属性直接在 HTML 中定义样式。

JavaScript

禁止使用 HTML 字串，一律使用 Dom 产生 HTML, e.g: document.createDocumentFragment()

注释

JavaScript 注释应该遵循 JSDoc 的标准撰写

全局变量 (Global)

1

/* global ZT */

常量 (Constant)

1
2
3
4

/**
 * 常量說明
 * @type {常量类型}
 */

Example

1
2
3
4
5

/**
 * 请求地址
 * @type {String}
 */
const REQUEST_URL = 'http://localhost:8080';

函數、方法 (Function, Method)

1
2
3
4
5
6
7

/**
 * 函数用途说明
 * @param {参数类型} 参数名称参数说明
 * @param {参数类型} [选择性参数名称] 参数说明
 * @param {参数类型} [选择性参数名称=参数预设值] 参数说明
 * @returns {返回值类型} 返回值说明
 */

Example

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

/**
 * 取得使用者
 * @param {Int} userId 使用者 ID
 * @param {Object} [options] 其他选项
 * @param {String} [options.query='a'] 查询关键词 默认为 'a'
 * @returns {Object} 使用者资料
 */
function getUser(userId, options) {
  // do something
  return user;
}

Vue

  • 待补充

Java

Java 注释应该遵循 JavaDoc 的标准撰写

  • 待补充

PHP

前端参数取得

参数取得需通过 filter_input 函数取得，不得使用 _GET 、_POST

输出到前台

参数命名必须为：全部小写，不同单字以「_」分隔

注解

PHP 注解应该遵循 PHPDoc 的标准撰写

成员变量 (Member)

成员变量只的是 Class 内的成员变数，我们都会要求替成员变量增加注解说明。通常 Function 的变量除非太特别否则都不需要特别注解说明。

1
2
3
4

/**
 * 成员变量說明
 * @type {类型}
 */

Example

1
2
3
4
5

/**
 * 使用者 ID
 * @type {String}
 */
$userId = 'Hello';

函数、方法 (Function, Method)

1
2
3
4
5
6
7

/**
 * 函数用途说明
 * @param 参数型态 参数名称 参数说明
 * @option 参数选项类型 参数选项名称 参数选项说明
 * @uses 全局变量 全域变数说明
 * @returns 返回值类型 返回值说明
 */

Example

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

/**
 * 取得使用者
 * @param int userId 使用者 ID
 * @param object options 其他选项
 * @option string options['query'] 查询关键字
 * @uses $_POST['role_id'] 从前端以 POST 取得角色 ID
 * @returns object 使用者资料
 */
function getUser ($userId, $options) {
  // do something
  return $user;
};

Python

  • 待补充

Database

  • 禁止使用 Table Join。
  • 禁止使用 Oracle Trigger。
  • 禁止将查询数据库的 SQL 放在循环中查询

SQL 撰写

  • 属于 SQL 语法使用大写（SELECT，WHERE，INSERT etc..）
  • 属于使用者自己定义的使用小写（表名 table name，字段名 column name etc..）
  • 表名、字段名前后需加上 `

Example

1

INSERT INTO `user` VALUES('a', 'b');

统一用词

系统中常用词，例如弹出框按钮、搜索框等，仅为举例，不限与此。

用词 统一
最后、最终 最后
关闭、Cancel、取消 取消
存储、保存、修改、OK、确定 确定
搜寻、查询、查找、搜索 搜索
]]>java 实现一个单线程的资源下载器https://lruihao.cn/posts/singlethreaddown/Wed, 08 May 2019 20:55:02 +0000Lruihaohttps://lruihao.cn/posts/singlethreaddown/

实现一个简单的基于单线程的资源下载器，如图所示，用户可以任意指定下载资源的链接地址，系统根据该地址判断资源是否存在，如果存在，则将该资源下载到本地。

GUI 设计基本流程

先记录一下 GUI 设计的基本流程：

  1. 根据需要从相应的顶层容器继承（如果创建窗体就继承 JFrame，对话框就继承 JDialog），新建一个子类。
  2. 然后设置顶层容器的属性，包括大小、位置、标题和关闭事件等。
  3. 设置界面上 GUI 组件的事件响应。 public void actionPerformed(ActionEvent e) {}
  4. 向顶层容器上添加 GUI 组件，并设置布局。（通常利用 JPanel 组件先作为微型容器）
  5. 创建新建子类的实例，调用 setVisible(true) 方法显示页面。（也可以直接在子类中设置 setVisible(true)）

实现代码

 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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

package cn.lruihao.base;

import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.HeadlessException;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JTextField;

public class SingleThreadDown extends JFrame implements ActionListener {
	private final JPanel panel=new JPanel();
	private final JLabel label1=new JLabel("网络资源的单线程下载：");
	private final JLabel label2=new JLabel("网络资源的网址：");
	JButton StartButton = new JButton("单击开始下载");
	JButton resetButton = new JButton("清空");
	JButton exitButton = new JButton("退出");
	JTextField urlField  = new JTextField(20);

	public SingleThreadDown() {
		panel.setLayout(new FlowLayout()); //布局管理器
		label1.setFont(new Font("雅黑",Font.BOLD,15));
		panel.add(label1);
		panel.add(label2);
		panel.add(urlField);
		panel.add(StartButton);
		panel.add(resetButton);
		panel.add(exitButton);
		setContentPane(panel);
		setSize(400,200);
		setLocation(400,400);
		setVisible(true); //面板可视化，也可以在 main 中通过 JFrame 子类对象调用方法设置
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //默认关闭事件
		StartButton.addActionListener(this);//添加点击事件，传入 ActionListener 对象，由于子类继承了 ActionListener 接口，所以 this
		resetButton.addActionListener(this);
		exitButton.addActionListener(this);
	}

	public void download(String address) throws Exception {
		URL url = new URL(address);
		URLConnection urlcon = url.openConnection();
		urlcon.connect();
		InputStream in=urlcon.getInputStream();//获取的字节流对象
		String filePath = url.getFile();
		int pos=filePath.lastIndexOf("/"); //"/"分割的最后一个串的下标
		String fileName = filePath.substring(pos+1);
		FileOutputStream out = new FileOutputStream("C:\\Users\\李瑞豪、\Desktop\\"+fileName);
		byte[] b = new byte[1024];
		int len=0;
		while((len=in.read(b,0,1024))!=-1) {
			out.write(b,0,len);
		}
		out.close();
		in.close();
		JOptionPane.showMessageDialog(this, "下载完毕");
	}

	@Override
	public void actionPerformed(ActionEvent e) {
		if(e.getSource()==StartButton) {
			if("".equals(urlField.getText())){
				JOptionPane.showMessageDialog(this, "请输入资源地址");
			}
			String url = urlField.getText();
			try {
				download(url);
			} catch (Exception e1) {
				JOptionPane.showMessageDialog(this, "资源地址有误，请检查~");
				e1.printStackTrace();
			}
		}else if(e.getSource()==resetButton) {
			urlField.setText("");
		}else {
			System.exit(0);
		}

	}

	public static void main(String[] args) {
		new SingleThreadDown();

	}

}

运行结果测试

通过https://github.com/Lruihao/Grocery/raw/master/fonts/MMT_last.ttf下载沐目体 ttf 字体文件，稍微等待一下弹出对话框“下载完毕”，经检查下载内容正常。

]]>java 通过 URL 和 URLConnection 访问网页资源https://lruihao.cn/posts/java-urlreader/Mon, 06 May 2019 17:41:35 +0000Lruihaohttps://lruihao.cn/posts/java-urlreader/

该例中首先生成一个 URL 对象 lrh，指向 RUI 豪小栈，然后再调用 lrh.openStream() 方法生成该 URL 的一个输入流，这是一个字节流，在此基础上进一步通过 InputStreamReader 和 BufferedReader 构造一个带缓冲功能的字符流，并通过这个字符流对象读取该 URL 的 html 内容，进而输出到桌面文件和控制台屏幕。URLConnection 类也可以用来对由 URL 引用的资源进行读写操作，前提是先通过 connect() 方法建立连接，然后再去获取响应头信息或响应内容。

 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

package cn.lruihao.base;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileWriter;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLConnection;

public class URLReader {

	public static void main(String[] args) throws Exception{
		try {
			URL lrh=new URL("https://www.lruihao.cn");
			File file=new File("C:\\Users\\李瑞豪、\Desktop\\lrh.html");
			FileWriter fout=new FileWriter(file);
			BufferedReader in =new BufferedReader(new InputStreamReader(lrh.openStream()));//字节流转化成字符流，再构建缓冲字符流
			String inputLine;
			while((inputLine=in.readLine())!=null) {
				System.out.println(inputLine);
				fout.write(inputLine);
			}
			in.close();
			fout.close();

			//获取响应 header 信息
			URLConnection conn=lrh.openConnection();
			conn.connect();
			System.out.println("获取到的响应长度："+conn.getContentLength());
			System.out.println("响应类型："+conn.getContentType());

			//用 BufferedReader 读取 URL 的响应
			in =new BufferedReader(new InputStreamReader(conn.getInputStream()));
			String line;
			String result=null;
			while((line=in.readLine())!=null) {
				result+=line;
			}
			System.out.println(result);
		} catch (Exception e) {
			e.printStackTrace();
		}

	}

}
]]>文件加密解密（字节流）https://lruihao.cn/posts/byteio/Thu, 02 May 2019 23:04:32 +0000Lruihaohttps://lruihao.cn/posts/byteio/

基本功能： 给定一个密钥，读取文件内容，加密后，输出到另外一个文件。

这里使用文件输入流读取文件内容，然后每个字节和密码进行异或简单加密。加密完成，使用文件输出流写入另一个文件中。解密和加密方法一样。利用的是对同一个数异或两遍其值不变的性质。因此一个程序可以完成加密和解密功能。只需修改文件名即可。

文件加密解密

 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

package cn.lruihao.base;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class EncryptFile {

	public static void main(String[] args) throws IOException {
		byte pwd=123;//加密/解密密码
		FileInputStream f=new FileInputStream("src/cn/lruihao/base/EncryptFile.java");//待加密文件
		FileOutputStream fout=new FileOutputStream("encrypted.txt");//已加密文件
		System.out.println("开始加密。");
		int n=f.available()/5;
		byte[] b=new byte[n];//以一个字节数组的长度读取和复制
		int count=0;
		while((count=f.read(b,0,n))!=-1) {
			//写入之前先加密/解密
			for(int i=0;i<count;i++) {
				b[i]=(byte)(b[i]^pwd);//
			}
			fout.write(b,0,count);
		}
		System.out.println("完成加密");
		f.close();
		fout.close();
//		f=new FileInputStream("encrypted.txt");
//		fout=new FileOutputStream("unencrypted.txt");
//		System.out.println("开始解密。");
//		n=f.available()/5;
//		b=new byte[n];//以一个字节数组的长度读取和复制
//		count=0;
//		while((count=f.read(b,0,n))!=-1) {
//			//写入之前先加密/解密
//			for(int i=0;i<count;i++) {
//				b[i]=(byte)(b[i]^pwd);
//			}
//			fout.write(b,0,count);
//		}
//		System.out.println("完成解密");
//		f.close();
//		fout.close();
	}

}

文件复制

 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

package cn.lruihao.base;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileStreamCopy {

	public static void main(String[] args) throws IOException {
		int size;
		FileInputStream f=new FileInputStream("src/cn/lruihao/base/FileStreamCopy.java");
		FileOutputStream fout=new FileOutputStream("copy-of-file.txt");
		System.out.println("总长度："+(size=f.available()));
		int n=size/10;
		System.out.print("使用单字节方法读取后：");
		for(int i=0;i<n;i++) {
			fout.write(f.read());
		}
		System.out.println("剩余长度："+f.available());
		System.out.println("读取一个字节数组后：");
		byte b[]=new byte[n];
		f.read(b);
		fout.write(b);
		System.out.println("剩余长度："+f.available());
		System.out.println("读取余下数据：");
		int count=0;
		while((count=f.read(b,0,n))!=-1) {
			//System.out.println(count);
			fout.write(b,0,count);
		}
		System.out.println("剩余长度："+f.available());
		f.close();
		fout.flush();
		fout.close();
	}

}
 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

package cn.lruihao.base;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class BufferedStreamCopy {

	public static void main(String[] args) throws IOException {
		FileInputStream f=new FileInputStream("src/cn/lruihao/base/BufferedStreamCopy.java");
		FileOutputStream fout=new FileOutputStream("copy-of-file.txt");
		BufferedInputStream bis=new BufferedInputStream(f);
		BufferedOutputStream bos=new BufferedOutputStream(fout);
		System.out.println("开始复制。");
		int n=f.available()/5;
		byte[] b=new byte[n];
		int count=0;
		while((count=bis.read(b,0,n))!=-1) {
			bos.write(b,0,count);
		}
		System.out.println("复制完成");
		bis.close();
		bos.flush();
		bos.close();
		f.close();
		fout.flush();
		fout.close();
	}

}
]]>模拟借书系统（java 异常练习）https://lruihao.cn/posts/javaexception/Wed, 01 May 2019 16:52:21 +0000Lruihaohttps://lruihao.cn/posts/javaexception/

实现代码

这里的异常主要是InputMismatchException, 可以直接捕获该异常，我直接捕获了父类异常。

 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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

package cn.lruihao.Exception;

import java.util.Scanner;

/**
 * @author 李瑞豪
 *	借书系统（异常练习）
 */

public class ExceptionDemo {
	private final Book[] books = {
		new Book("数据结构"),
		new Book("Java"),
		new Book("php"),
		new Book("c")
	};

	public static void main(String[] args) {
		System.out.println("欢迎来到借书系统！");
		ExceptionDemo jieshu= new ExceptionDemo();
		jieshu.menu();
	}

	public void menu() {
		System.out.println("输入命令：1. 书名查找；\t2. 序号查找；");
		 //初始化并捕获用户输入
		Scanner sc = new Scanner(System.in);
//		捕获异常
		try {
			int id =sc.nextInt();
			if(id==1||id==2) {
				inquire(id);
			}else {
				System.out.println("输入错误！请根据提示输入~~");//输入非 1，2 的数字情况
				menu();
			}
		}catch (Exception e) {//输入字符为非数字
			e.printStackTrace();
			System.out.println("输入错误，请输入数字命令~~");
			menu();
		}finally{
			sc.close();
		}
	}

	private void inquire(int id) {
		Scanner sc = new Scanner(System.in);

		if(id==1) {
			System.out.println("请输入要查找的书名！");
			String name=sc.nextLine();
			int num=FindName(name);
			if(num==0?false:true) {//验证书名是否存在 存在则打印
				System.out.println("book："+name+"\t 序号："+num);
				//menu();//回到访问起点 也可以去掉终止程序
			}else{
	            System.out.println("图书不存在");
	            menu();
	        }
			sc.close();
		}else if(id == 2) {
			System.out.println("请输入您要查找的序号：");
			int id2=sc.nextInt();
			FindNum(id2);
			sc.close();
		}

	}

	private void FindNum(int num) {
		try {
			if(num>=0&&num<books.length) {
				 System.out.println(books[num].getName());
				 //menu();//回到访问起点 也可以去掉终止程序
			}else{
	            System.out.println("图书不存在");
	            menu();
	        }
		}catch (Exception e) {
			e.printStackTrace();
			System.out.println("输入有误！~~");
		}

	}

	private int FindName(String name) {
		int num=0;
		for(Book i:books) {
			String name1=i.getName();
			if(name1.equals(name)) {
				return num;
			}
			num++;
		}
		return 0;
	}
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

package cn.lruihao.Exception;

public class Book {
	private String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Book(String name) {
		this.name = name;
	}

}

大致运行效果

]]>用记事本编写第一个 java 程序https://lruihao.cn/posts/hellojava/Fri, 19 Apr 2019 19:49:54 +0000Lruihaohttps://lruihao.cn/posts/hellojava/

之所以用记事本来写不是为了装 X 或者什么的。反而恰恰是返璞归真，因为在用 java 语言进行程序开发时，首先是以纯文本的方式编写所有的 java 源程序，并保存成以.java为后缀的文件；然后将这些源程序用javac编译成.class后缀名的字节代码文件；字节代码不是被本地处理器执行的代码，而是能够被 java 虚拟机（JVM）执行的代码。最后用 java 运行工具在 JVM 执行 java 应用程序。
由于 JVM 可以运行在不同的操作系统上，因此同一个字节代码文件可以跨平台运行。

  • javac
  • java

编写 java

用记事本编辑 java 文件，并且把后缀改成.java，文件名和类名要一样。

1
2
3
4
5

public class HelloWorld{
	public static void main(String[] args){
		System.out.println("Hello World!");
	}
}

打开 cmd

]]>java 正则表达式练习https://lruihao.cn/posts/java-regex/Thu, 18 Apr 2019 22:04:21 +0000Lruihaohttps://lruihao.cn/posts/java-regex/邮箱 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexDemo {
    public static void main(String[] args) {
//       Pattern 类 正则表达式的编译表示。
        Pattern pattern = Pattern.compile("^[a-zA-Z0-9_!#$%&'*+/=?`{|}~^.-]+@[a-zA-Z0-9.-]+$");
        String[] emails = {"admin@lruihao.cn", "lruihao.cn"};
        for (String email :
                emails) {
//Matcher 通过解释 Pattern 对字符序列执行匹配操作的引擎
            Matcher matcher = pattern.matcher(email);
            System.out.println(email + "匹配结果：" + matcher.matches());
        }
    }
}
1
2

admin@lruihao.cn 匹配结果：true
lruihao.cn 匹配结果：false

电话

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

package base;

import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexTest {
	public static void main(String[] args) {
		Pattern patter=Pattern.compile("^[1][3,4,5,7,8][0-9]{9}$");
		Scanner sc=new Scanner(System.in);
		String telnum=sc.nextLine();
		sc.close();
		Matcher matcher=patter.matcher(telnum);
		System.out.println(telnum+"匹配结果： "+matcher.matches());
	}
}
 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

/**
 * 获取当前的 httpSession
 * @return
 */
public static HttpSession getSession() {
 return getRequest().getSession();
}
/**
 * 手机号验证
 * @param str
 * @return 验证通过返回 true
 */
public static boolean isMobile(final String str) {
  Pattern p = null;
  Matcher m = null;
  boolean b = false;
  p = Pattern.compile("^[1][3,4,5,7,8][0-9]{9}$"); // 验证手机号
  m = p.matcher(str);
  b = m.matches();
  return b;
}
/**
 * 电话号码验证
 * @param str
 * @return 验证通过返回 true
 */
public static boolean isPhone(final String str) {
  Pattern p1 = null, p2 = null;
  Matcher m = null;
  boolean b = false;
  p1 = Pattern.compile("^[0][1-9]{2,3}-[0-9]{5,10}$"); // 验证带区号的
  p2 = Pattern.compile("^[1-9]{1}[0-9]{5,8}$");     // 验证没有区号的
  if (str.length() > 9) {
    m = p1.matcher(str);
    b = m.matches();
  } else {
    m = p2.matcher(str);
    b = m.matches();
  }
  return b;
}

身份证

1
2
3
4

/* 身份证正则表达式 16 或 18 */
   public static final String IDCARD="((11|12|13|14|15|21|22|23|31|32|33|34|35|36|37|41|42|43|44|45|46|50|51|52|53|54|61|62|63|64|65)[0-9]{4})" +
           "(([1|2][0-9]{3}[0|1][0-9][0-3][0-9][0-9]{3}" +
           "[Xx0-9])|([0-9]{2}[0|1][0-9][0-3][0-9][0-9]{3}))";
]]>java 常用类https://lruihao.cn/posts/stringbuffer/Sun, 14 Apr 2019 10:12:44 +0000Lruihaohttps://lruihao.cn/posts/stringbuffer/StringBuffer/StringBuilder（掌握）

StringBuffer 是线程安全的可变字符串。

StringBuilder 是线程不安全的可变字符串。
和 StringBuffer 的功能一样。就是效率高一些，但是不安全。

构造方法：

  • StringBuffer sb = new StringBuffer();
  • StringBuffer sb = new StringBuffer(50);
  • StringBuffer sb = new StringBuffer(“hello”);

成员方法：（自己补齐方法和意思）

  • 添加功能
    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 和 StringBuffer 的相互转换，通过构造即可。
  • 把数组转成指定的字符串格式
  • 把字符串反转
  • 判断一个字符串是否是对称字符串

数组高级部分（理解）

排序

  • 冒泡排序

    相邻元素，两两比较，大的往后放。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

	public static void bubbleSort(int[] arr) {
		for(int x=0; x<arr.length-1; x++) {
			for(int y=0; y<arr.length-1-x; y++) {
				if(arr[y]>arr[y+1]) {
					int temp = arr[y];
					arr[y] = arr[y+1];
					arr[y+1] = temp;
				}
			}
		}
	}
  • 选择排序

    从 0 开始，依次和后面的比较，小的往前放。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

	public static void selectSort(int[] arr) {
		for(int x=0; x<arr.length-1; x++) {
			for(int y=x+1; y<arr.length; y++) {
				if(arr[y] < arr[x]) {
					int temp = arr[x];
					arr[x] = arr[y];
					arr[y] = temp;
				}
			}
		}
	}

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

public static void selectSort(int[] a)
{
    int min=0;
    int temp=0;
    if((a==null)||(a.length==0))
        return;
    for(int i=0;i<a.length-1;i++)
    {
        min=i;//无序区的最小数据数组下标
        for(int  j=i+1;j<a.length;j++)
        {
            //在无序区中找到最小数据并保存其数组下标
            if(a[j]<a[min])
            {
                min=j;
            }
        }
        //将最小元素放到本次循环的前端
        temp=a[i];
        a[i]=a[min];
        a[min]=temp;
    }
}

查找

  • 基本查找
    数组无序
  • 二分查找
    数组有序
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

public static int getIndex(int[] arr,int value) {
	int max = arr.length-1;
	int min = 0;
	int mid = (max+min)/2;

	while(arr[mid] != value) {
		if(arr[mid] > value) {
			max = mid - 1;
		}else if(arr[mid] < value) {
			min = mid + 1;
		}

		if(max < min) {
			return -1;
		}

		mid = (max+min)/2;
	}

	return mid;
}

Arrays 工具类（掌握）

Arrays 是针对数组进行操作的工具类，提供了排序和查找等功能

成员方法：（自己补齐方法和意思）

  • 把数组转成字符串 public static String toString(): 将任意类型数据转换成字符串
  • 排序 public static void sort()：
  • 二分查找 public static int binarySearch(int[] arr,int key)

案例：

把字符串中的字符进行排序

基本类型包装类（掌握）

为了让我们对基本类型进行更多的操作，java 针对每种基本类型提供了对应的包装类类型。

分别是哪些呢？

1
2
3
4
5
6
7
8
9

	byte		Byte
	short		Short
	int		Integer
	long		Long
	float		Float
	double		Double
	char		Character
	boolean		Boolean
特殊：  void		Void

Integer

  • 构造方法
    • Integer i = new Integer(100);
    • Integer i = new Integer(“100”);
  • 成员方法（自己补齐方法和意思）
    • 把字符串转成 int 类型
      String->int: Integer.parseInt()
      int->String: String.valueOf() 或 Integer.toString()
  • JDK5 的新特性
1
2
3
4
5
6
7
8
9

自动装箱：
	int --> Integer		//Integer.valueOf()
自动拆箱：
	Integer --> int		//Integer.intValue()

请解释：
	Integer i = 100;
	i+=200;
	System.out.println(i);
  • byte 缓存池面试题
    byte,short,char—>小于 127，否则报-6 的错误（查看 JDK)

Character

  • 构造方法
    Character ch = new Character(‘a’);
  • 成员方法（自己补齐方法和意思）
    • 判断字符是否是大写字母 public boolean isUpperCase(char ch)
    • 判断字符是否是小写字母 public boolean isLowerCase(Char ch)
    • 判断字符是否是数字字符 public boolean isDigit(Char ch)
    • 把字符转成大写 public Char toUpperCase(Char ch)
    • 把字符转成小写 public Char toLowerCase(Char ch)
]]>Java 父类子类的对象初始化过程https://lruihao.cn/posts/substatus/Thu, 21 Mar 2019 13:36:25 +0000Lruihaohttps://lruihao.cn/posts/substatus/

摘要：Java 基本的对象初始化过程，子类的初始化，以及涉及到父类和子类的转化时可能引起混乱的情况。

基本初始化过程

对于一个简单类的初始化过程是：
static 修饰的模块（static 变量和 static 块） => 按照代码顺序依次执行。
↓
实例变量 及非 static 模块 => 按照代码顺序依次执行。
↓
构造函数 => 执行对应的构造函数。

子类的初始化过程

父类 static 修饰的模块
↓
子类 static 修饰模块
↓
父类实例变量和非 static 块
↓
父类对应构造函数。当子类对应构造函数中没有显示调用时调用的是父类默认的构造函数。
↓
子类实例变量和非 static 块
↓
子类构造函数

 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

package code0507;

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

		Sub sub = new Sub();
		System.out.println(sub);

	}
}

class Super {
	int a = 6;

	public Super() {
		test();  //被子类同名函数覆盖，优先访问子类 test
	}
	int b=9;

	public void test() {
		System.out.println(a);
	}
}

class Sub extends Super {
	int a = 8;

	public Sub() {
		test();
	}

	public void test() {
		System.out.println(a);
	}
}

运行结果

1
2

0
8
]]>java 泛型 testhttps://lruihao.cn/posts/fanxing/Sat, 16 Mar 2019 13:56:01 +0000Lruihaohttps://lruihao.cn/posts/fanxing/
  • 泛型方法，它在修饰符后，返回值类型前增加了类型参数 (<>)
  • 类型通配符一般使用问号?代替具体的类型实参，注意不是类型形参。

代码

 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

package code0507;

public class WildCardTest {

	public static void main(String[] args) {
		Box<String>name=new Box<String>("hello");
		Box<Integer>age=new Box<Integer>(12);
		Box<Double>number=new Box<Double>(210.50);
		Box<Integer>point=new Box<Integer>();
		getData(name);
		getData(age);
		getData(number);
		point.printpoint(520, 1314);
		point.printpoint("me", "too");
	}

	public static void getData(Box<?>data){//类型通配符
		System.out.println("data:"+data.getData());
	}
}
class Box<T>{
	private T data;
	public Box() {}//构造方法重载
	public Box(T data) {
		setData(data);
	}
	public T getData() {
		return data;
	}
	public void setData(T data) {
		this.data = data;
	}
	//定义泛型方法
	public<T1,T2>void printpoint(T1 x,T2 y){
		T1 m=x;
		T2 n=y;
		System.out.println("This point is:"+m+","+n);
	}
}

运行结果

1
2
3
4
5

data:hello
data:12
data:210.5
This point is:520,1314
This point is:me,too
]]>eclipse 的基本使用https://lruihao.cn/posts/eclipseuse/Fri, 15 Mar 2019 23:47:24 +0000Lruihaohttps://lruihao.cn/posts/eclipseuse/基本使用 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

A: 选择一个工作空间
	D:\develop\eclipse-SDK-3.7.2-win64\workspace
B: 如何写一个 HelloWorld 案例（代码以项目为基本单位）
	a: 创建项目（工程）
		*File -- New -- Java Project
		*在左边空白处，直接右键 -- New -- Java Project

		键入项目名称后直接 Finish。
	b: 所有的 java 文件必须写到 src 下面才有效
	c: 创建一个包
		cn.lruihao
	d: 在包下创建一个类
		HelloWorld

		同时让它帮我们写好了 main 方法。
	e: 在 main 方法中写内容即可
	f: 编译程序
		自动编译，在保存的那一刻帮你做好了
	g: 运行程序
		选择要运行的文件或者在要运行的文件内容中
		右键 -- Run as - Java Application 即可
	h: 内容显示
		在 Console 控制台显示内容

Eclipse 的基本设置

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

A: 程序的编译和运行的环境配置（如果你的 Eclipse 启动没有问题，就不要配置了）
B: 去掉默认注释（可以不用改）
C: 行号的显示和隐藏
	显示：在代码区域的最左边的空白区域，右键 -- Show Line Numbers 即可。
	隐藏：把上面的动作再做一次。
D: 字体大小及颜色
	a:Java 代码区域的字体大小和颜色：
		window -- Preferences -- General -- Appearance -- Colors And Fonts -- Java 修改 -- Java Edit Text Font
	b: 控制台
		window -- Preferences -- General -- Appearance -- Colors And Fonts -- Debug -- Console font
	c: 其他文件
		window -- Preferences -- General -- Appearance -- Colors And Fonts -- Basic -- Text Font
E: 窗体给弄乱了，怎么办
	window -- Reset Perspective
F: 控制台找不到了
	Window--Show View—Console

快捷键的使用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

A: 内容辅助键
	Alt+/ 起提示作用
	main+alt+/,syso+alt+/, 给出其他提示
B: 快捷键
	格式化  ctrl+shift+f
	导入包  ctrl+shift+o
	注释	ctrl+/
		ctrl+shift+/,ctrl+shift+\
	代码上下移动 选中代码 alt+上/下箭头
	查看源码  选中类名 (F3 或者 Ctrl+鼠标点击）

Eclipse 中如何提高开发效率

1
2
3
4
5

A: 自动生成构造方法
	a: 无参构造方法 在代码区域右键--source--Generate Constructors from Superclass
	b: 带参构造方法 在代码区域右键--source--Generate Constructors using fields.. -- finish
B: 自动生成 get/set 方法
	在代码区域右键--source--Generate Getters and Setters...
]]>匿名类在可视化界面中的应用https://lruihao.cn/posts/qframe/Fri, 15 Mar 2019 22:31:28 +0000Lruihaohttps://lruihao.cn/posts/qframe/

java 中匿名类用的最多的地方就是可视化界面设计中，特别是将事件监听器注册到某个组件上的时候。

代码

 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

package cn.lruihao;

import java.awt.event.*;
import javax.swing.*;

public class QFrame extends JFrame {
	public QFrame() {
		JButton jbtnew=new JButton("New");//新建按钮
		JPanel panel=new JPanel();//面板容器
		panel.add(jbtnew);//添加组件
		add(panel);
		jbtnew.addActionListener(new ActionListener() {
			//新建一匿名类，并将该对应的事件监听器注册到“新建”按钮 就 jbtnew 上
			@Override
			public void actionPerformed(ActionEvent e) {
				JOptionPane.showMessageDialog(null, "单击了新建按钮");
				System.out.println("lruihao.cn");

			}
		});
	}

	public static void main(String[] args) {
		JFrame frame=new QFrame();
		frame.setTitle("QFrame");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setLocationRelativeTo(null);
		frame.pack();
		frame.setVisible(true);

	}

}

创建一个可视化界面，界面中有一个按钮，单击按钮显示“单击了新建按钮”。

结果

参考

]]>java 继承 testhttps://lruihao.cn/posts/jicheng/Thu, 24 Jan 2019 15:07:50 +0000Lruihaohttps://lruihao.cn/posts/jicheng/
引用

继承的好处：

  1. 提高了代码的复用性
  2. 提高了代码的维护性
  3. 让类与类之间产生了关系，是多态的前提

继承的弊端：类的耦合性很强

设计原则：低耦合，高内聚。

  • 耦合：类与类的关系。
  • 内聚：自己完成事情的能力。

java 中的继承特点

Java 只支持单继承，不支持多继承。Java 支持多层继承（继承体系）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

class A {
}

class B extends A {
}
/*
class C extends A,B {
}
*/

class C extends B {
}

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

	}
}

java 中的继承注意事项

  1. 子类只能继承父类所有非私有的成员（成员方法和成员变量）
  2. 子类不能继承父类的构造方法，但是可以通过 super 关键字去访问父类构造方法。
  3. 不要为了部分功能而去继承

那么，我们什么时候考虑使用继承呢？ 继承中类之间体现的是：”is a”的关系。
如果两个类满足这个关系：xxx is a yyy，那么他们就可以使用继承。

1
2
3

Student,Person  对
Dog,Animal  对
Dog,Pig  错

继承

继承间的构造方法关系：创建子类对象，会先去访问父类的构造方法。对父类的数据进行初始化。

 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

package jicheng;

class Fu{
	public int num = 10;
	public Fu(){
		System.out.println("父类");
	}
}
class Zi extends Fu{
	public int num = 20;
	public Zi(){
		System.out.println("子类");
	}
	public void show(){
		int num = 30;
		System.out.println(num);//30
		System.out.println(this.num);//20
		System.out.println(super.num);//10
	}
}

public class test {
	public static void main(String[] args) {
		Zi z = new Zi();
		z.show();
	}
}

程序运行结果

1
2
3
4
5

父类
子类
30
20
10

代码块

代码块的执行顺序： 静态代码块 –> 构造代码块 –> 构造方法
代码的执行特点：静态代码块只执行一次，构造代码块每次调用构造方法都执行。

 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

package jicheng;

class Fu {
	static {
		System.out.println("父类静态代码块");
	}

	{
		System.out.println("父类构造代码块");
	}

	public Fu() {
		System.out.println("父类构造方法");
	}
}

class Zi extends Fu {
	static {
		System.out.println("子类静态代码块");
	}

	{
		System.out.println("子类构造代码块");
	}

	public Zi() {
		System.out.println("子类构造方法");
	}
}

public class test {
	public static void main(String[] args) {
		Zi z = new Zi();
		Zi z2 = new Zi();
	}
}

程序运行结果：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

父类静态代码块
子类静态代码块
父类构造代码块
父类构造方法
子类构造代码块
子类构造方法
父类构造代码块
父类构造方法
子类构造代码块
子类构造方法

继承间的成员关系

  • 成员方法 不同名称： 非常简单，一看就知道调用谁
    相同名称： 先在子类找，再在父类找
    …
    找不到就报错。

  • 成员变量： 名字不同： 非常的简单，一看就知道使用的是谁。
    名字相同： 就近原则。

    使用变量的时候，会先找局部范围。
    如果想直接使用成员变量，加关键字：this 即可。
    如果想直接使用父类的成员变量，加关键字：super 即可。

注意事项

子类中所有的构造方法默认都会访问父类中空参数的构造方法。为什么呢？因为子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化。

]]>Arrays 类及基本使用https://lruihao.cn/posts/java-arrays/Fri, 18 Jan 2019 13:13:10 +0000Lruihaohttps://lruihao.cn/posts/java-arrays/主要方法
  • static type[] copyof(type[] original,int length)
  • static int binarysearch(type[] a,type key)
  • static boolean equals(type[] a,type[] b)
  • static void fill(type[] a,type val)
  • static void fill(type[] a,int fromindex,int toindex,type val)
  • static void sort(type[] a)

实例代码

 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
58

package Arrays;

import java.text.Collator;
import java.util.Arrays;
import java.util.Comparator;

public class ArraysDemo {
	public static void main(String agrs[]) {
		Integer arr[]=new Integer[9];
		for(int i=0;i<9;i++)
			arr[i]=(int)(Math.random()*100);
		//显示，排序数组
		System.out.print("原内容：");
		display(arr);
		Arrays.sort(arr);
		System.out.print("排序后：");
		display(arr);
		//将值-1 分配给数组 arr 中下标从 0 到 3-1 的位置
		Arrays.fill(arr, 0,3,-1);
		System.out.print("fill() 后：");
		display(arr);
		//搜索 23
		System.out.print("值 23 的位置：");
		int index =Arrays.binarySearch(arr, 23);//二分查找
		System.out.print(index);//如果查找不到，index 为负
		System.out.print("\n 插入 0 在 3 号位置：");
		Arrays.fill(arr,3,4,0);
		display(arr);
		System.out.print("值 0 的位置：");
		index =Arrays.binarySearch(arr, 0);
		System.out.print(index);
		Integer arr2[]=new Integer[8];
		arr2=Arrays.copyOf(arr, arr2.length);
		//复制 8 个
		System.out.print("\n 复制后的数组：");
		display(arr2);
		if(Arrays.equals(arr, arr2))
			System.out.println("两数组相同！");
		else System.out.println("两数组不相同！");
		System.out.println("----------------------------------------");
		String[] str = {"计算机","黄桑","通信","李瑞豪"};
		Arrays.sort(str);
		for(int i=0;i<str.length;i++)
			System.out.print(str[i]+" ");
		System.out.println("");
		//Collator 类是用来执行分语言环境的字符串比较，这里用的 CHINA
		Comparator com=Collator.getInstance(java.util.Locale.CHINA);//获取 Comparator 对象，参数表示按中文排序
		//根据指定的 "比较器" 产生的顺序对 "指定对象数组" 进行排序
		Arrays.sort(str,com);//sort(T[] a,Comparator<?super T>c)
		for(int i=0;i<str.length;i++)
			System.out.print(str[i]+" ");
	}
	static void display(Integer arr[]) {
		for(int i=0;i<arr.length;i++)
			System.out.print(arr[i]+" ");
		System.out.println("");
	}
}

程序运行结果

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

原内容：41 0 44 96 49 96 30 6 87
排序后：0 6 30 41 44 49 87 96 96
fill() 后：-1 -1 -1 41 44 49 87 96 96
值 23 的位置：-4
插入 0 在 3 号位置：-1 -1 -1 0 44 49 87 96 96
值 0 的位置：3
复制后的数组：-1 -1 -1 0 44 49 87 96
两数组不相同！
----------------------------------------
李瑞豪 计算机 通信 黄桑
黄桑 计算机 李瑞豪 通信
]]>java 猜数字小游戏（Math 类）https://lruihao.cn/posts/mathclass/Tue, 15 Jan 2019 17:33:28 +0000Lruihaohttps://lruihao.cn/posts/mathclass/

大一刚学 c 的时候以前写过 c 语言版 的。

  1. Math: 针对数学进行运算的类
  2. 特点：没有构造方法，因为它的成员都是静态的
  3. 产生随机数： public static double random(): 产生随机数，范围 [0.0,1.0)
  4. 产生 1-100 之间的随机数 int number = (int)(Math.random()*100)+1;
  5. 猜数字小游戏案例
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

class MathDemo {
	public static void main(String[] args) {
		//获取随机数
		//double d = Math.random();
		//System.out.println(d);

		/*
		for(int x=0; x<10; x++) {
			//System.out.println(Math.random());
			System.out.println(Math.random()*100);
		}
		*/

		//我们如何获取 1-100 之间的随机数呢？
		for(int x=0; x<100; x++) {
			int number = (int)(Math.random()*100)+1;
			System.out.println(number);
		}
	}
}

小游戏

该游戏可以由程序随机产生或由用户输入四个 0 到 9 之间的数字，且不重复。玩游戏者通过游戏提示输入八次来匹配上面所输入的数字。A 表示位置正确且数字正确，B 表示数字正确而位置不正确。
算法： 可以直接算出 A 类的数目，但是 B 类的数目直接算出或许会很麻烦，正好我们可以先算出 C 类数目恰好减去 A 类就是 B 类了。

 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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

package caishuzi;

import java.util.Scanner;

class Num {
	private int[] a= {0,0,0,0};

	public Num() {}

	public void setx() {
		/*for(int i=0;i<4;i++) {
			a[i]=(int)(Math.random()*10);
		}*/
		//为了四个互不相同的随机数
		a[0]=(int)Math.random()*10+1;
		for(int i=1;i<4;i++) {
			int t=(int)(Math.random()*10);
			for(int j=0;j<i;j++) {
				if(t==a[j]) {
					t=(int)(Math.random()*10);
					j=0;
				}
			}
			a[i]=t;
		}
	}
	public int[] getx() {
		return a;
	}
	public void show() {
		System.out.println();
		for(int i=0;i<4;i++)
			System.out.print(a[i]+" ");
		System.out.println();
	}

}

public class caishuzi {

	public static void main(String agrs[]) {
		int a[] = {0,0,0,0},b[] = {0,0,0,0};
		System.out.println("* * * *\n 请输入 4 个数字！A 表示位置数字都正确，B 表示数字正确位置错误。");
		Scanner sc=new Scanner(System.in);
		Num n=new Num();
		n.setx();
		a=n.getx();
		/*for(int i=0;i<4;i++)
			System.out.print(a[i]+" ");
		n.show();*/
		for(int k=0;k<10;k++) {//猜测次数
			int A=0,B=0,C=0;
			for(int i=0;i<4;i++) {
				b[i]=sc.nextInt();
			}
			sc.close();
			for(int i=0;i<4;i++){
				if (b[i]==a[i])A++;
				for(int j=0;j<4;j++){
					C=b[i]==a[j]?++C:C;//C 表示猜测数内和随机数中 A 类和 B 类数的数目
					if (b[i]==a[j])break;
				}
			}
			B=C-A;// 关键算法（感叹数学魅力）
			if(A==4) {
				System.out.println("恭喜猜对啦！");
			}else {
				System.out.println(A+"A"+B+"B");
			}
		}

	}

}

一次游戏过程

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

* * * *
请输入 4 个数字！A 表示位置数字都正确，B 表示数字正确位置错误。
0 1 2 3
0A1B
0 1 2 4
0A1B
0 1 2 5
1A1B
6 1 2 5
1A2B
1 6 2 5
3A0B
1 6 7 5
恭喜猜对啦！
]]>面向对象基础知识总结https://lruihao.cn/posts/duixiang/Tue, 15 Jan 2019 16:07:31 +0000Lruihaohttps://lruihao.cn/posts/duixiang/面向对象思想（理解）
  1. 面向对象是基于面向过程的一种编程思想
  2. 思想特点：
    A: 是一种更符合我们思考习惯的思想
    B: 把复杂的问题简单化
    C: 让我们从执行者变成了指挥者
  3. 举例：
    A: 洗衣服
    B: 吃饭
    C: 买电脑
  4. 举例并代码体现 把大象装进冰箱

类与对象（掌握）

  1. 我们学习编程是为了把现实世界的事物用编程语言描述来实现信息化。
  2. 现实世界事物是如何表达的呢？ 属性：外在特征
    行为：内在行为
  3. 我们学习的是 java 语言，它最基本的单位是类。
    所以我们要学会用类来体现一个事物。
  4. 类：是一组相关的属性和行为的集合
  5. 对象：是该类事物的具体个体。
  6. 举例：
    学生 类
    张三 对象

类的组成（掌握）

  1. 成员变量
    其实就是变量，只不过定义在类中，方法外，并且可以不用初始化。
  2. 成员方法
    其实就是方法，只不过不需要 static 了
  3. 案例：
    学生类
1
2
3
4
5
6

	class Student {
		String name;
		int age;

		public void study() {}
	}

类的使用（掌握）

  1. 创建对象
    格式：类名 对象名 = new 类名 ();
  2. 使用成员
    成员变量：对象名。变量名； 成员方法：对象名。方法名 (…);

成员变量和局部变量的区别（理解）

  1. 在类中的位置不同
    A: 成员变量 类中，方法外
    B: 局部变量 方法的形式参数，或者方法体中
  2. 在内存中的位置不同
    A: 成员变量 在堆中
    B: 局部变量 在栈中
  3. 生命周期不同
    A: 成员变量 随着对象的存在而存在，随着对象的消失而消失
    B: 局部变量 随着方法的调用而存在，随着方法的调用完毕而消失
  4. 初始化值不同
    A: 成员变量 有默认初始化值
    B: 局部变量 没有默认值，必须先声明，赋值，最后才能使用

形式参数问题（理解）

  1. 基本类型
    基本类型作为形式参数，需要的是该基本类型的值。
  2. 引用类型
    引用类型作为形式参数，需要的是该引用类型的地址值。（对象）

匿名对象（理解）

  1. 匿名对象：没有名字的对象。是对象的简化书写方式。
  2. 使用场景
    A: 调用方法，仅仅只调用一次
    B: 作为实际参数传递

封装（掌握）

  1. 隐藏实现细节，提供公共的访问方式
  2. 好处：
    A: 隐藏实现细节，提供公共的访问方式
    B: 提高了代码的复用性
    C: 提高了代码的安全性
  3. 使用原则
    A: 把成员变量隐藏
    B: 给出该成员变量对应的公共访问方式

private 关键字（掌握）

  1. 是一个权限修饰符
  2. 可以修饰类的成员（成员变量和成员方法）
  3. 仅仅在本类中可以访问，对外提供对应的 GetXXX()，SetXXX() 等方法
  4. 标准代码：
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

	class Student {
		private String name;
		private int age;

		public void setName(String n) {
			name = n;
		}

		public String getName() {
			return name;
		}

		public void setAge(int a) {
			age = a;
		}

		public int getAge() {
			return age;
		}

		public void study() {}
	}

this 关键字（掌握）

  1. this：代表本类的对象
  2. 应用场景：
    解决了局部变量隐藏成员变量的问题。
    其他用法和 super 一起讲。
  3. 标准代码：
 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

	class Student {
		private String name;
		private int age;

		public void setName(String name) {//局部变量
			this.name = name;
		}

		public String getName() {
			return name;
		}

		public void setAge(int age) {
			this.age = age;
		}

		public int getAge() {
			return age;
		}

		public void show() {
			System.out.println("姓名是："+name+", 年龄是："+age);
		}

		public void study() {
			System.out.println("学生爱学习");
		}

		public void eat() {
			System.out.println("学生要吃饭");
		}

		public void sleep() {
			System.out.println("学生想睡觉");
		}
	}

	class StudentTest {
		public static void main(String[] args) {
			Student s = new Student();

			s.setName("林青霞");
			s.setAge(28);

			s.show();
			s.study();
			s.eat();
			s.sleep();

			System.out.println("姓名是："+s.getName());
			System.out.println("年龄是："+s.getAge());
		}
	}

构造方法（掌握）

  1. 作用：对对象的数据进行初始化。
  2. 特点：
    A: 方法名和类名相同
    B: 没有返回值类型
    C: 没有返回值
  3. 注意事项
    A: 如果我们没写构造方法，系统将默认给出无参构造方法
    B: 如果我们写了构造方法，系统将不再给出默认无参构造方法
    建议：我们自己手动给出无参构造方法
  4. 给成员变量赋值：
    A: 无参+setXxx()
    B: 带参
  5. 一个标准的代码：
 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

	class Student {
		private String name;
		private int age;

		public Student() {}

		public Student(String name,int age) {//构造方法
			this.name = name;
			this.age = age;
		}

		public void setName(String name) {
			this.name = name;
		}

		public String getName() {
			return name;
		}

		public void setAge(int age) {
			this.age = age;
		}

		public int getAge() {
			return age;
		}

		public void show() {
			System.out.println("姓名是："+name+", 年龄是："+age);
		}
	}

	class StudentTest {
		public static void main(String[] args) {
			//无参+setXxx()
			Student s = new Student();
			s.setName("林青霞");
			s.setAge(28);
			s.show();

			//带参
			Student ss = new Student("张曼玉",20);
			ss.show();
		}
	}

对象的初始化过程（理解）

  • Student s = new Student(); 做了哪些事情
    A: 加载 Student.class 文件进内存
    B: 在栈中为 s 开辟空间
    C: 在堆中为学生对象开辟空间
    D: 为学生对象的成员变量赋默认值
    E: 为学生对象的成员变量赋显示值
    F: 通过构造方法给成员变量赋值
    G: 对象构造完毕，把地址赋值给 s 变量

static 关键字（掌握）

  1. 是一个状态修饰符。静态的意思
  2. 它可以修饰成员变量和成员方法
  3. 特点：
    A: 随着类的加载而加载
    B: 优先于对象存在
    C: 被所有对象共享
    这也是判断我们是不是该使用静态的条件
    举例：饮水机（可共享 static) 和水杯例子。
    D: 可以通过类名调用
    静态修饰的内容，可以通过类名调用，也可以通过对象名调用
  4. 方法访问特点
    A: 普通成员方法
    可以访问静态成员变量，非静态成员变量，静态成员方法，非静态成员方法
    B: 静态成员方法
    只能访问静态成员变量，静态成员方法
    简记：静态只能访问静态
    注意：
    静态中是不能有 this 的。
    先进内存的不能访问后进内存的。反之可以。
 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

/*
	班级编号应该是被班级每个人都共享的，所以定义一个就应该可以了。
	而姓名和年龄，每个人应该是不一样的，所以，每个对象，都应该定义自己的。

	在 java 中，用什么来表示成员变量是被共享的呢？static
*/
class Student {
	//姓名
	String name;
	//年龄
	int age;
	//班级编号
	//String classNumber;
	static String classNumber;

	public Student(String name,int age) {
		this.name = name;
		this.age = age;
	}

	public Student(String name,int age,String classNumber) {
		this.name = name;
		this.age = age;
		this.classNumber = classNumber;
	}

	public void show() {
		System.out.println(name+"---"+age+"---"+classNumber);
	}
}

class StudentDemo {
	public static void main(String[] args) {
		//创建学生对象
		Student s1 = new Student("林青霞",28,"20150306");
		s1.show();

		/*
		Student s2 = new Student("马云",35,"20150306");
		s2.show();

		Student s3 = new Student("马化腾",33,"20150306");
		s3.show();
		*/
		Student s2 = new Student("马云",35);
		s2.show();

		Student s3 = new Student("马化腾",33);
		s3.show();
	}
}
 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

/*
	static: 静态关键字。

	作用：
		可以修饰成员变量和成员方法

	特点：
		A: 随着类的加载而加载
		B: 优先于对象存在
		C: 被类的所有对象共享
			这也是我们判断是否使用静态关键字的条件

			饮水机：可以被静态修饰
			水杯：不可以被静态修饰
		D: 可以通过类名调用
			我们的调用既可以是对象，还可以是类名
*/
class Student {
	public void show() {
		System.out.println("show");
	}

	public static void show2() {
		System.out.println("show2");
	}
}

class StudentDemo2 {
	public static void main(String[] args) {
		Student s = new Student();
		s.show();
		s.show2();

		Student.show2();
		//Student.show();&ensp;
	}
}
 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

/*
	static 的注意事项：
		A: 在静态方法中是没有 this 关键字的
			因为静态是随着类的加载而加载，优先于对象而存在。而 this 是随着对象的创建而存在。
			先进内存的， 不能访问后进内存的；而后进内存的，可以访问先进内存的。
		B: 静态只能访问静态。
			非静态的成员方法：
				可以访问静态成员变量，非静态成员变量，静态成员方法，非静态成员方法
			静态的成员方法：
				只能访问静态的成员变量，静态的成员方法
*/
/*
class Student {
	private String name;

	public static void setName(String name) {//&ensp; 静态方法不能用 this
		this.name = name;
	}

	public void show() {
		System.out.println(name);
	}
}*/

class Demo {
	int x = 10;
	static int y = 20;

	public void show() {
		System.out.println(x);
		System.out.println(y);
	}

	public static void show2() {
		//System.out.println(x);&ensp;
		System.out.println(y);//√
	}

	public void show3() {
		show();
		show2();
	}

	public static void show4() {
		//show(); 只能访问静态的成员方法
		show2();
	}
}

class StudentDemo3 {
	public static void main(String[] args) {
		//Student.setName("林青霞");
	}
}

静态成员变量和普通成员变量的区别（理解）

  1. 所属不同
    静态属于类的，称为类变量
    非静态属于对象的，称为对象变量，实例变量
  2. 内存空间不同
    静态在方法区的静态区
    非静态在堆内存
  3. 生命周期不同
    静态随着类的加载而加载，随着类的消失而消失
    非静态随着对象的创建而存在，随着对象的消失而消失
  4. 调用不同
    静态可以通过类名调用，也可以通过对象名调用。建议通过类名调用
    非静态只能通过对象名调用

main 方法是静态的（理解）

1

public static void main(String[] args)

public: 访问权限修饰符，表示最大的访问权限，被 jvm 调用，所有权限要够大。
static: 被 jvm 调用，不用创建对象，直接类名访问
void: 被 jvm 调用，不需要给 jvm 返回值
main: 一个通用的名称，虽然不是关键字，但是被 jvm 识别
String[] args:
早期出现是为了接收键盘录入数据的。

实例

 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

/*求和*/
class Demo {
	private int x;
	private int y;

	public Demo() {}

	public Demo(int x,int y) {
		this.x = x;
		this.y = y;
	}

	public void setX(int x) {
		this.x = x;
	}

	public int getX() {
		return x;
	}

	public void setY(int y) {
		this.y = y;
	}

	public int getY() {
		return y;
	}

	//成员变量已经有 x,y 了。这里就没有必要在定义了
	/*
	public int sum(int x,int y) {
		return x + y;
	}
	*/

	public int sum() {
		return x + y;
	}
}

class Test {
	public static void main(String[] args) {
		Demo d = new Demo();
		d.setX(10);
		d.setY(20);
		int result = d.sum();
		System.out.println(result);
	}
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

/*求和*/
class Demo {
	public int sum(int x,int y) {
		return x + y;
	}
}

class Test2 {
	public static void main(String[] args) {
		Demo d = new Demo();
		int result = d.sum(10,20);
		System.out.println(result);
	}
}
 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
58
59
60
61
62
63
64
65
66

/*
	定义一个员工类，自己分析出几个成员，
	然后给出成员变量，构造方法，getXxx()/setXxx() 方法，
	以及一个显示所有成员信息的方法。并测试。

	Employee：
		成员变量：员工编号，姓名，职位
		构造方法：无参，带参
		成员方法：getXxx()/setXxx() 方法，show()
*/
class Employee {
	private String eid;
	private String name;
	private String job;

	public Employee() {}

	public Employee(String eid,String name,String job) {
		this.eid = eid;
		this.name = name;
		this.job = job;
	}

	public void setEid(String eid) {
		this.eid = eid;
	}

	public String getEid() {
		return eid;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public void setJob(String job) {
		this.job = job;
	}

	public String getJob() {
		return job;
	}

	public void show() {
		System.out.println("员工编号是："+eid+", 姓名是："+name+", 职位是："+job);
	}
}

class EmployeeDemo {
	public static void main(String[] args) {
		//无参
		Employee e = new Employee();
		e.setEid("itcast007");
		e.setName("周星驰");
		e.setJob("高级工程师");
		e.show();

		//带参
		Employee e2 = new Employee("itcast003","刘德华","挖掘机工程师");
		e2.show();
	}
}

java 类中的成员变量和方法访问权限

关键词 同一个类 同一个包 不同包中的子类 不同包中的非子类
private √      
default √ √    
protected √ √ √  
public √ √ √ √
]]>java 水仙花数（循环）https://lruihao.cn/posts/java-range/Mon, 14 Jan 2019 17:30:24 +0000Lruihaohttps://lruihao.cn/posts/java-range/

水仙花数（Narcissistic number）也被称为超完全数字不变数（pluperfect digital invariant, PPDI）、自恋数、自幂数、阿姆斯壮数或阿姆斯特朗数（Armstrong number），水仙花数是指一个 3 位数，它的每个位上的数字的 3 次幂之和等于它本身（例如：1^3 + 5^3+ 3^3 = 153）。

定义

水仙花数只是自幂数的一种，严格来说 3 位数的 3 次幂数才称为水仙花数。
附：其他位数的自幂数名字
一位自幂数：独身数
两位自幂数：没有
三位自幂数：水仙花数
四位自幂数：四叶玫瑰数
五位自幂数：五角星数
六位自幂数：六合数
七位自幂数：北斗七星数
八位自幂数：八仙数
九位自幂数：九九重阳数
十位自幂数：十全十美数

 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

package xunhuan;

import java.util.Scanner;

public class shuixianhua {

	public static void main(String[] agrs) {
        System.out.print("指定最大位数 N:");
        Scanner input = new Scanner(System.in);
        int N = input.nextInt();
        input.close();
        for (int i = 3; i <= N; i++) {
            int a[] = new int[i];
            int num = (int) Math.pow(10, i - 1) + 1;
            System.out.print(i + "位的水仙花数有：\t");
            while (num <= Math.pow(10, i)) {
                int sum = 0;
                for (int j = 0; j < i; j++)
                    a[j] = (int) (num / Math.pow(10, j) % 10);//取各个位的数
                for (int j = 0; j < i; j++)
                    sum = sum + (int) Math.pow(a[j], i);
                if (num == sum)
                    System.out.print(num + "\t");
                num++;
            }
            System.out.print("\n");
        }
    }

}

由于 int 精度限制，最多算到 9 位，而且使用常规算法，算到 8，9 位的时候就特别慢了。

1
2
3
4
5
6
7
8

指定最大位数 N:10
3 位的水仙花数有：	153	370	371	407
4 位的水仙花数有：	1634	8208	9474
5 位的水仙花数有：	54748	92727	93084
6 位的水仙花数有：	548834
7 位的水仙花数有：	1741725	4210818	9800817	9926315
8 位的水仙花数有：	24678050	24678051	88593477
9 位的水仙花数有：	146511208
]]>java 录入数据https://lruihao.cn/posts/java-input/Mon, 14 Jan 2019 15:33:46 +0000Lruihaohttps://lruihao.cn/posts/java-input/记忆格式：

(1) 导包：
import java.util.Scanner;
注意：位置在 class 的上面。
(2) 创建键盘录入对象：
Scanner sc = new Scanner(System.in);
(3) 获取数据
int i = sc.nextInt();
(4) 练习：
A: 求两个数据的和
B: 获取两个数据中较大的值
C: 获取三个数据中较大的值
D: 比较两个数是否相等

实例

 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

package helloworld;

import java.util.Scanner;

public class helloworld {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int i=sc.nextInt(),j=sc.nextInt(),k=sc.nextInt();
		sc.close();
		System.out.println(i+"+"+j+"="+(i+j));
		System.out.println("MAXij="+Max(i,j));
		System.out.println("MAXijk="+Max(i,j,k));

	}
	//Max() 方法重载
	static int Max(int i,int j) {
		return i>j?i:j;
	}
	static int Max(int i,int j,int k) {
		if(i==j)
			System.out.println("i 和 j 相等");
		else if(i==k)
			System.out.println("i 和 k 相等");
		else if(j==k)
			System.out.println("j 和 k 相等");
		return  (i=i>j?i:j)>k?i:k;
	}

}

结果

1
2
3
4
5

5 5 6
5+5=10
MAXij=5
i 和 j 相等
MAXijk=6
]]>java 标识符https://lruihao.cn/posts/biaoshi/Mon, 14 Jan 2019 15:07:57 +0000Lruihaohttps://lruihao.cn/posts/biaoshi/标识符：

给类，接口，方法或者变量起名字的符号

组成规则：

A: 英文字母大小写
B: 数字
C:_和$

注意事项：

A: 不能以数字开头
B: 不能是 Java 中的关键字
C: 区分大小写
Student,student 这是两个名称

常见命名方式：

A: 包 其实就是文件夹，用于解决相同类名问题
全部小写
单级：com
多级：cn.itcast
B: 类或者接口
一个单词：首字母大写
Student,Person,Teacher
多个单词：每个单词的首字母大写
HelloWorld,MyName,NameDemo
C: 方法或者变量
一个单词：全部小写
name,age,show()
多个单词：从第二个单词开始，每个单词首字母大写
myName,showAllStudentNames()
D: 常量
一个单词：全部大写
AGE
多个单词：每个单词都大写，用_连接
STUDENT_MAX_AGE

]]>