Java总结-2019.10

节点1:环境搭建,Java基础语法

1. 环境搭建

版本:
J2SE、J2EE、J2ME
下载并安装JDK
JDK(Java Develop Kit):开发工具包
JRE(Java Runtime Environment):运行时环境
配置环境变量
右键—>计算机—>选择“属性”—>点击“高级系统设置”—>打开“系统属性”窗口—>点击“环境变量”
(1) 新建“JAVA_HOME”环境变量,值设置为:JDK的安装目录
(2) 修改“Path”环境变量,添加“;%JAVA_HOME%\bin;”
(3) Classpath(可选)
验证是否安装成功:
打开“运行”—>输入cmd—>在命令提示符窗口,输入java –version,如果能够出现如下界面,则安装成功!
在这里插入图片描述

2. 第一个Java程序

创建文件名为HelloWorld.java的源文件:

//定义一个公共类,类名HelloWorld
public class HelloWorld{
	//类体-main方法
	public static void main(String[] args){
		//方法体
		System.out.print("Hello World!");
	}
}

运行Java程序:
(1) 打开“运行”,输入cmd,打开命令提示符窗口
(2) 切换目录
a) 切换盘符: e:
b) 切换目录: cd billfox(cd—change directory)
c) 编译程序: javac HelloWorld.java(编译源文件,获得class字节码文件)
d) 运行程序: java HelloWorld(运行字节码文件)

3. 开发工具的安装使用

安装版.exe
解压版

4. 使用Eclipse创建Java项目

包名:反域名制(com.taobao.projectName)
类名:所有单词首字母要大写!(UpperCamelCase驼峰命名法 StudentCount)
变量名,方法名,参数名:(lowerCamelCase驼峰命名法 studentCount)
常量:所有字母大写,每个单词之间用下划线隔开。 MAX_STOCK_COUNT

命名规范:由字母,数字,下划线和$组成,不能以数字开头。
比如:num1 num_1 $num

5. Java编程基础

1) 变量

语法:数据类型 变量名 [= 值];
例子:int count = 10;
float studentWeight;

标识符和关键字
标识符:是用来表示变量名、类名、方法名、数组名和文件名的有效字符序列。
关键字:是Java语言中被赋予特定含义的一些单词。

变量的作用域

public class Demo01 {
	public static void main(String[] args) {
		//变量的作用域
		int x = 10;
		
		{
			//代码块
			int y = 20;
			System.out.println(y);
			System.out.println(x);
		}
		
		System.out.println(y);//报错,超出了y的作用范围
		System.out.println(x);
	}
}

2) 数据类型( 四类8种)

(1) 整数型
a) 字节型byte 1个字节(8位) -27 ~27-1
b) 短整型short 2个字节(16位) -215 ~215-1
c) 整型int 4个字节(32位) -231 ~231-1
d) 长整型long 8个字节(64位) -263 ~263-1
(2) 浮点数类型
a) 单精度浮点 float 4个字节
b) 双精度浮点 double 8个字节
(3) 布尔型 boolean (true,false)
(4) 字符型 char

数据类型转换
(1) 自动类型转换(小 转 大)
byte–>short–>char–>int–>long–>float–>double
例子:
int num = 20;
float f1 = num;
(2) 强制类型转换(大 转 小)
例子:
float f2 = 2.5f;
int num2 = (int)f2;//有可能损失精度或者溢出
(3) 字符串型数据和整型数据相互转换 “10” 10
a) 字符串 转 数字 int num = Integer.parseInt(“10”);
b) 数字 转 字符串 String str = 10 + “”;

3) 输入输出

输出:
System.out.print(输出的内容); //不换行
System.out.println(输出的内容); //输出内容后换行
输入:
Scanner sc = new Scanner(System.in);//简易的文本扫描器
int I = sc.nextInt();//获取输入的整数
float f = sc.nextFloat();//获取输入的单精度浮点数
double d = sc.nextDouble();//获取输入的双精度浮点数
String s = sc.next();//获取输入的字符串

代码提示配置
参考https://www.cnblogs.com/zgqys1980/p/5067337.html
主动触发代码提示的快捷键:Alt + /
字体大小配置
Window->preferences->搜索”font”->选择”Colors and Fonts”->选择右侧列表中Basic下的Text Font,然后点击编辑(Edit)按钮,修改你想要的字体大小即可。

4) 常量

符号常量:final double PI = 3.1415926;
字面常量:10、2.5、’a’

5) 运算符

1. 算术运算符

+、-、*、/、%、++(前/后)、–(前/后)

注意:
/ 当两个运算数为整数时,为取整运算。
/ 当两个运算符不全为整数时,为除法运算。

c = a++;//先把a的值赋给c,然后a再自增
c = ++a;//先把a的值自增,然后把a赋给c

2. 关系运算符

、<、>=、<=、==、!=

由关系运算符构成的关系表达式,返回值为布尔值,即true/false.

3. 逻辑运算符

&&(短路与)、||(短路或)、!、&(非短路与)、|(非短路或)、^(异或)

逻辑运算符,用于连接关系表达式(boolean),最终的结果,也是布尔值(boolean)。

4. 位运算符

5. 赋值运算符

=、+=、-=、*=、/=、%=

a += 10;// 等价于 a = a + 10;

6. 条件运算符

表达式1?表达式2:表达式3;

“表达式1”是一个结果为布尔值的逻辑表达式。也就是返回值为true/false
运算规则:
如果表达式1返回true,则整个表达式的返回值为表达式2;否则返回表达式3;

7. 字符串运算符

其实就是对字符串进行拼接。

8. 运算符的优先级

. [] ()
算术运算符
关系运算符
逻辑运算符
条件运算符
赋值运算符

6) 流程控制语句

1. 顺序结构

2. 分支结构

  1. 单分支if
  2. 双分支if…else…
  3. 多分支
    a) If…else if…else if…else
    b) Switch(表达式){case 值1:break; default:break;}
  4. 分支结构嵌套

3. 循环结构

  1. While
  2. Do…while
  3. For
  4. Foreach增强for循环

4. 跳转语句

break;//结束循环
continue;//退出本次循环,进入下一次
return;//退出方法

7) 数组

1. 数组的定义

	(1)int[] scores;//声明
	     scores = new int[45];//初始化
	
	(2)int[] scores = new int[45];//声明数组的同时初始化
	
	(3)静态初始化
		int[] arr = new int[] {1,2,3,4,5,6};
		int[] arr =  {1,2,3,4,5,6};

2. 数组的赋值

		scores[0] = 10;
		scores[1] = 15;

3. 数组的常用操作

	数组遍历
	数组最值(最大值,最小值)
	数组排序(冒泡排序,选择排序)
	数组元素的删除,修改

4. Arrays

	排序 sort
	查询 binarySearch
	复制 copyOf
	转字符串 toString
	填充 fill

8) 方法

1. 方法的定义

[修饰符] 返回值类型 方法名([参数类型 参数名1,参数类型 参数2…]){
//方法体
}

例子:

public static void printStar(int line,int column) {
		
		for(int i = 0;i < line;i++) {
			//打印第i行: 
			//打印j个星号
			for(int j=0;j<column;j++) {
				System.out.print("*");
			}
			//打印换行
			System.out.println();
		}
}

2. 方法的分类

(1) 无返回值无参数

public class Demo02 {
	public static void main(String[] args) {
		welcome();
	}
	
	public static void welcome() {
		System.out.println("**************");
		System.out.println("***  欢迎光临   ***");
		System.out.println("**************");
	}
}

(2) 无返回值有参数

public class Demo03 {
	public static void main(String[] args) {
		welcome("Hello");
	}
	
	public static void welcome(String content) {
		System.out.println("**************");
		System.out.println("***  "+content+"  ***");
		System.out.println("**************");
	}
}

(3) 有返回值无参数

public class Demo04 {
	public static void main(String[] args) {
		int num = getNum();
		//System.out.println(num);
		
	}
	
	//有返回值
	public static int getNum() {
		//创建随机类
		Random rad = new Random();
		//int n = rad.nextInt(); //获得一个随机数
		int n = rad.nextInt(); //获得一个bound范围之内的随机数, 10   [0,10)   n>=0  n<10
		return n;
	}
}

(4) 有返回值有参数

public class Demo05 {
	public static void main(String[] args) {
		int sum = add(8, 5);
		System.out.println(sum);
	}
	
	//加法
	public static int add(int n1,int n2) {
		int result = n1 + n2;
		return result;
	}
}

节点2:Java面向对象编程

  1. 面向对象编程思想
    与面向过程编程思想的区别:
    可以拿生活中的实例来理解面向过程与面向对象,例如五子棋,面向过程的设计思路就是首先分析问题的步骤:1、开始游戏,2、黑子先走,3、绘制画面,4、判断输赢,5、轮到白子,6、绘制画面,7、判断输赢,8、返回步骤2,9、输出最后结果。把上面每个步骤用不同的方法来实现。

如果是面向对象的设计思想来解决问题。面向对象的设计则是从另外的思路来解决问题。整个五子棋可以分为1、黑白双方,这两方的行为是一模一样的,2、棋盘系统,负责绘制画面,3、规则系统,负责判定诸如犯规、输赢等。第一类对象(玩家对象)负责接受用户输入,并告知第二类对象(棋盘对象)棋子布局的变化,棋盘对象接收到了棋子的变化就要负责在屏幕上面显示出这种变化,同时利用第三类对象(规则系统)来对棋局进行判定。
2. 类和对象的概念:
• 对象:对象是类的一个实例(对象不是找个女朋友),有状态和行为。例如,一条狗是一个对象,它的状态有:颜色、名字、品种;行为有:摇尾巴、叫、吃等。(具体)
• 类:类是一个模板,它描述一类对象的行为和状态。(抽象)
3. 类的设计

  1. 类的构成:
    1) 成员变量
    2) 成员方法
    3) 构造方法
     特点:
    1.构造方法的方法名必须和类名一致。
    2.没有返回值类型。
    4) 类成员
     类变量(静态变量) 访问: 类名.类变量
     类方法(静态方法) 访问: 类名.类方法()
     静态代码块
    /*
  • 类的设计

  • 1)成员变量

  • 2)成员方法

  • 3)构造方法

  • 4)类成员

  • a.类变量

  • b.类方法

  • c.静态代码块

  • 类,其实一种用户自定义的数据类型。

  • 编码规范:驼峰命名法
    */
    public class Student {

    //1.成员变量
    String name;
    String sex;
    int age;

    //2.成员方法
    public void study() {
    System.out.println(name+“在学Java,在”+school);//成员方法可以访问类变量,但类方法不能访问成员变量。
    }

    public void playGame() {
    System.out.println(name+“在玩王者荣耀”);
    }

    //3.构造方法
    /*

    • 特点:
    • 1.构造方法的方法名要和类名一致。
    • 2.没有返回值类型。
    • —3.一般情况下,用public来修饰。
      */
      public Student() {
      System.out.println("–构造方法执行–");
      count++;
      }

    //4.类变量(静态变量)
    static String school;
    static int count;//当前类的对象个数

    //5.类方法(静态方法)
    public static void count() {
    System.out.println(“学校共有”+ count+“个学生 。”);
    }

    //6.静态代码块
    static {
    //对类进行初始化
    count = 0;
    System.out.println("–学校构建完成。–");
    }
    }

  1. 参数的传递(值传递)
    基本数据类型:变量值
    引用数据类型:内存值

了解:InstanceOf:判断某个对象是否是某个类的对象。 S1 instanceof Student

  1. 方法重载
    方法重载的特点:
  1. 在同一个类中

  2. 方法名相同

  3. 参数的个数或者类型不同
    public class Actor {
    String name;

    //表演
    public void act() {
    System.out.println(“唱歌”);
    }

    public void act(String instrument) {
    System.out.println(“边弹” + instrument +“边唱”);
    }

    public void act(int n) {
    System.out.println(“循环唱” + n +“次”);
    }
    }

    方法重载,包括:

  4. 成员方法重载

  5. 构造方法重载。
    public class Actor {
    //成员变量
    String name;
    String sex;
    int age;

    //成员方法 重载
    public void act() {
    System.out.println(“唱歌”);
    }

    public void act(String instrument) {
    System.out.println(“边弹” + instrument +“边唱”);
    }

    public void act(int n) {
    System.out.println(“循环唱” + n +“次”);
    }

    //构造方法 重载
    public Actor() {
    }

    public Actor(String actorName) {
    name = actorName;
    }

    public Actor(String actorName,String actorSex) {
    name = actorName;
    sex = actorSex;
    }

    public Actor(String actorName,String actorSex,int actorAge) {
    name = actorName;
    sex = actorSex;
    age = actorAge;
    }
    }

    补充:可变参数
    //求整数的和(可变参数)
    public int add(int… nums) {
    int sum = 0;
    for (int i = 0; i < nums.length; i++) {
    sum = sum + nums[i];
    }
    return sum;
    }

  1. this
    this指当前类的对象
    public Actor(String name,String sex,int age) {
    this.name = name;//当前要创建的对象的name属性 = name参数;
    this.sex = sex;
    this.age = age;
    }
    通过this关键字
    1.可以调用当前类的成员变量。
    2.可以调用当前类的成员方法。
    3.可以调用当前类的构造方法。
    public class Student {
    String name;
    String sex;

    public void study() {
    System.out.println(this.name+“在学习”);//1.通过this调用成员变量
    }

    public void race() {
    this.study();//2.通过this调用成员方法
    System.out.println(“参加比赛!”);
    }

    public Student() {

    }

    public Student(String name){
    this();//3.通过this调用无参构造
    this.name = name;
    }
    }

节点3:封装,继承,多态

  1.  封装
    

实现步骤:
(1)属性私有化 (2)提供公共的getter,setter方法
自动生成get,set方法:右键—>Source—>Generate Getters and Setters

public class Actor {
//成员变量
private String name;
private String sex;
private int age;

//提供公共的get,set方法
public void setName(String name) {
	this.name = name;
}

public String getName() {
	return this.name;
}

public void setSex(String sex) {
	if (sex.equals("男") || sex.equals("女")) {
		this.sex = sex;
	}else {
		System.out.println("您设置的性别有误!");
	}
}

public String getSex() {
	return this.sex;
}

public void setAge(int age) {
	if (age < 0 || age > 130) {
		System.out.println("您设置的年龄有误!");
	}else {
		this.age = age;
	}
	
}

public int getAge() {
	return this.age;
}

//成员方法 重载
public void act() {
	System.out.println("唱歌");
}

public void act(String instrument) {
	System.out.println("边弹" + instrument +"边唱");
}

public void act(int n) {
	System.out.println("循环唱" + n +"次");
}

//构造方法  重载
public Actor() {
}

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

public Actor(String name,String sex) {
	this.name = name;
	this.sex = sex;
}

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

}
2. 继承

  1. 继承的概念:
    可以基于已经存在的类构造一个新类。继承已经存在的类就可以复用这些类的方法和域。在此基础上,可以添加新的方法和域,从而扩充了类的功能。

继承的关键字:extends

  1. 继承的特点:
  1. 可以实现代码的复用—子类拥有父类非私有的属性和方法。
  2. 子类可以对父类进行扩展—子类可以拥有自己的属性和方法。
  3. 方法重写—子类可以用自己的方式去实现父类的方法。
  4. 单继承,可以多重继承
  5. 缺点:提高了代码的耦合度。

例子:
定义父类:
public class Animal {
//父类定义子类共有的属性和行为
String name;
String sex;
int age;
String color;

public void eat() {
	System.out.println(name + "吃东西");
}

}
定义子类-Cat:
public class Cat extends Animal{
//猫类特有的行为
public void catchMouse() {
System.out.println(name+ “抓老鼠…”);
}
}
定义子类-Dog:
public class Dog extends Animal {
//狗类特有的行为
public void guard() {
System.out.println(name + “看家”);
}

}
3) 修饰符
(1) 访问修饰符
a) public:所有类都可以访问。 (当前类,同一个包中的不同类,不同包的类)
b) protected:包的访问权限+不同包的子类 (当前类,同一个包中的不同类,不同包的子类)
c) 缺省:包的访问权限。 (当前类,同一个包中的不同类)
d) private:当前类 (当前类)

(2) 非访问修饰符
a) static
i. 修饰成员变量,则成员变量变为类变量。static String school = “莱职”;
ii. 修饰成员方法,则成员方法变为类方法。
iii. 修饰代码块,则代码块变为静态代码块。特点:是在main方法之前运行,而且只运行一次。其实就是在类加载时运行。
b) final
i. 修饰变量,则变量变成不可改变的量,即常量。 final int num = 10;
ii. 修饰方法,则方法变为不可重写的方法。
iii. 修饰类,则类变为不可继承的类。
c) abstract 抽象
4) 方法重写
特点:
1.要有继承,重写发生在两个类之间,子类去重写父类的同名的方法
2.子类的方法名要和父类的方法名相同,而且参数(个数,类型)也要完全一致。
3.子类对方法的修饰,只能扩大,不能缩小。

父类:
public class Animal {
//域(成员变量)
String name;
String sex;
int age;
String color;

//方法(成员方法)
public void eat() {
	System.out.println(name + "吃东西");
}

}
子类:
public class Cat extends Animal{
//特有的行为(扩展)
public void catchMouse() {
System.out.println(name+ “抓老鼠…”);
}

//子类可以重写从父类继承而来的方法
public void eat() {
	System.out.println(name+"吃鱼");
}

}

  1. Super
    Super:指的是当前对象的父类
    public class Dog extends Animal {
    //特有的行为(扩展)
    public void guard() {
    System.out.println(name + “看家”);
    }

    //方法重写 — 注解
    @Override
    public void eat() {
    super.eat();//调用超类(父类)的eat方法
    System.out.println(super.name+“啃骨头”);//调用超类(父类)的name属性
    }
    }
    通过super关键字
    1.可以调用父类的成员变量 super.property;
    2.可以调用父类的成员方法 super.method();
    3.可以调用父类的构造方法 super();

注意:子类默认会调用父类的无参构造,如果显式的调用了父类的有参构造,则不会再调用父类的无参构造。

  1. 多态
    多态的三个必要条件:
    1.继承
    2.重写
    3.父类引用指向子类对象(上转型对象)

节点4:抽象类和接口

  1. 抽象类
  1. 定义抽象类:
    abstract class Person{
    //可以包含抽象方法
    }

class Student extends Person{
//子类继承抽象类,要去重写父类的抽象方法。
}

  1. 特点:
    1.抽象类不一定包含抽象方法,但包含抽象方法的类,一定是抽象类。
  1. 抽象类中的抽象方法只是声明,不包含方法体,就是不给出方法的具体实现也就是方法的具体功能。
    3.抽象类不能实例化。
    4.抽象类只能作为子类的超类(父类),被用来创建继承层级里子类的模板。
    5.Java中只有单继承。
  2. 构造方法,类方法(用 static 修饰的方法)不能声明为抽象方法。
  3. 抽象类的子类必须给出抽象类中的抽象方法的具体实现,除非该子类也是抽象类。
    抽象类存在的意义,就是被继承。
  4. 接口
  1. 语法 :
    [可见度] interface 接口名称 [extends 其他的接口名] {
    // 声明变量
    // 抽象方法
    }

示例:
/*

  • 1.普通类
  • 只能包含非抽象方法。
    */
    public class Student {
    //属性
    String name;
    String sex;
    int age;
    //方法
    public void study() {
    System.out.println(“学习”);
    }
    }

/*

  • 2.抽象类
  • 可以包含抽象方法,非抽象方法,也可以不包含任何方法。
    */
    public abstract class Animal {
    //属性
    String name;
    //方法
    public abstract void eat();
public void bark() {
	System.out.println("叫。。。");
}

}

/*

  • 3.接口
  • 只能有抽象方法。
    */
    public interface Work {
    //属性(默认用public static final修饰)
    int count = 0;//注意:接口中的静态常量,一定要赋初值。
    //方法(默认用public abstract修饰)
    void work();//抽象方法前的public abstract修饰符可以省略
    public abstract void earnMoney();
    }
  1. 接口的实现:
    public class Teacher implements Work {

    @Override
    public void work() {
    System.out.println(“上课”);
    }

    @Override
    public void earnMoney() {
    System.out.println(“拿课时费”);
    }

}
3) 特点:
抽象类是一种特殊的类。接口是一种特殊的抽象类。
接口是一个抽象方法的集合。、
Java中,对于类来说,只有单继承,但对于接口来说,可以多继承。
定义接口的关键字:interface

  1. 标记接口
    标记接口是没有任何方法和属性的接口.它仅仅表明它的类属于一个特定的类型,供其他代码来测试允许做一些事情。
    标记接口作用:简单形象的说就是给某个对象打个标(盖个戳),使对象拥有某个或某些特权。
    示例:
    package java.util;
    public interface EventListener {}

节点5:Object类和常用API

  1. Object
    Object类是所有类的父类。
  1. 常用方法:
    (1) hashcode() 返回哈希值
    (2) equals() 判断对象是否相等
    自动生成方式:在代码中,右键,选择”source”->”Genareate hashcode() and equals()”
    (3) getClass() 返回此Object的运行时类。
    (4) toString() 返回对象的字符串形式
    自动生成方式:在代码中,右键,选择”source”->”Genareate toString() ”
  1. String(不可变性)
  1. 创建字符串(构造方法)
    (1) String str0 = “Hello”;//字符串常量
    (2) String str1 = new String(“Hello”);//通过String构造方法
    (3) String str2 = new String(char[] cs);//通过字符数组构造字符串
    了解String的11种构造方法

  2. 操作字符串(常用方法)
    (1) charAt(int index) 返回指定索引处的字符
    (2) indexOf(String s) 查找字符在字符串中第一次出现的位置
    (3) lastIndexOf(String) 查找字符在字符串中最后一次出现的位置
    (4) contains(String s) 判断是否包含字符序列
    (5) substring(int beginIndex)
    从beginIndex位置截取子字符串,一直扩展到字符串末尾
    (6) substring(int beginIndex,int endIndex) [begin,end)
    从beginIndex位置截取子字符串,一直到endIndex位置,不包括endIndex.
    (7) trim() 去除前后空格!
    (8) replace(char oldChar,char newChar) 替换
    (9) split(String s) 字符串分割
    (10) equals() 判断字符串内容是否相同
    (11) equalsIgnoreCase() 忽略大小写判断相等
    (12) matches(正则表达式)
    (13) length() 返回字符串的字符数(长度)
    (14) isEmpty() 判断字符串是否为空字符串
    (15) static valueOf(各种数据类型) 返回各种数据类型的字符串形式
    (16) toCharArray() 字符串 转 字符数组
    (17) getBytes() 字符串 转 字节
    (18) toLowerCase() 转小写
    (19) toUpperCase() 转大写
    (20) concat() 字符串拼接 +
    (21) format() 格式化字符串 %f %d %s

  3. 正则表达式
    (1)匹配位置
    ^ 匹配字符串开始的位置。
    $ 匹配字符串结束的位置。
    (2)匹配字符
    .(点号) 匹配任意一个字符
    \ 将下一字符标记为特殊字符
    \s 匹配任意空白字符(空格,\f换页符\n换行符\r回车符\t制表符\v垂直制表符)
    \S 匹配任意非空白字符
    \d 匹配任意数字
    \D 匹配非数字
    \w 匹配任何字类字符。等价于[A-Za-z0-9_]
    \W 匹配任何非字类字符。等价于[^A-Za-z0-9_]
    (3)匹配字符范围
    x|y 匹配x或y.
    [xyz] 匹配包含的任一字符。
    [^xyz] 匹配未包含的任一字符。
    [a-z] 匹配字符范围。
    [^a-z] 匹配反向范围字符
    (4)匹配次数

    •    匹配前面的字符1-n次
      
    •    匹配前面的字符0-n次
      

    ? 匹配前面的字符0-1次
    {n} 匹配前面的字符正好n次
    {n,} 匹配前面的字符至少n次
    {n,m} 匹配前面的字符至少n次,至多m次。

    总结:正则表达式,可以用于匹配matches(),替换replace()和分割split()。

  4. StringBuffer 、StringBuilder
    StringBuffer sBuffer = new StringBuffer(“Hello”);
    System.out.println(sBuffer);
    sBuffer.append(“World!”); //在末尾追加字符 //0123456789
    System.out.println(sBuffer); //HelloWorld!
    sBuffer.delete(3, 5); //删除多个字符(指定范围) [3,5)
    System.out.println(sBuffer); //HelWorld!
    sBuffer.deleteCharAt(0);//删除单个字符(指定位置)
    System.out.println(sBuffer);//elWorld!
    sBuffer.insert(2, “123456”);//在指定位置,插入内容
    System.out.println(sBuffer);//el123456World!
    sBuffer.reverse();//倒序
    System.out.println(sBuffer);
    sBuffer.setCharAt(0, ‘A’);//修改指定位置的字符
    System.out.println(sBuffer);
    StringBuffer中包含很多自己特有方法,也包含一些类似String类中的方法。比如(subString,indexOf,charAt)
    StringBuilder和StringBuffer的方法,基本完全相同。

总结:
  String:适用于少量的字符串操作的情况
  StringBuilder:适用于单线程下在字符缓冲区进行大量操作的情况
  StringBuffer:适用多线程下在字符缓冲区进行大量操作的情况

  1. 日期时间类
  1. Date
    Date date = new Date();//获取当前时间

  2. SimpleDateFormat
    (1)Date转String
    SimpleDateFormat sdf = new SimpleDateFormat(“yyyy年MM月dd日 hh时mm分ss秒 SSS E D”);
    String strDate = sdf.format(date);
    System.out.println(strDate);
    (2)String转Date
    String str = “2018年10月01日 10:30:30”;
    SimpleDateFormat sdf2 = new SimpleDateFormat(“yyyy年MM月dd日 hh:mm:ss”);
    Date date2 = sdf2.parse(str);//异常
    System.out.println(date2);

    获得系统时间的毫秒数
    long start = System.currentTimeMillis( );
    long end = date.getTime();

  3. Calendar
    //获取Calendar对象
    Calendar c = Calendar.getInstance();
    System.out.println©;

    //修改Calendar的时间
    //c.set(2009, 6-1, 12);
    
    //获取日期的部分信息--年份
    System.out.println(c.get(Calendar.YEAR));
    System.out.println(c.get(Calendar.MONTH));
    System.out.println(c.get(Calendar.DAY_OF_MONTH));
    
    
    System.out.println(c.get(Calendar.DAY_OF_WEEK));
    
    System.out.println(c.get(Calendar.HOUR));
    System.out.println(c.get(Calendar.HOUR_OF_DAY));
    
    //单独设置属性值
    c.set(Calendar.YEAR, 2009);
    
    c.add(Calendar.YEAR, 5);
    c.add(Calendar.MONTH, 2);
    
    System.out.println(c.get(Calendar.YEAR));//2014
    System.out.println(c.get(Calendar.MONTH));//5
    
    //判断闰年
    GregorianCalendar gc = new GregorianCalendar();
    System.out.println(gc.isLeapYear(1900));
    
  1. 包装类
    //包装类 (Byte,Short,Integer,Long Float,Double Character Boolean)
    //基本数据类型(byte,short,int,long float,double char boolean)

    //面向对象编程
    int num0 = 10;//数字
    Integer num1 = new Integer(20);//对象
    
    //Student student = new Student();
    
    //封箱(基本数据类型--->包装类)比如:int-->Integer
    Integer num2 = new Integer(num0);
    Integer num3 = Integer.valueOf(num0);
    
    //拆箱(包装类--->基本数据类型)比如:Integer-->int
    int num4 = num1.intValue();
    
    //自动封箱,拆箱
    Integer num6 = 10;
    int num5 = new Integer(10);
    
    //数值字符串   转成   基本数据类型   例子: "10"  -->  10
    String str = "10";
    System.out.println(str + 1);
    int num7 = Integer.parseInt(str);
    System.out.println(num7 + 1);
    
    String str2 = "2.5";
    System.out.println(str2 + 1);
    float f = Float.parseFloat(str2);
    System.out.println(f + 1);
    
  2. 数学类
    //数学类
    System.out.println(Math.E);
    System.out.println(Math.PI);

    System.out.println(Math.abs(-10.25));//绝对值
    System.out.println(Math.sin(Math.PI/6));
    System.out.println(Math.cos(Math.PI/3));
    
    System.out.println(Math.ceil(2.5));//天花板
    System.out.println(Math.floor(2.5));//地板
    System.out.println(Math.round(2.26));//近似值
    
    System.out.println(Math.sqrt(9));//开平方根
    System.out.println(Math.cbrt(8));//开立方根
    System.out.println(Math.pow(3, 4));// 求幂
    
    System.out.println(Math.max(10, 8));//最大值
    System.out.println(Math.min(10, 8));//最小值
    
    System.out.println(Math.toDegrees(Math.PI/6));//弧度 转 角度
    System.out.println(Math.toRadians(30));//角度 转 弧度
    
    System.out.println(Math.random());//随机数   0<=x<1
    
    System.out.println(Math.multiplyExact(2, 3));//乘法
    System.out.println(Math.negateExact(10));//取反		
    
  3. System和Runtime
    System.out.println(“Hello”);
    System.err.println(“Hello”);
    Scanner sc = new Scanner(System.in);
    //系统环境变量
    Map map = System.getenv();
    for (String string : map.keySet()) {
    System.out.print(string+";
    System.out.println(map.get(string));
    }
    System.out.println("===============");
    //系统属性
    Properties properties = System.getProperties();
    System.out.println(properties);
    System.out.println("------------------");

    Runtime runtime = Runtime.getRuntime();
    System.out.println("处理器的数量:" + runtime.availableProcessors());
    System.out.println("总内存数:" + runtime.totalMemory());
    
    //runtime.exec("C:\\Program Files (x86)\\Tencent\\TIM\\Bin\\QQScLauncher.exe");
    runtime.exec("notepad.exe");
    

节点6:泛型、集合应用技术
为什么要学习集合?
集合相比数组而言,集合的长度是可变的,但是数组是不可变的。

  1. Collection-单列集合
  1. List-列表(有序,可重复)
    数组:静态数组
    (1)ArrayList:动态数组(线程不同步,查询效率更高)

    //int[] arr = new int[10];
    //1.创建一个ArrayList(动态数组-可以自动扩展)
    ArrayList list = new ArrayList();
    //在没有指定泛型的时候,集合中可以添加任意类型的元素。
    list.add(1);
    list.add(2.5);
    list.add('A');
    list.add("Hello");
    list.add(new Student());
    list.add(6);
    list.add(7);
    list.add(8);
    list.add(9);
    list.add(10);
    //集合是永远都填不满的,也就是可以自动扩展.
    list.add(11);
    list.add(12);
    list.add(13);
    
    System.out.println(list.toString());
    
    //2.泛型(参数化类型)
    ArrayList iList = new ArrayList();
    
    //3.ArrayList的常用方法
    //3.1添加元素到末尾
    iList.add("tom");
    iList.add("jack");
    iList.add("rose");
    iList.add("Kitty");
    iList.add("Lufy");
    //3.2在指定位置添加元素
    iList.add(2, "Zoro");
    System.out.println(iList);
    //3.3删除指定位置的元素
    iList.remove(0);
    System.out.println(iList);
    //3.4修改元素
    iList.set(2, "Bluck");
    System.out.println(iList);
    //3.5获取元素
    String s = iList.get(2);
    System.out.println(s);
    
    //3.6获取集合元素个数
    System.out.println(iList.size());
    //3.7判断集合是否为空
    System.out.println(iList.isEmpty());
    //3.8判断集合是否包含指定元素
    System.out.println(iList.contains("Tomcat"));
    //3.9查找元素在集合中的位置
    int index = iList.indexOf("Lufy");
    System.out.println("Lufy在集合的"+index+"号位置");
    //3.10清空集合
    iList.clear();
    System.out.println(iList);
    System.out.println("集合是否为空:"+iList.isEmpty());
    System.out.println("---ArrayList的遍历--方式一:");
    //ArrayList的遍历--方式一
    for (int i = 0; i < iList.size(); i++) {
    	System.out.println(iList.get(i));
    }
    System.out.println("---ArrayList的遍历--方式二:");
    //ArrayList的遍历--方式二
    for (String string : iList) {
    	System.out.println(string);
    }
    System.out.println("---ArrayList的遍历--方式三:");
    //ArrayList的遍历--方式三(迭代器)
    Iterator iter = iList.iterator();//获取List的迭代器
    while(iter.hasNext()) {//通过迭代器,判断是否有下一个元素
    	String string = iter.next();//获取下一个元素
    	System.out.println(string);
    }
    

(2)Vector:(线程同步)[了解]
(3)LinkedList:链表(修改效率更高)
常用方法跟ArrayList基本相同。
不同之处:在性能方面。ArrayList适用于查询,LinkedList适用于增删改
2) Set-集合(无序,不可重复)
(1)HashSet:
//1.创建集合HashSet
HashSet hs = new HashSet();
System.out.print(“s1 equals s2:”);
System.out.println(s1.equals(s2));//true
//System.out.println(“String”.equals(“String”));
hs.add(1);
hs.add(2.5);
hs.add(‘A’);
hs.add(“String”);
hs.add(s1);
hs.add(s2);
hs.add(1);
hs.add(“String”);
//无序,不可重复
System.out.println(hs);

	//2.常用方法 和 泛型
	HashSet sHashSet = new HashSet();
	//2.1 添加
	sHashSet.add("tom");
	sHashSet.add("cat");
	sHashSet.add("rose");
	sHashSet.add("jack");
	System.out.println(sHashSet);
	//2.2删除
	sHashSet.remove("tom");
	System.out.println(sHashSet);
	//2.3判断是否包含某元素
	System.out.println(sHashSet.contains("jack"));
	//2.4获取集合的长度
	System.out.println(sHashSet.size());
	
	System.out.println("HashSet的遍历(迭代器):");
	//HashSet的遍历(迭代器)
	Iterator iter = sHashSet.iterator();
	while(iter.hasNext()) {
		String string = iter.next();
		System.out.println(string);
	}

在HashSet类中,如果添加自定义类的对象,要求不可重复,需要在自定义类中重写hashCode()和equals()方法。
自动生成equals()方法的方式:右键SourceGenarate hashcode() and equals()…
2. Map-双列集合

  1. HashMap(线程不安全)
    创建HashMap双列集合///
    HashMap hm = new HashMap();//初始容量16 0.75
    hm.put(1, “张三”);
    hm.put(“102”, 6);
    hm.put(2.5, 1);
    hm.put(101,new Student());

    //使用泛型//
    HashMap hmStudents = new HashMap();
    
    Student s1 = new Student();
    s1.setId(101);
    s1.setName("张三");
    Student s2 = new Student();
    s2.setId(102);
    s2.setName("李四");
    Student s3 = new Student();
    s3.setId(103);
    s3.setName("王五");
    Student s4 = new Student();
    s4.setId(104);
    s4.setName("赵六");
    /一、增删改查/
    //1.添加元素
    hmStudents.put(101, s1);
    hmStudents.put(102, s2);
    
    //4.获取元素
    Student s = hmStudents.get(103);
    System.out.println(s);
    
    //2.删除元素
    s = hmStudents.remove(102);
    System.out.println(s);
    
    //3.替换(修改)元素
    s = hmStudents.replace(101, s2);
    System.out.println(s);
    
    s = hmStudents.get(101);
    System.out.println(s);
    
    hmStudents.put(102, s1);
    hmStudents.put(103, s3);
    hmStudents.put(104, s4);
    //二、获取集合//
    //获取key的集合(第一列的集合)
    Set set = hmStudents.keySet();
    System.out.println(set);
    //获取value的集合(第二列的集合)
    Collection cs = hmStudents.values();
    System.out.println(cs);
    //获取entry的集合(两个列的集合)
    Set> entries = hmStudents.entrySet();
    System.out.println(entries);
    //三、判断包含及其他
    //判断是否包含某个key
    boolean b = hmStudents.containsKey(102);
    System.out.println(b);
    //判断是否包含某个value
    boolean b2 = hmStudents.containsValue(s3);
    System.out.println(b2);
    //判断集合是否为空
    hmStudents.isEmpty();
    //清空集合
    //hmStudents.clear();
    
    /四、遍历(综合应用)///
    //HashMap的遍历
    System.out.println("遍历方法一:");
    Set sIntegers = hmStudents.keySet();//获取第一列的集合
    Iterator iterator = sIntegers.iterator();//获取第一列集合的迭代器
    while (iterator.hasNext()) {
    	Integer key = (Integer) iterator.next();
    	System.out.print(key+"=");//打印key
    	Student stu = hmStudents.get(key);//根据key,获取value
    	System.out.println(stu);
    }
    
  2. Hashtable(线程安全,用法跟HashMap相同)

  1. Collections-工具类
    排序 sort
    查询 binarySearch
    复制 copy
    随机排列 shuffle
    反转(逆序)reverse
    交换 swap
    填充 fill
    查找子列表 indexOfSubList()、lastIndexOfSubList()
    节点7:异常和IO技术
  2. 异常
  1. 概念:
    异常是程序中的一些错误,但并不是所有的错误都是异常,并且错误有时候是可以避免的。

  2. 异常发生的原因:
    了解(物理错误,程序错误,用户错误)

  3. 异常的分类:
    (1)检查性异常:(在编译时,不能被忽略,不可避免,必须处理)
    java.io.FileNotFoundException 文件未找到异常
    (2)运行时异常:(在编译时被忽略,是可能被程序员避免的异常,可以避免,可以不处理,发生时修改代码)
    java.lang.ArithmeticException 算术运算异常
    java.lang.ArrayIndexOutOfBoundsException 数组下标越界异常

异常的类图

  1. 异常处理:
    (1)积极处理-捕获处理
    try{
    //可能发生异常的代码
    }catch(发生异常的类型 异常对象名){
    //处理异常的代码
    }finally{
    //释放资源(无论是否发生异常,都会执行)
    }
    注意:异常的默认处理方式是,会终止程序。导致程序不能继续运行!!

异常对象的常用方法
void printStackTrace()
将此throwable和其追溯打印到标准错误流。
String
getMessage()
返回此throwable的详细消息字符串。

多个catch语句
(1)一个try语句块,可以跟多个catch语句,捕获多种异常。
(2)在catch语句中,异常类的父类Exception要放在后面。异常类的子类,放在前面。

(2)消极处理
抛出异常 throw:手动抛出异常
throw 异常对象;
声明抛出异常 throws:一般用于声明方法,可能会发生异常!
public static void divide() throws Exception{

}

自定义异常
了解:继承Exception
2. IO技术

  1. File类
    概念:
    文件和目录路径名的抽象表示。

常用方法:
(1)创建:
1)文件 createNewFile()
2)目录 mkdir():创建单级目录 mkdirs():创建多级目录
(2)删除:delete()
(3)获取文件或文件夹属性
exists():测试此抽象路径名表示的文件或目录是否存在。
getAbsolutePath()
getName()
getParent()
getPath()
isDirectory()
isFile()
isHidden()
lastModified()
list()
(4)文件或文件夹操作
renameTo(File dest)
2) 字节流
(1) 字节输出流(写):OutputStream
实现类:

  1. FileOutputStream
    构造方法:
    FileOutputStream(String name)
    FileOutputStream(File file)
    FileOutputStream(String name, boolean append):append为true,则表示追加文本
    FileOutputStream(File file, boolean append) append为true,则表示追加文本

注意:如果追加文本,需要换行。Window操作系统中要用”\r\n”
常用方法:

  1. write(int b)写一个字节
  2. write(byte[] b)写一个字节数组
  3. write(byte[] b,int off,int len)写一个字节数组的一部分
  4. close() 关闭流
  5. BufferedOutputStream
    构造方法

常用方法

  1. ObjectOutputStream
  2. PrintStream
    构造方法

常用方法

(2) 字节输入流(读):InputStream
实现类:

  1. FileInputStream
    构造方法:
    FileInputStream(String name)
    通过打开与实际文件的连接来创建一个 FileInputStream ,该文件由文件系统中的路径名 name命名。
    FileInputStream(File file)
    通过打开与实际文件的连接创建一个 FileInputStream ,该文件由文件系统中的 File对象 file命名。
    常用方法:
    available()
    返回从此输入流中可以读取(或跳过)的剩余字节数的估计值,而不会被下一次调用此输入流的方法阻塞。
    read()
    从该输入流读取一个字节的数据。
    read(byte[] b)
    从该输入流读取最多 b.length个字节的数据为字节数组。
    read(byte[] b, int off, int len)
    从该输入流读取最多 len字节的数据为字节数组。
    close()
    关闭此文件输入流并释放与流相关联的任何系统资源。

  2. BufferedInputStream
    构造方法

常用方法
3. ObjectInputStream

  1. 字符流
    (1) 字符输出流(写):Writer
    实现类:
    OutputStreamWriter:转换流(字符流字节流)
  1. FileWriter

  2. BufferedWriter

  3. PrintWriter

(2) 字符输入流(读):Reader
实现类:
InputStreamReader:转换流(字节流字符流)

  1. FileReader

  2. BufferedReader

节点8:JDBC

  1. JDBC基本步骤
  1. 什么是JDBC?
  2. JDBC原理
  3. JDBC核心类
    参考网址:https://www.cnblogs.com/qlqwjy/p/8227665.html

有:DriverManager、Connection、Statement,和ResultSet!
(1)DriverManger(驱动管理器)的作用有两个:
  l 注册驱动: DriverManager.registerDriver(new Driver());
  l 获取Connection: DriverManager.getConnection(String url,String user,String password)
(2)Connection对象表示连接,与数据库的通讯都是通过这个对象展开的:
l Connection最为重要的一个方法就是用来获取Statement对象;
(1) Statement createStatement()
(2) PreparedStatement prepareStatement(sql);
(3)Statement是用来向数据库发送SQL语句的,这样数据库就会执行发送过来的SQL语句
  l void executeUpdate(String sql):执行更新操作(insert、update、delete等);
  l ResultSet executeQuery(String sql):执行查询操作,数据库在执行查询后会把查询结果,查询结果就是ResultSet;
(4)ResultSet对象表示查询结果集,只有在执行查询操作后才会有结果集的产生。结果集是一个二维的表格,有行有列。操作结果集要学习移动ResultSet内部的“行光标”,以及获取当前行上的每一列上的数据:
  l boolean next():使“行光标”移动到下一行,并返回移动后的行是否存在;
  l XXX getXXX(int col):获取当前行指定列上的值,参数就是列数,列数从1开始,而不是0。
2. JDBC-CRUD(Statement)
void executeUpdate(String sql)—执行增删改
ResultSet executeQuery(String sql)—执行查询
3. PreparedStatement
优点:(1)防止SQL注入。(2)效率更高。

【结论】:实际开发中,推荐使用PreparedStatement!!!
4. 自定义工具类
package com.ambow.dbwork;
import java.sql.;
/

JDBC连接数据库的工具类—自定义工具类【了解,自己能写】
//1. 获取数据库连接
//2. 释放资源
*/
public class JDBCUtils {
private static String DRIVERNAME = “com.mysql.jdbc.Driver”;
private static String URL = “jdbc:mysql://localhost:3306/db_book”;
private static String USER = “root”;
private static String PWD = “root”;

//1. 获取数据库连接
public static Connection getConnection(){
    Connection conn = null;
    //1.加载驱动
    try {
        Class.forName(DRIVERNAME);
        //2.获取数据库连接
        conn = DriverManager.getConnection(URL, USER, PWD);
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (SQLException e) {
        e.printStackTrace();
    }
    return conn;
}
//2. 释放资源
public static void closeAll(Connection conn, Statement stmt, ResultSet rs){
    if (rs != null){
        try {
            rs.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    if (stmt != null){
        try {
            stmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    if (conn != null){
        try {
            conn.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

}

  1. 数据库连接池
    (1) c3p0
    参考网址:https://blog.csdn.net/HeiSeHuoEr/article/details/89537080
    (2) druid-阿里【推荐】
    参考网址:https://blog.csdn.net/Dear_UU/article/details/89370491
    package com.ambow.jdbc;

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.pool.DruidDataSourceFactory;

import java.io.InputStream;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

public class DruidUtils {
//Druid德鲁伊,据说是魔兽世界中的一个角色,森林女神
public static DruidDataSource dataSource;//数据库连接池

//1.初始化Druid连接池
static {
    //第二种方式:使用软编码通过配置文件初始化
    try {
        Properties properties = new Properties();
        //通过类加载器加载配置文件
        InputStream inputStream = DruidUtils.class.getClassLoader().getResourceAsStream("druid.properties");
        properties.load(inputStream);
        //创建连接池
        dataSource = (DruidDataSource) DruidDataSourceFactory.createDataSource(properties);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

//2.获取连接
public static Connection getConnection() {
    try {
        return dataSource.getConnection();//从连接池中获取连接
    } catch (SQLException e) {
        e.printStackTrace();
    }
    return null;
}

//3.释放资源
public static void closeAll(Connection connection, Statement statement, ResultSet resultSet) {
    //释放resultSet
    try {
        if (resultSet != null) {
            resultSet.close();
        }
    } catch (SQLException e) {
        e.printStackTrace();
    }
    //释放Statement
    try {
        if (statement != null) {
            statement.close();
        }
    } catch (SQLException e) {
        e.printStackTrace();
    }
    //释放Connection
    try {
        if (connection != null) {
            connection.close();
        }
    } catch (SQLException e) {
        e.printStackTrace();
    }
}

}
6. Apache DBUtils工具类/Spring JDBCTemplate
参考网址:https://blog.csdn.net/HeiSeHuoEr/article/details/85157546

JDK8新特性:
lambda表达式
https://www.liaoxuefeng.com/article/001411306573093ce6ebcdd67624db98acedb2a905c8ea4000
全新的Stream API
https://www.liaoxuefeng.com/article/001411309538536a1455df20d284b81a7bfa2f91db0f223000
JDK11新特性解读
https://www.liaoxuefeng.com/article/0015419379727788f4e146b6fb1409dbaa7ad35db2560fc000

廖雪峰SQL教程
https://www.liaoxuefeng.com/wiki/001508284671805d39d23243d884b8b99f440bfae87b0f4000

你可能感兴趣的:(java)