一、基本类型
1.Boolean：返回值为 true 、 false。
Boolean a = true；
2.Char：返回值为字符。‘ ’
Char b = ‘a’;
3.数字：整形：byte<short<int<long。
Long l = 23223435345345L;(整数默认int型，超过int范围要加l)
浮点型：double（双精度：精确到16位）>float（单精度：精确到7位）。
例如：float f = 23.9f；
Double d = 23.9d；（d可选）
二.运算符
+、-、*、/、%、<、>、<=、>=、==、!
三、控制语句
If语句 for循环 swich-case while
1、跳出：
break：跳出循环
continue：跳出本次循环，继续下次循环
2、&&、&、||、|的区别
&&、||为短路运算，当左侧结果能够判断全部结果时，不在进行右侧运算执行
&、|为逻辑运算，左右两侧表达式在任何情况都会运算执行
3、switch
语法：
switch (表达式) {
case
表达式:
表达式;
……
case
表达式:
表达式;
……
default:
表达式;
……
}
特点：
只要case判断为真，则执行当前case对应代码块，并影响此case以下所有case的结果判定为真，并运行所对应的代码块
default，必运行
所以，case中的代码一般伴随着break进行结束掉整个switch代码
4、while
语法
while(boolean) {
表达式
}
特点：
与for极其相似，和for相比，缺少对“初始化语句”和“每次循环完毕后收尾语句”的支持
5、do- while
语法
do {
表达式;
}while(boolean);
特点：
基本与while一致，区别表现在，while是先判断再执行，do- while是先执行再判断
四、数组
Int[]
I = new int[6];//长度固定
五、集合
1、List接口
(1) ArrayList
① 核心方法：add、get
② List和数组互转
- List转数组
List<Integer> arrayList0 = new ArrayList<Integer>();
arrayList0.add(80);
arrayList0.add(90);
Integer[] is = new Integer[arrayList0.size()];
arrayList0.toArray(is);
- 数组转List
Integer[] is = {20, 30, 40};
List<Integer> asList = Arrays.asList(is);
③ List排序
- List元素通过实现Comparable接口，完成对比规则的实现集合中的实体类
public class PeopleBean implements Comparable<PeopleBean> {
private String code;
private String name;
private int age;
private String sex;
@Override
public int compareTo(PeopleBean o) {
if(this.getAge()> o.getAge()){
return -1;
}else if(this.getAge() < o.getAge()){
return 1;
}else{
return 0;
}
}
}
Collections排序类
List<PeopleBean> peopleList = new ArrayList<PeopleBean>();
peopleList.add(new PeopleBean("0000", "张三", 20, "男"));
peopleList.add(new PeopleBean("0001", "李四", 30, "男"));
peopleList.add(new PeopleBean("0002", "王五", 10, "男"));
Collections.sort(peopleList);
- 通过实现Comparator接口，完成排序格则的实现集合中的实体类
public class PeopleBean2 {
private String code;
private String name;
private int age;
private String sex;
public PeopleBean2(String code, String name, int age, String sex) {
this.code = code;
this.name = name;
}
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
public String getName() {
return name;
}
}
Comparator实现方式之一（传统类）
Comparator实现类
public class PeopleBean2Comparator implements Comparator<PeopleBean2> {
@Override
public int compare(PeopleBean2 o1, PeopleBean2 o2) {
if(o1.getAge() > o2.getAge()){
return 1;
}else if(o1.getAge() < o2.getAge()){
return -1;
}else{
return 0;
}
}
}
Collections排序类
List<PeopleBean2> peopleList = new ArrayList<PeopleBean2>();
peopleList.add(new PeopleBean2("0000", "张三", 20, "男"));
peopleList.add(new PeopleBean2("0001", "李四", 30, "男"));
Collections.sort(peopleList, new PeopleBean2Comparator());
Comparator实现方式之二（匿名类）
List<PeopleBean2> peopleList = new ArrayList<PeopleBean2>();
peopleList.add(new PeopleBean2("0000", "张三", 20, "男"));
peopleList.add(new PeopleBean2("0001", "李四", 30, "男"));
Collections.sort(peopleList, new Comparator<PeopleBean2>(){
@Override
public int compare(PeopleBean2 o1, PeopleBean2 o2) {
if(o1.getAge() > o2.getAge()){
return 1;
}else if(o1.getAge() < o2.getAge()){
return -1;
}else{
return 0;
}
}
});
④ ArrayList、LinkedList的区别
ArrayList是Array(动态数组)的数据结构，属于线性表中的顺序结构的线性表，物理表现即为内存为连续的空间
LinkedList是Link(链表)的数据结构，双向链表，即可以从头遍历到尾，也可以从尾遍历到头
面试：
⑤ ArrayList、LinkedList的性能区别
-
ArrayList查询快，插入慢，插入的越靠前，越慢
-
LinkedList插入快，查询慢，查询的越靠后，越慢
2、Map接口
(1) HashMap
① 核心方法：put、get
② Map遍历，map自身不支持遍历，需要通过其他集合进行中转：
③ 通过entrySet方法获取Entry（key和value的实体类）的set集合
- 通过方法获取map的set集合
Map<String,String> hashMap = new HashMap<String, String>();
hashMap.put("0000","张三");
hashMap.put("0001","张三1");
Set<Entry<String,String>> entrySet = hashMap.entrySet();
- 遍历set之一：通过迭代器（Iterator）遍历set
Iterator<Entry<String,String>> iterator = entrySet.iterator();
while(iterator.hasNext()){
Entry<String,String> next = iterator.next();
System.out.println(next.getKey());
System.out.println(next.getValue());
}
- 遍历set之二：通过for遍历set
for(Entry<String,String> entry: entrySet){
System.out.println(entry.getKey());
System.out.println(entry.getValue());
}
④ 通过keySet方法获取key的set集合
Set<String> keySet = hashMap.keySet();
for(String key: keySet){
System.out.println(key);
System.out.println(hashMap.get(key));
}
⑤ 通过values方法获取value的Collection集合
Collection<String> values = hashMap.values();
for(String value: values){
System.out.println(value);
}
六、面向对象 面试：特征：继承、封装、多态（方法的重写和重载）
1.类：包括变量（成员变量）和块
块中包括没名字的块{}、静态块static{}、方法名（）{}（简称方法）
面试：Java找方法的依据方法名+参数。
重载：方法名一样，参数不同
2.构造方法
（1）构造方法定义：
无返回值
方法名字与类名相同
（2）特点：
①与类名相同
②没有返回值
③不能被调用
④构造方法可以相互调用，但需要this，且必须写在方法首行
⑤类在无构造方法时，会自动补充一个无参的构造方法
⑥构造方法可重载
⑦构造方法在生成对象时被执行
（3）new关键词：new后边紧跟构造方法
new关键词的作用
①申请内存②生成对象③返回对象地址
（4）this：①当前对象②this（）构造方法，调用本类中的成员方法（只能调用一个构造方法且必须在首行）
七、继承（extends）
1.语法表示为: class 子类 extends 父类{}
//父类
public class A {
//有许多方法
B继承A, A是B的父类，B是A的子类
}
//子类继承父类
public class B extends A {
}
2.子类拥有父类的属性和方法，并且子类可以拓展具有父类所没有的一些属性和方法
3.继承注意点
1）成员变量和方法
① 子类只能继承父类的所有非私有的成员变量和方法。可以继承public
protected 修饰的成员，不可以继承private修饰的。
② 面试：
本类 本包的类 子类 非子类的外包类
public 是 是 是 是
protected 是 是 是 否
default 是 是 否 否
private 是 否 否 否
③ 对于子类可以继承父类中的成员变量和成员方法，如果子类中出现了和父类同名的成员变量和成员方法时，父类的成员变量会被隐藏，父类的成员方法会被覆盖。子类生成的对象是先调用子类的方法。需要使用父类的成员变量和方法时，就需要使用super关键字来进行引用。
2）构造器
①子类不能继承获得父类的构造方法，但是可以通过super关键字来访问父类构造方法。
②在一个构造器中调用另一个重载构造器使用this调用完成，在子类构造器中调用父类构造器使用super调用来完成。
④ super 和 this 的调用都必须是在第一句，否则会产生编译错误，this和super只能存在一个。
④如果父类有无参构造时，所有构造方法（包含任意有参构造）自动默认都会访问父类中的空参构造方法。（自带super();）
3）初始化顺序
面试：
父类静态的块
子类静态的块
父类的成员变量初始化
父类的块
父类构造方法
子类的成员变量初始化
子类的块
子类构造方法
八、接口（interface）一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。
1.接口定义和声明
[修饰符] interface 接口名 {
[public] [static] [final] 常量;
[public] [abstract] 方法;
}
修饰符：可选参数public，如果省略，则为默认的访问权限；
接口名：指定接口的名称，默认情况下，接口名必须是合法的Java标示符，一般情况下，要求首字符大写；
方法：接口中的方法只有定义而不能有实现
2.接口的实现：
Java实现接口，用implements：
[修饰符] class <类名> [implements 接口列表]{
}
3.接口的特点
就像一个类一样，一个接口也能够拥有方法和属性，但是在接口中声明的方法默认是抽象的。（即只有方法标识符，而没有方法体）。
4.接口语法
.接口中只能出现常量和抽象方法，不能定义私有的方法
.接口其实是一个特殊的抽象类，特殊在接口是完全抽象的
.接口中没有构造方法，接口也无法实例化
.接口和接口之间可以多继承
.一个类可以实现多个接口，这里的实现等同于继承
.一个非抽象的类实现接口，需要将接口中所有方法实现/重写/覆盖
5.单继承多实现
九、抽象类（abstract）
1.当父类的某些方法不确定时，可以用abstract关键字来修饰该方法[抽象方法]，用abstract来修饰该类[抽象类]
抽象类是为了把相同的但不确定的东西的提取出来，为了以后的重用。定义成抽象类的目的，就是为了在子类中实现抽象类。
2.用abstract修饰的类，即抽象类；用abstract修饰的方法，即抽象方法。
3.抽象方法不能有方法主体。例如：public abstract int add（）；
4.抽象类中不一定要包含abstrace方法。也就是抽象类中可以没有abstract方法。一旦类中包含了abstract方法，那类该类必须声明为abstract类。
根类：Object
父类的变量 = 子类的对象
十、String
1、String:
1.1、String不可变、不可被继承
1.2、String直接书写字符串（如下），生成的字符串，存储在栈中。
对象生成过程：首先在栈中寻找是否存在此字符串对象，如果不存在，则生成字符串对象并返回对象地址，如果存在，则直接返回字符串对象地址
String peopleName = "张三";
1.3、String通过new生成的对象，存储在堆中。
String peopleName = new String("张三");
1.4、如下书写的字符串，会生成“张三”、“李四”、“张三李四”
String peopleName = "张三";
peopleName = peopleName + "李四";
1.5、如下书写的字符串，在java虚拟中（jvm）中，会做特殊优化处理，最终仅生成一个字符串对象
String peopleName = "张三"
+ "张三张三"
+ "张三张三"
+ "张三张三";
1.6、如下书写的字符串，会在栈中生成“张三”字符串对象，会在堆中生成“张三”字符串对象，共生成出两个对象
String peopleName = new String("张三");
1.7、String常用方法：
方法名称 使用频率 注释
contains 低 //是否包含
endsWith 略低 //是否以此后缀结尾
equals 高 //字符串是否相同
equalsIgnoreCase 低 //字符串是否相同（忽略大小写）
getBytes 中（被迫使用） //返回字符串转换的字节
getChars 低（被迫使用） //返回字符串转换的字符
indexOf 高 //返回参数所在字符串中第一次出现的index
lastIndexOf 中（看心情） //返回参数所在字符串中第一次出现的index（从后开始找）
length 高 //字符串长度（字符个数）
replace 中 //替换
split 高 //分割字符串
substring 高 //截取字符串
toCharArray 低 //返回字符串转换的字符
toLowerCase、toUpperCase 中 //大小写转换
trim 中 //去除字符串先后空格
valueOf 看心情（使用场景高） //其他类型数据转换为字符串
注意：StringBuider、StringBuffer：是两个可变字符串类，其区别：StringBuider线程不安全；StringBuffer线程安全
1.8、String、StringBuider、StringBuffer：性能对比：
1.8.1：在字符串变化不频繁的前提下
String>StringBuider>StringBuffer
1.8.2：在字符串变化频繁的前提下
StringBuider>StringBuffer>String
面试： StringBuffer（线程安全、慢） 和 StringBuilder（线程不安全、快）长度可变
十一、I/O流
字节流：FileInputStream读入 和 FileOutputStream写出
适用于：二进制文件 图片、视频
字符流：InputStreamReader读入 和 OutputStreamWriter写出
适用于：纯文本
BufferInputStream BufferOutputStream
ObjectInputStream ObjectOutputStream
管道：getChannel（）其中的两个方法 transferTo（给谁）和transferFrom（从谁那拿）
1、FileChannel
(1) 文件管道（不分输入管道和输出管道）
① transferFrom：从指定管道获取数据
FileInputStream fileInputStream = new FileInputStream("D://新建文本文档.txt");
FileOutputStream fileOutputStream = new FileOutputStream("D://新建文本文档2.txt");
FileChannel fileInputStreamFileChannel = fileInputStream.getChannel();
FileChannel fileOutputStreamFileChannel = fileOutputStream.getChannel();
fileOutputStreamFileChannel.transferFrom(fileInputStreamFileChannel,0,fileInputStream.available());
② transferTo：推给指定管道数据
FileInputStream fileInputStream = new FileInputStream("D://新建文本文档.txt");
FileOutputStream fileOutputStream = new FileOutputStream("D://新建文本文档2.txt");
FileChannel fileInputStreamFileChannel = fileInputStream.getChannel();
FileChannel fileOutputStreamFileChannel = fileOutputStream.getChannel();
fileInputStreamFileChannel.transferTo(0, fileInputStream.available(),fileOutputStreamFileChannel);
2、传统文件拷贝
FileInputStream fileInputStream = new FileInputStream("D://新建文本文档.txt");
FileOutputStream fileOutputStream = new FileOutputStream("D://新建文本文档2.txt");
byte[] bs = new byte[16];
int size = 0;
while((size = fileInputStream.read(bs)) != -1) {
fileOutputStream.write(bs,0, size);
}
fileOutputStream.flush();
注意：写完要刷一下
十二、多线程Thread
实现方式（两种）①implements Runnable()（资源共享）②extends Thread（资源不共享）
1、Thread：多线程核心工具类：申请线程资源、启动线程、控制线程（睡眠、等待、唤醒等）
(1) 方法start：启动线程
2、Runnable：线程业务类接口
(1) 方法run()：实现此方法，业务的核心方法
3、多线程实现方式一：Runnable实现方式
(1) 实现Runnable接口：
public class Business implements Runnable {
public void run() {
System.out.println("我是多线程，哈哈哈哈哈！");
}
}
(2) 启动代码：依赖Thread工具类
Business business = new Business();
Thread thread = new Thread(business);
thread.start();
System.out.println("我的代码执行完了，哈哈哈哈！");
4、多线程实现方式二：Thread实现方式
(1) 继承Thread：
public class Business2 extends Thread{
@Override
public void run() {
System.out.println(this.getName()+ ":我是第二个多线程，哈哈哈哈哈！");
}
}
(2) 启动代码
public static void main(String[] args) throws IOException {
Business2 business2 = new Business2();
business2.start();
System.out.println("我的代码执行完了，哈哈哈哈！");
}
5、Thread线程控制主要方法：
(1) sleep(int)：睡眠，输入等待时长（单位：毫秒）
等待时长过后，进入就绪状态，等待cpu（JVM）宰割
(2) yield()：线程中碰到此方法，直接进入就绪状态，等待cpu（JVM）宰割
join()：在线程中碰见调用某线程的join()方法，当前方法进入等待状态，直到某线程直线完，再进入就绪状态。
6. 线程池
(1) 概念：线程池是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，不会因为反复创建线程而消耗太多资源。
(2) 常用的线程池：
newFixedThreadPool(int nThreads) 创建固定数目线程的线程池
newCachedThreadPool()创建一个可缓存的线程池，调用execute 将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。
(3) 定时任务（Timer任务调度器）
public class Test extends TimerTask {
public void run(){
System.out.println("任务开始时间：" + new Date());
try {
Thread.
sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("任务结束时间：" + new Date());
}
}
启动代码：
Timer timer = new
Timer();
timer.scheduleAtFixedRate(new Test(), new Date(), 2000);
注释：scheduleAtFixedRate----安排指定的任务在指定的时间开始进行重复的固定速率执行
7, 线程安全
(1) 出现线程安全问题的原因：线程安全问题都是由全局变量及静态变量引起的，若有多个线程同时执行写操作，可能会改变变量的值，影响操作结果。
(2) 解决方法：线程安全处理Synchronized（线程同步）
- 同步代码块：
在代码块声明时 加上synchronized，格式如下：
synchronized (锁对象) {
可能会产生线程安全问题的代码
}
注意：同步代码块中的锁对象可以是任意的对象；但多个线程时，要使用同一个锁对象才能够保证线程安全。
- 同步方法：
在方法上 加上synchronized，格式如下：
public synchronized void
method(){
可能会产生线程安全问题的代码
}
注意：同步方法中的锁对象是 this
(3) 线程之间的通信：
多个线程处理同一个资源时，可以通过等待唤醒机制使各个线程之间能有效的利用资源：
方法有：
wait（） :等待，将正在执行的线程跳入就绪状态中，并存储到线程池中。
notify（）：唤醒，唤醒线程池中被wait（）的线程，一次唤醒一个，而且是任意的。
notifyAll（）： 唤醒全部，可以将线程池中的所有wait() 线程都唤醒。
面试笔试：
(1) 启动一个线程是run()还是start()？区别是什么？
区别：
start： 启动线程，并调用线程中的run()方法
run : 执行该线程对象要执行的任务
(2) sleep()和wait()的区别？
sleep() 不释放锁，在休眠的时间内不能被唤醒；
wait() 释放锁，在等待的时间内能唤醒。
十三、
1、强转
(1) 引用类型的强转，转变的仅仅是变量的类型，所以强转的规则，需要遵循变量的对象的规范：变量类型>对象类型，即：变量类型满足条件，为对象类型或者对象类型的父类（包括接口）
（2）内部类：可以将一个类的定义放在里另一个类的内部，这就是内部类
/**
* 我是一个外部类（外部是相对内部而言）
*/
public class Outer{
/**
* 我是一个内部类
*/
class Inner{
//...
}
}
2、三目运算
(1) 语法：boolean ? 值 : 值
① 三目运算代码：
int age = 10;
String type = (age >= 18 ? "未成年人" : "成年人");
System.out.println(type);
② If相同作用代码
int age = 10;
String type = null;
if(age >= 18){
type = "未成年人";
}else{
type = "成年人";
}
System.out.println(type);
3、可变参数：参数本身实际是个数组集合
(1) 特点：
① 传参时更灵活
② 可变参数只能放到所有参数最后
③ 可变参数只能有一个
④ 优先级低：重载时可能会出现方法重叠（同时有两个方法满足调用需求），此时定参方法比可变参数的方法优先级高
方法定义
public class Test {
public long add(String temp, int... is){
long sum = 0;
for(int i : is){
sum += i;
}
return sum;
}
}
方法调用1
Test test = new Test();
int[] is = {20, 30, 5, 40};
long sum = test.add("哈哈哈", is);
方法调用2
Test test = new Test();
sum = test.add("哈哈哈", 30, 20, 50);
System.out.println(sum);
4、Math类
(1) Random方法
(2) 常见数学运算方法
5、Random类
6、递归
随机抽取类
public class Test9 {
private String[] strs = {"石志慧", "陈志飞", "王文娟", "王晓吉", "毛泽璞", "刘鹏飞", "罗晋", "郝超", "李洋", "贾江涛"};
public String getRandomName(){
Random random = new Random();
int nextInt = random.nextInt(strs.length);
String name = strs[nextInt];
if(name == null){
return getRandomName();
}
strs[nextInt]=null;
return name;
}
public int getNamesSize(){
return strs.length;
}
}
抽取测试类
public class Test10 {
public static void main(String[] args) {
Test9 test9 = new Test9();
for(int i=0; i<test9.getNamesSize(); i++){
String randomName = test9.getRandomName();
System.out.println(randomName);
}
}
}
十四、日期
1、Date类
(1) 常用方法
① 构造方法Date()
② 返回毫秒值getTime()：返回自1970年1月1日到当前Date时间点的毫秒数
2、SimpleDateFormat类
(1) Parse，字符串转日期
String beginDate = "2019/07/31 23:23:23";
SimpleDateFormat simpleDateFormat2 = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
Date parse = null;
try{
parse = simpleDateFormat2.parse(beginDate);
System.out.println(parse);
}catch (ParseException e) {
}
(2) Format，日期转字符串
Date date = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy哈MM月dd日 HH时mm分：ss秒SSS毫秒");
String format = simpleDateFormat.format(date);
System.out.println(format);
(3) 日期格式
yyyy年MM月dd日 HH时（24小时）hh时（12小时）mm分ss秒SSS毫秒
3、Calendar类
(1) Calendar.getInstance()：获取当前日历
(2) setTime（）传入Date类型对象，设置日历当前时间
cal.setTime(new Date());
(3) add（）操作日历时间
cal.add(Calendar.DATE,-1);减一天
cal.add(Calendar.HOUR,-1);减一小时
cal.add(Calendar.MONTH,-1);减一个月
cal.add(Calendar.MINUTE,-1);减一分钟
(4) getTime()获取日历当前时间
Date time = cal.getTime();
(5) get()获取日历当前时间对应（年月日星期等）时间数据
// 获取当前时间在本年中的位置
System.out.println(cal.get(Calendar.DAY_OF_YEAR));
// 获取当前时间在本星期中的位置
System.out.println(cal.get(Calendar.DAY_OF_WEEK));
// 获取当前时间在本月中的位置
System.out.println(cal.get(Calendar.DAY_OF_MONTH));
十五、异常
1、Throwable：异常与错误的父类
2、Error：错误
3、异常：当方法中出现无法处理的情况时，可抛出异常，给调用者，与返回值的角色类似。目的：希望调用处理
(1) Exception：所有异常的父类
(2) 异常处理方式，两种
① Try-catch抓取异常
-
Try块为抓取异常 -
Catch块为处理异常：catch块可为多个，并且按自上而下的顺序对应异常处理，父异常可抓取子异常，所有在处理多个异常并存在父子关系时，需要把子异常放到前边，防止父异常捷足先登，导致子异常处理块失效 -
Finally为强制执行块：不管是否有异常，Finally块中的代码强制执行。
如果碰到代码中有返回值的情况下，先挂起返回结果，再执行Finally块中的代码，最后执行挂起的返回代码
public int test() {
int i = 0;
try {
add2(0,0);
add(20,20);
return i;
}catch (ParseException e) {
e.printStackTrace();
}catch (Exception e) {
e.printStackTrace();
}finally {
i = i + 30;
System.out.println("test方法：" + i);
}
return 0;
}
② Throws抛出异常：可抛多个异常，用“,”逗号隔开
public int add2(int a, int b) throws ParseException, Exception {
if (a == 0 || b == 0) {
throw new Exception();
}
return 0;
}
③ Throw：在声明异常（new异常对象）时，需要Throw把声明的异常对象抛出去，纳入异常的体系中。
throw new ParseException(null, b);
十六、枚举、泛型、反射
1、枚举：枚举本质为类，枚举值为当前类的对象，并赋值给静态常量。
(1) 枚举额外提供了返回枚举值集合的方法
(2) 案例
① 枚举代码
public enum SexEnum {
NAN("0000", "男"), NV("0001", "女"), UNKNOWN("0002", "未知");
private String code;
private String name;
private SexEnum(String code, String name) {
this.code = code;
this.name = name;
}
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
②
对应传统类代码
public class SexBean {
public final static SexBean NAN = new SexBean("0000", "男");
public final static SexBean NV = new SexBean("0001", "女");
private String code;
private String name;
private SexBean(String code, String name) {
this.code = code;
this.name = name;
}
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
③
使用案例及遍历
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String inString = scanner.next();
if(SexBean.NAN.getCode().equals(inString)){
System.out.println(SexBean.NAN.getName());
}else{
System.out.println(SexBean.NV.getName());
}
if(SexEnum.NAN.getCode().equals(inString)){
System.out.println(SexEnum.NAN.getName());
}else{
System.out.println(SexEnum.NV.getName());
}
SexEnum[] values = SexEnum.values();
for(SexEnum sexEnum : values){
System.out.println(sexEnum.getCode() + ":" + sexEnum.getName());
}
}
2、泛型：规定类中使用的类型的变量，可通过extends关键词限定泛型变量指定类型的范围
(1) 类泛型
类泛型定义
public class MyList<A extends Comparable> {
private A[] temps;
public A[] add(int i, A temp){
temps[i] = temp;
return temps;
}
public A get(int i){
return temps[i];
}
public A[] getTemps() {
return temps;
}
public void setTemps(A[] temps) {
this.temps = temps;
}
}
SexBean类（案例：业务依赖类，可以此类作为传入泛型。注意：泛型对要求，A extends Comparable）。自行做调整。
public class SexBean{
private String code;
private String name;
public SexBean(String code, String name) {
this.code = code;
this.name = name;
}
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
测试方法
public static void main(String[] args) throws IOException {
MyList<String> myList = new MyList<String>();
myList.setTemps(new String[10]);
myList.add(0, "男");
System.out.println(myList.get(0));
}
(2) 方法泛型
方法泛型
public <A> List<A> ArrayToList(A[] temps){
List<A> list = new ArrayList<A>();
if(temps != null){
for(A a : temps){
list.add(a);
}
}
return list;
}
测试方法
public static void main(String[] args) throws IOException {
MyList2 myList = new MyList2();
String[] strs = {"abcd4", "abcd3", "abcd2", "abcd1"};
SexBean[] sexArray = null;
List<SexBean> list = myList.ArrayToList(sexArray);
}
十七、Sql
1.Sql
(1) 简单查询语句
select 查询字段[, 查询字段]... from 表名 [where 条件字段 = 条件值 ]
① 案例
select people_code,
people_name from people_info where (people_age = 20 or people_name = '张三') and
people_age = 30
select
people_code as code, people_name from people_info where people_age > 30
(2) 新增语句
insert into 表名[(字段名称[,字段名称])] values(字段值[, 字段值])
① 案例
insert into people_info(people_code, people_name,
people_age) values('0000', '李四', 20)
insert into people_info values('0000', '李四')
(3) 简单修改语句
update 表名 set 字段名称 = 值[, 字段名称 = 值] [where 条件字段 = 条件值 ]
① 案例
update people_info set people_age = 30, people_name = '张三' where people_code = '0002'
(4) 删除语句
delete from 表名 [where 条件字段 = 条件值 ]
delete from people_info where people_code = '0002'
2、JDBC：java提供的连接数据库的规范接口
(1) JDBC连接步骤
① 加载驱动
Class.forName("com.mysql.jdbc.Driver")
② 连接数据库，获取连接
Connection connection =DriverManager.getConnection("jdbc:mysql://localhost:3306/abcde", "root", "123");
③ 通过连接对象获取sql执行对象：Statement接口实现对象
Statement statement = connection.createStatement();
④ 通过Statement对象操作数据库：
- 主要方法：executeQuery（查询）、execute（执行：新增、修改、删除）
ResultSet resultSet = statement.executeQuery(sql);
⑤ 解析ResultSet
jdbc查询结果集（重点：索引index是1开始，并不是传统的0开始）：
while(resultSet.next()) {
String people_code = resultSet.getString(1);
String people_name = resultSet.getString("people_name");
System.out.println(people_code + ":" +people_name);
}
564
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
