一、基本类型
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);
}