Java知识点笔记（一）：how2j.cn的学习（一）

本文内容的学习网站：http://how2j.cn/

1、创建 Java 项目

File -> New -> Other -> Java -> Java Project

2、常用快捷键

主方法：main + alt + / 输出：syso + alt + / for语句：for + alt + / try语句：try + alt + / 格式化：ctrl + shift + f

注释：ctrl + shift + c 引包去包：ctrl + shift + o

3、八种基本数据类型

整型（4种）：byte，short，int，long 浮点型（2种）：float，double 字符型（1种）：char 布尔型（1种）：boolean

4、操作符

byte a = 1; byte b = 1; a + b -> int类型

& 和 | 两边的表达式都会执行，&& 和 || 如果左边表达式的结果可以确定总结果，右边的表达式不会执行

>>>无符号右移，负数会变成正数

控制台输入：Scanner s = new Scanner(System.in);

Math.random() 会得到一个0-1之间的随机浮点数

5、数组

package com.aroma.review;import java.util.Arrays;public class TestArray {public static void main(String[] args) {int[] a = new int[3]; //创建数组int[] b = {1,2,3}; //创建并初始化//增强型for循环只取值，不能改值for(int i : b) {System.out.println(i);}//数组的工具类Arrays//复制数组int[] b2 = Arrays.copyOfRange(b, 0, 3); //转为字符串System.out.println(Arrays.toString(b2));//排序a[0] = 2;  a[1] = 1;  a[2] = 3;Arrays.sort(a);System.out.println(Arrays.toString(a));//搜索,使用binarySearch必须先使用sort排序System.out.println(Arrays.binarySearch(a, 2));//比较System.out.println(Arrays.equals(a, b));}
}

运行结果：

1
2
3
[1, 2, 3]
[1, 2, 3]
1
true

6、类，对象和属性

实例化一个对象的时候，必然调用构造方法

Hero h = new Hero();的意思为：引用 h 指向一个 Hero 对象（=表示指向，不是赋值）

static 修饰的方法叫做类方法或静态方法，可以直接访问，不需要建立对象

static 修饰的属性叫做类属性或静态属性，所有的对象共享一个值

单例模式

package com.aroma.review;public class Singleton {// 类属性，用于指向一个实例化对象private static final Singleton singleton = new Singleton();// 私有化构造方法,外部无法进行实例化private Singleton() {}// get方法返回静态属性private static Singleton getSingleton() {return singleton;}}

7、四种访问修饰符

private：私有的，子类不能继承，其它类也不能访问

package/friendly/default：默认的，同包子类能继承，同包非子类能访问，异包子类不能继承，异包非子类不能访问

protected：受保护的，同包子类能继承，同包非子类能访问，异包子类能继承，异包非子类不能访问

public：公开的，所有类都能访问

8、接口和继承

Java 不允许多继承，但可以实现多个接口，实现某个接口，就必须重写该接口中的方法，接口可以提供默认方法

多态: 同个类型，同个方法，呈现出不同的状态

this 代表当前对象，super 可以调用父类的方法和属性

Object 类是所有类的父类，声明一个类时，默认继承了 Object 类

final 修饰的类不能被继承，final 修饰的方法不能被重写，final 修饰的基本类型变量只有一次赋值的机会

final 修饰的引用只有一次指向对象的机会

抽象类不能够直接实例化，抽象方法没有实现体，抽象类可以没有抽象方法

接口中声明的属性只能是 public final static 的

非静态内部类的实例化必须存在一个外部类对象，匿名类是在声明一个类的同时实例化，本地类可以理解为有名字的匿名类

package com.aroma.review;public class Hero extends Object {public String name;public void attack() {}// 构造方法public Hero() {}public Hero(String name) {this.name = name;}// 非静态内部类class Score {int kill;public void legendary() {if (kill >= 8)System.out.println(name + " is legendary!");}}// 类方法public static void victory() {System.out.println("Victory!");}// 静态内部类static class Crystal {int hp;public void win() {if (hp == 0)Hero.victory();}}// 主函数public static void main(String[] args) {Hero garen = new Hero("Garen");Score score = garen.new Score();score.kill = 9;score.legendary();Hero.Crystal crystal = new Hero.Crystal();crystal.hp = 0;crystal.win();// 匿名类Hero h = new Hero() {public void attack() {System.out.println("Attack!");}};h.attack();// 本地类class newHero extends Hero {public void attack() {System.out.println(name + " attack!");}}newHero ahri = new newHero();ahri.name = "Ahri";ahri.attack();}}

运行结果：

Garen is legendary!
Victory!
Attack!
Ahri attack!

9、数字与字符串

不调用构造方法，通过 = 自动把基本类型转换为类类型叫做装箱

不调用 Integer 的 intValue 方法，通过 = 自动转换成 int 类型叫做拆箱

StringBuffer 是可变长的字符串

package com.aroma.review;public class Test {public static void main(String[] args) {// 数字转字符串int i = 1;String s = String.valueOf(i);// 字符串转数字String s2 = "2";int i2 = Integer.parseInt(s2);// 四舍五入float f = 1.5f;System.out.println(Math.round(f));// 格式化输出String str = "%s + %d %n";System.out.printf(str, s, i2);//获取字符System.out.println(str.charAt(3));//获取字符数组System.out.println(str.toCharArray());//截取字符串System.out.println(str.substring(3, 6));//根据str创建一个StringBuffer对象StringBuffer str2 = new StringBuffer(str);//尾部添加str2.append(" 123");System.out.println(str2);//删除str2.delete(10, 14);System.out.println(str2);//插入str2.insert(3, "123 ");System.out.println(str2);}
}

运行结果：

2
1 + 2
+
%s + %d %n
+ %
%s + %d %n 123
%s + %d %n
%s 123 + %d %n

10、日期

日期格式化类 SimpleDateFormat

package com.aroma.review;import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;public class TestDate {public static void main(String[] args) {//日期转字符串SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");String str = sdf.format(new Date());System.out.println(str);//字符串转日期SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");String str2 = "2019-10-10 11:30:59";      try {System.out.println(sdf2.parse(str2).toString());} catch (ParseException e) {// TODO: handle exceptione.printStackTrace();}}
}

运行结果：

2019-10-10 11:31:00
Thu Oct 10 11:30:59 CST 2019

11、异常处理

异常分为三种：可查异常，运行时异常和错误，后两者统称非可查异常

可查异常是必须处理的异常，否则编译器不通过，其它两种异常不要求强制捕获

throw 通常在方法体内，执行 throw 一定是抛出了某个异常

throws 在方法声明上，表示可能出现异常，不一定会发生异常

package com.aroma.review;public class Hero {public String name;protected int hp;// 构造方法public Hero() {}public Hero(String name, int hp) {this.name = name;this.hp = hp;}// 自定义异常@SuppressWarnings("serial")class IsDeadException extends Exception {public IsDeadException(String name) {super(name);}}// 抛出异常public void attack(Hero h) throws IsDeadException {if (h.hp == 0)throw new IsDeadException(h.name + " is dead.");}// 主函数public static void main(String[] args) {Hero garen = new Hero("Garen", 100);Hero ahri = new Hero("Ahri", 0);try {garen.attack(ahri);} catch (IsDeadException e) {// TODO: handle exceptionSystem.out.println(e.getMessage());e.printStackTrace();}}
}

运行结果：

Ahri is dead.
com.aroma.review.Hero$IsDeadException: Ahri is dead.at com.aroma.review.Hero.attack(Hero.java:29)at com.aroma.review.Hero.main(Hero.java:39)

12、I/O流

ASCII 码及对应十六进制数：0-9 对应 30-39，A-Z 对应 41-5A，a-z 对应 61-7A

InputStream 字节输入流，OutputStream 字节输出流，Reader 字符输入流，Writer 字符输出流

BufferedReader 缓存字符输入流，可以一次读取一行数据，缓存字符输出流 PrintWriter，可以一次写出一行数据

数据输入流 DataInputStream，数据输出流 DataOutputStream

把流定义在 try() 里，try catch 或者 finally 结束时会自动关闭

一个对象以流的形式进行传输，叫做序列化，该对象所对应的类，必须是实现 Serializable 接口

package com.aroma.review;import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.PrintWriter;public class TestStream {public static void main(String[] args) {//需要先在D盘创建test.txt,内容为ABCFile f = new File("d:/test.txt");       try(FileInputStream fis = new FileInputStream(f)) {//字节数组byte[] content = new byte[(int) f.length()];//字节流读取文件内容fis.read(content);//循环输出for(byte b : content) {System.out.println(b);}                    } catch (IOException e) {// TODO: handle exceptione.printStackTrace();}try(FileReader fr = new FileReader(f)) {//字符数组char[] content = new char[(int)f.length()];//字符流读取文件内容fr.read(content);//循环输出for(char c : content)System.out.println(c);} catch (IOException e) {// TODO: handle exceptione.printStackTrace();}//不需要先在D盘创建test2.txt，会自动创建File f2 = new File("d:/test2.txt");       try(FileOutputStream fos = new FileOutputStream(f2)) {//要写入文件的内容byte[] data = {68, 69};//写入fos.write(data);       } catch (IOException e) {// TODO: handle exceptione.printStackTrace();}//不需要先在D盘创建test3.txt，会自动创建File f3 = new File("d:/test3.txt");      try(FileWriter fw = new FileWriter(f3)) {//要写入的内容String data = "DE";//写入fw.write(data.toCharArray());} catch (IOException e) {// TODO: handle exceptione.printStackTrace();}/*需要先在D盘创建test4.txt,内容为*Life is dear*Love is dearer*Both can be given up for freedom*/File f4 = new File("d:/test4.txt");try(    //缓存流必须建立在一个存在的流的基础上FileReader fr = new FileReader(f4);BufferedReader br = new BufferedReader(fr);  ) {while(true) {String line = br.readLine();if(line == null)break;System.out.println(line);}           } catch (IOException e) {// TODO: handle exceptione.printStackTrace();}//不需要先在D盘创建test5.txt，会自动创建File f5 = new File("d:/test5.txt");try(    //缓存流必须建立在一个存在的流的基础上FileWriter fw = new FileWriter(f5);PrintWriter pw = new PrintWriter(fw);) {pw.println("Life is dear");pw.println("Love is dearer");pw.println("Both can be given up for freedom");} catch (IOException e) {// TODO: handle exceptione.printStackTrace();}Hero h = new Hero("Garen", 100);//需要先在D盘创建test6.txt用于保存该对象File f6 = new File("d:/test6.txt");try(//创建对象输出流FileOutputStream fos = new FileOutputStream(f6);ObjectOutputStream oos =new ObjectOutputStream(fos);//创建对象输入流              FileInputStream fis = new FileInputStream(f6);ObjectInputStream ois =new ObjectInputStream(fis);) {oos.writeObject(h);Hero h2 = (Hero) ois.readObject();System.out.println(h2);         } catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();} catch (ClassNotFoundException e) {// TODO Auto-generated catch blocke.printStackTrace();}}
}

package com.aroma.review;import java.io.Serializable;public class Hero implements Serializable {//类当前版本private static final long serialVersionUID = 1L;public String name;public int hp;//构造方法public Hero(String name, int hp) {this.name = name;this.hp = hp;}//重写toString方法@Overridepublic String toString() {return "[name=" + name + ", hp=" + hp + "]";}
}

运行结果：

65
66
67
A
B
C
Life is dear
Love is dearer
Both can be given up for freedom
[name=Garen, hp=100]

13、集合框架

容器类 ArrayList 实现了List接口，容量会自动增长

指定了泛型的容器，只能存放指定类型的元素以及其子类

LinkedList 实现了 List 接口，Queue 接口和双向链表结构 Deque

ArrayList 是顺序结构，增删慢定位快，LinkedList 是链表结构，增删快定位慢

HashMap 储存数据的方式是键值对，对于 HashMap，key 是唯一的

HashMap 可以存放 null，线程不安全，Hashtable 不能存放 null，线程安全

package com.aroma.review;import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;public class TestList {public static void main(String[] args) {List<Hero> list = new ArrayList<Hero>();//增加for (int i = 0; i < 5; i++) {list.add(new Hero("Hero " + i));}list.add(3, new Hero("newHero"));System.out.println(list);//删除list.remove(3);//遍历for (int i = 0; i < list.size(); i++) {System.out.println(list.get(i));}Queue<Hero> queue = new LinkedList<Hero>();//队列，先进先出for (int i = 0; i < 5; i++) {queue.offer(new Hero("Hero " + i));}System.out.println(queue); //栈，后进先出class MyStack<T> {//方便在头尾插入删除数据LinkedList<T> list = new LinkedList<T>();//进栈public void push(T t) {list.addLast(t);}//出栈public T pop() {return list.removeLast();}}       MyStack<Hero> stack = new MyStack<Hero>();for (int i = 0; i < 5; i++) {stack.push(new Hero("Hero " + i));}for (int i = 0; i < 5; i++) {System.out.println(stack.pop());}//取出与存入的数据顺序是不一致的HashMap<String,Hero> map = new HashMap<String,Hero>();for (int i = 0; i < 5; i++) {Hero h = new Hero("Hero " + i);map.put(h.name, h);}System.out.println(map);}
}

package com.aroma.review;public class Hero {public String name;//构造方法public Hero(String name) {this.name = name;}//重写toString方法@Overridepublic String toString() {return name;}
}

运行结果：

[Hero 0, Hero 1, Hero 2, newHero, Hero 3, Hero 4]
Hero 0
Hero 1
Hero 2
Hero 3
Hero 4
[Hero 0, Hero 1, Hero 2, Hero 3, Hero 4]
Hero 4
Hero 3
Hero 2
Hero 1
Hero 0
{Hero 1=Hero 1, Hero 0=Hero 0, Hero 3=Hero 3, Hero 2=Hero 2, Hero 4=Hero 4}

14、Lambda

Lambda其实就是匿名方法，是一种把方法作为参数传递的编程思想

管道是一系列的聚合操作，分为管道源，中间操作和结束操作

package com.aroma.review;import java.util.ArrayList;
import java.util.List;
import java.util.Random;public class TestLambda {public static void main(String[] args) {// 初始化Random r = new Random();List<Hero> list = new ArrayList<Hero>();for (int i = 0; i < 5; i++) {list.add(new Hero("Hero " + i, r.nextInt(1000), r.nextInt(100)));}// 使用匿名类Check check = new Check() {public boolean test(Hero h) {return h.hp > 100 && h.damage < 50;}};System.out.println("匿名类：");filter(list, check);// 使用LambdaSystem.out.println("Lambda：");filter(list, h -> h.hp > 100 && h.damage < 50);// 使用静态方法System.out.println("静态方法：");filter(list, TestLambda::test);// 使用对象方法System.out.println("对象方法：");filter(list, Hero::test);// 使用聚合操作System.out.println("聚合操作：");list.stream().filter(h -> h.hp > 100 && h.damage < 50).forEach(h -> System.out.println(h));}// 静态方法private static void filter(List<Hero> list, Check check) {for (Hero h : list) {if (check.test(h))System.out.println(h);}}public static boolean test(Hero h) {return h.hp > 100 && h.damage < 50;}//接口interface Check {     public boolean test(Hero h);}}

package com.aroma.review;public class Hero {public String name;public float hp;       public int damage;//构造方法public Hero(){}public Hero(String name,float hp, int damage) {this.name =name;this.hp = hp;this.damage = damage;}public boolean test(){return this.hp>100 && this.damage<50;}//重写toString方法@Overridepublic String toString() {return "[name=" + name + ", hp=" + hp + ", damage=" + damage + "]";}
}

运行结果：

匿名类：
[name=Hero 1, hp=132.0, damage=36]
[name=Hero 2, hp=997.0, damage=4]
Lambda：
[name=Hero 1, hp=132.0, damage=36]
[name=Hero 2, hp=997.0, damage=4]
静态方法：
[name=Hero 1, hp=132.0, damage=36]
[name=Hero 2, hp=997.0, damage=4]
对象方法：
[name=Hero 1, hp=132.0, damage=36]
[name=Hero 2, hp=997.0, damage=4]
聚合操作：
[name=Hero 1, hp=132.0, damage=36]
[name=Hero 2, hp=997.0, damage=4]

15、多线程

创建多线程有3种方式，分别是继承线程类，实现Runnable接口和匿名类

如果一个类，其方法都是有 synchronized 修饰的，那么该类就叫做线程安全的类

线程池的思路和生产者消费者模型是很接近的

16、JDBC

JDBC（Java DataBase Connection）是通过Java访问数据库

导入mysql-connector-java-5.1.30.jar包：项目右键Properties -> Java Build Path -> Libraries -> Add External JARs...

jar包下载地址：https://mvnrepository.com/

Connection 用于与数据库建立连接，Statement用于执行sql语句

PreparedStatement有预编译机制，性能比Statement更快，可防止sql注入式攻击

ORM（Object Relationship Database Mapping）对象和关系数据库的映射

DAO（Data Access Object）数据访问对象

package com.aroma.review;import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;public class TestJDBC {public static void main(String[] args) {// 初始化驱动try {// 忘记导包会抛出ClassNotFoundExceptionClass.forName("com.mysql.jdbc.Driver");} catch (ClassNotFoundException e) {// TODO Auto-generated catch blocke.printStackTrace();}// 数据库必须先创建hero表String sql = "insert into hero values(null,?,?,?)";try (// 数据库的ip，端口号，名称，编码方式，账号和密码Connection c = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/aroma?&characterEncoding=utf8","root","root");// Statement用于执行sql语句Statement s = c.createStatement();// PreparedStatement需要根据sql语句创建PreparedStatement ps = c.prepareStatement(sql);) {// 插入，每次都要编译for (int i = 0; i < 5; i++) {String sql2 = "insert into hero values(null," + "'Ahri'" + "," + 99.0f + "," + 40 + ")";s.execute(sql2);}// 插入,预编译，响应更快for (int i = 0; i < 5; i++) {ps.setString(1, "Garen");ps.setFloat(2, 100.0f);ps.setInt(3, 50);ps.execute();}// 删除String sql3 = "delete from hero where id = 1";s.execute(sql3);// 修改String sql4 = "update hero set name = 'Annie' where id = 2";s.execute(sql4);// 遍历String sql5 = "select * from hero";ResultSet rs = s.executeQuery(sql5);while (rs.next()) {System.out.printf("%d\t %s\t %f\t %d%n", rs.getInt(1), rs.getString(2), rs.getFloat(3), rs.getInt(4));}// 总记录数String sql6 = "select count(*) from hero";ResultSet rs2 = s.executeQuery(sql6);int count = 0;while (rs2.next()) {count = rs2.getInt(1);}System.out.println("总共" + count + "条数据");// 获取元数据DatabaseMetaData dbmd = (DatabaseMetaData) c.getMetaData();System.out.println("产品名称：" + dbmd.getDatabaseProductName());System.out.println("产品版本：" + dbmd.getDatabaseProductVersion());System.out.println("分隔符：" + dbmd.getCatalogSeparator());System.out.println("驱动版本：" + dbmd.getDriverVersion());ResultSet rs3 = dbmd.getCatalogs();while(rs3.next()) {System.out.println("数据库名称：" + rs3.getString(1));}} catch (SQLException e) {// TODO Auto-generated catch blocke.printStackTrace();}}
}

运行结果：

2     Annie   99.000000   40
3    Ahri    99.000000   40
4    Ahri    99.000000   40
5    Ahri    99.000000   40
6    Garen   100.000000  50
7    Garen   100.000000  50
8    Garen   100.000000  50
9    Garen   100.000000  50
10   Garen   100.000000  50
总共9条数据
产品名称：MySQL
产品版本：5.7.27
分隔符：.
驱动版本：mysql-connector-java-5.1.30 ( Revision:${svn.Revision} )
数据库名称：information_schema
数据库名称：aroma
数据库名称：mysql

Java知识点笔记（一）：how2j.cn的学习（一）相关推荐

java学习网站http://how2j.cn/
http://how2j.cn/ 转载于:https://www.cnblogs.com/YUJIE666/p/10542566.html
《Java学习笔记(第8版)》学习指导
<Java学习笔记(第8版)>学习指导目录图书简况学习指导第一章 Java平台概论第二章从JDK到IDE 第三章基础语法第四章认识对象第五章对象封装第六章继承与多 ...
2022疫情缩水,啃透这份399页Java架构知识点笔记,已从13K涨到25K
本来已经在为去大厂工作摩拳擦掌的Java朋友,社招又是需要5年以上的,今年显得格外艰难: 就业人数高达874万!人才竞争加剧! 疫情让大多数公司的招聘需求缩减!对社招来说,人才招聘要求愈来愈高! 别说 ...
【推荐】Java自学网站HOW2J.CN 手把手带你做实践项目
写在前面:HOW2J.CN 最近开始找实习,发现大部分公司更需要会Java的,而不是只会Python的,所以只好开始重新学习Java了.因为之前学过,所以对基本语法的掌握还是非常快的. 学习Java不 ...
《Java Web开发入门很简单》学习笔记
<Java Web开发入门很简单>学习笔记 1123 第1章了解Java Web开发领域 Java Web主要涉及技术包括:HTML.JavaScript.CSS.JSP.Servlet ...
Java中如何创建自定义的注解学习笔记（MD版）
概要 Java中如何创建自定义的注解学习笔记(MD版). 博客博客地址:IT老兵驿站. 前言记得这篇笔记还是在泉州的龙玲酒店记录的,是一个周六的晚上,坐飞机从上海到泉州,从笔记中能勾起一些旅游的回 ...
Java知识点太多？北大教授点破Java学习秘籍
知识点太多??? 那是你没有彻底了解Java的学习方法!!! 在Java学习中什么该学什么不该学习,或者学到那为止,又或者学到那里才算完结一个知识点,就像23个设计模式你真的要在初学Java的过程中, ...
Java Web--HTML、CSS、JavaScript详细学习笔记（内含丰富示例代码）
** Java Web–HTML.CSS.JavaScript学习笔记 ** HTML(Hyper Text Markup Language超文本标记语言):控制的是页面的内容,是由标签组成的语言,能 ...
深度学习知识点笔记汇总
这段时间把CS231n课程作业网站上的知识点文档仔细看了一遍,感觉收获很大.于是后面就花了几天时间翻译.整理.总结这些文档的内容,并贴在CSDN博客上.如果发现有翻译错误或者没看懂的地方,欢迎留言 ...

Java知识点笔记（一）：how2j.cn的学习（一）

Java知识点笔记（一）：how2j.cn的学习（一）相关推荐

最新文章

热门文章