java学习总结（二）
15.封装
//Java中面向对象三大特性
//1.封装
//2.继承
//3.多态
一、封装的基本概念
封装就是将不想或者不该告诉他人的东西隐藏起来，将可以告诉他人的东西公开（隐藏对象的属性和方法的实现细节，只公开接口）
二、属性的封装步骤
封装：对外隐藏特征和行为的内部实现细节。封装有利于程序的安全
a.将模型中的属性修饰符设置为private
b.为私有化的属性提供一个公开的赋值方法（set...）和一个公开的取值方法(get...)
private String name;
private int age;
//编写一个公开的赋值方法
public void setName(String name){
if(!name.equals("吴")){
this.name = "吴";
}else{
this.name = name;
}
}
//编写一个公开的取值方法
public String getName(){
return this.name;//this表示当前模型，可去掉
}
//如果对属性没有特殊的限制，可以采用自动化封装
//1.添加private
//2.右键- source - Generate Getters and Setters - 选择封装属性
private char gender;
public char getGender() {
return gender;
}
public void setGender(char gender) {
this.gender = gender;
}
三、封装的好处
a、隐藏实现的细节
b、只能通过规定方法访问数据
c、方便加入控制语句
d、方便修改的实现
16.静态(static)
一、静态变量
静态变量是指被static修饰的变量
静态变量属于某个类，被所有实例共享
可以通过类名访问或通过实例名访问
二、静态方法
静态方法：被static修饰的方法称为静态方法或类方法
三、静态代码块
静态代码块不存在于任何方法体中。
静态代码块只会被执行一次，它在Java虚拟机加载类时执行
四、Java中的静态概念static
1.静态变量也称为全局变量，意味着变量都是在内存里面运行的，不用再重新运算；非静态变量也称为局部变量
2.main方法就是一个静态方法
3.静态意味着在程序当中占有内存，所以调用属性和方法只能找在程序中占有内存的；静态如果要调用普通属性和普通方法，就需要实例化，因为实例化之后的对象会被分配内存
//实例化之后demo对象分配了内存空间地址2a139a55
StaticDemo demo = new StaticDemo();
4.普通方法中可以使用静态变量和静态方法
5.//常用的属性，方法可以设置为静态static。
//不常用的属性方法，最好放在模型当中，使用时实例化即可
//如果过多的使用static会导致内存加载过慢，导致程序性能降低
6.静态变量和普通变量运行先后顺序
静态变量初始化→静态代码块→初始化静态方法→初始化实例变量→代码块→构造方法
17.继承（this、super）
1.什么是继承？
继承即是提供子类沿用父类某些共同的行为和特征的一种方法。
2.继承的优势
继承可以减少代码的重复，有利于程序的扩展性
3.在Java中，继承只能单根继承，一个类只能继承一个类，不能继承多个
4.super和this关键字的使用
◦this ： 表示当前对象本身
◦super： 表示对父类或超类的引用
a.当子类和父类具有共同的属性时，使用this可以指代子类的属性，使用super可以指代父类的属性
b.this，super不能在静态环境（static）下使用，包括static方法和static语句块；可以在普通环境下使用。
5.super()和this()在使用时，需要注意一下几个方面的问题
a.this()表示调用当前类的无参数构造，super()表示调用父类的无参数构造；
b.每个子类构造方法中都会先隐含地调用super()，然后再执行本类中的代码块；
c.super()和this()都需要放在构造函数内的第一行；
d.super()和this()不能出现在同一个构造函数中；
e.this()和super()均不能在静态环境下（static）使用。包括static方法和static语句块
f.this()和super()也不能在普通环境下使用；
6.子类继承父类时需要使用extends
7.当父类中的某些属性用private修饰时，子类就不能获取父类中的这些属性
8.如果子类和父类拥有共同的属性和方法时，则会默认调用子类的属性和方法；如果子类没有属性和方法时，则会调用父类的属性和方法
9.当子类独有某一属性时，父类无法指代这一属性
Father son1 = new Son();//父类的引用指向子类的对象
//son.girl 因为girl是子类独有的属性，父类的引用无法指定
son1.work();
10.子类引用得到子类同名属性，父类引用得到父类同名属性（可以不断向前追溯某一属性）
11.在Java中，Object是所有类的父类，所有的Java类都直接或间接地继承了Object类,Object类一般是空值
12.继承具有传递性；一个类可以是子类，同时也可以是另外一个类的父类
18.Java中final关键字的使用
1.final修饰的类被称为最终类----不可被继承
public final class Demo4 {
}
//Demo4被final修饰，不能被继承
//public class Test4 extends Demo4 {
//
//}
2.final修饰的方法被称为最终方法-----不可被重写
3.final修饰的常量被称为常量-----不可被重新赋值
19.方法
一、概念
方法是类或对象的行为特征的抽象，方法是类或对象最重要的组成部分
二、形参和实参的概念
形参：全称为“形式参数”，是在定义方法名和方法体的时候使用的参数，用于接收调用该方法时传入的实际值
实参：全称为“实际参数”，是在调用方法时传递给该方法的实际值
注意：调用方法时给定的实际参数类型要与定义方法时形式参数类型相同，而且顺序也要相同。
Java中的方法不能独立存在，调用方法必须使用类或对象作为主调者。调用方法传入的参数称为实参。
四、构造方法
构造方法是用于初始化一个对象的内部状态的特殊方法
构造方法的特性
1、构造方法的主要作用是完成对类对象的初始化工作
2、在创建new()中一个类的新对象时，系统会自动调用该类的构造方法为新对象初始化
3、构造方法不能由编程人员显式地直接调用
4、构造方法没有返回类型
5、构造方法的方法名与类名相同
20.多态
一.多态是指当不同的对象收到相同的消息时产生的不同的动作。对外只有一个入口多种实现方式。即一个接口使用不同实例执行不同的操作。在Java中多态有两种表现形式，即：
、
方法重载(overload)与重写(override)
二.使用方法的重载来体现多态的特性
//原则是：使用同一的方法入口，通过不同的参数来体现不同的效果
//1.方法的重载体现在一个类当中
//2.他会考参数列表的不同（参数的个数，参数的类型）调用不同的方法
//3.重载跟方法的返回值没有关系
重载 overloading
1) 方法重载是让类以统一的方式处理不同类型数据的一种手段。多个同名函数同时存在，具有不同的参数个数/类型。重载是一个类中多态性的一种表现。
2) Java的方法重载，就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。调用方法时通过传递给它们的不同参数个数和参数类型给它们的不同参数个数和参数类型给它们的不同参数个数和参数类型来决定具体使用哪个方法, 这就是多态性。
3) 重载的时候，方法名要一样，但是参数类型和个数不一样，返回值类型可以相同也可以不相同。无法以返回型别作为重载函数的区分标准。
三、方法的重写
//1.方法的重写体现在父子类当中
//2.子类重写父类的需要遵循：
//a.方法名相同
//b.参数列表相同
//c.返回值相同
//d.子类的访问范围需要大于等于父类的访问范围
重写overriding
1) 父类与子类之间的多态性，对父类的函数进行重新定义。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。
在Java中，子类可继承父类中的方法，而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。方法重写又称方法覆盖。
2) 若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法。如需父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类。
3) 子类函数的访问修饰权限不能少于父类的；
四、重载与重写的区别
重载（overload） 重写（override）
方法的名称相同，参数个数，类型不同 方法名称、参数列表和返回类型完全与父类一致
方法的访问范围不要求 子类中提供的重写方法的范围不能比父类中的小
应用在一个类的内部 应用于子父类继承关系中
21、接口（interface）
一、什么是接口
接口就是某个事物对外提供的一些功能的申明 。
可以利用接口实现多态，同时接口也弥补了Java单一继承的弱点。
使用interface关键字定义接口。
一般使用接口声明方法或常量，接口中的方法只能是声明，不能是具体的实现。
二、如何使用接口
三、接口特性
1、//接口interface:是某个事物对外提供的一些功能的申明 (提供服务)
//接口没有构造方法
//接口中的属性是用 public、static、final修饰的
//接口中的方法是用 public、abstract修饰的
2、接口允许多继承
interface InterfaceDemo extends IFruit，IFarmer {
public int add(int x,int y);
}
3、//实现一个接口需要使用关键字implements
4、//接口不能被实例化
//接口的引用指向实现类的实例
x、接口中的属性不可重新赋值，因为属性 被static，final所修饰了
//public InterFaceDemo(); 接口没有构造方法?
//接口中的方法没有方法体，方法声明后以;结束
//如果不写访问修饰符，系统会默认为方法添加public修饰符
//由于接口没有方法体，系统会默认为方法添加abstract(抽象)
四、接口使用时机
如果一个类要使用分布在不同类中的属性和方法，需要借助接口实现多继承
如果一个类方法的参数需要引用另外一个类，且该方法参数引用的类型在不同的条件下会发生相应的改变，此时需要使用接口
五、抽象类与接口
抽象类 接口
抽象类有构造方法 接口没有构造方法
抽象类不允许多继承 接口允许多继承
有抽象方法的类一定是抽象类，抽象类不一定有抽象方法 接口中的属性是用public、static和final修饰的，接口的方法是用public、abstract修饰的
有抽象方法的类一定是抽象类，抽象类不一定有抽象方法
接口中的属性是用public、static和final修饰的，接口的方法是用public、abstract修饰的
22.抽象类+Object类
//Java中的Object类
//类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。
//所有对象（包括数组）都实现这个类的方法。
______________________________________________
一、什么是抽象类
抽象类的作用类似于“模板”，其目的是方便开发人员根据抽象类的格式来修改和创建新类
抽象类主要用于被继承，有利于程序的扩展
1、如果某个类被abstract修饰，则表明该类为抽象类。
2、如果某个方法被abstract修饰，则表明该方法为抽象方法。抽象方法不能有方法体。
3、一个类只要有一个抽象方法，那么该类就是抽象类；但抽象类可以有非抽象方法（普通方法）。
4、抽象类的具体子类必须实现抽象类所有的抽象方法。
二、抽象类的语法
定义抽象类
建立类继承于抽象类
//普通的方法（带有方法体）：可以根据业务选择是否重写
public void work(){
System.out.println("我每天工作很忙的，给我省心一点");
}
//抽象方法（被abstract修饰无方法体）：需要子类必须重写,便于子类进行扩展
public abstract void drink();
//抽象类中的属性默认情况下与父类设定的相同
三、抽象类的使用时机
如果几个类具备相同的行为和特征，可以抽取这些共同的行为和特征形成抽象类，抽象类是专用于继承的
四、小结
//被abstract修饰的类，成为抽象类
//抽象类的作用类似于“模板”，其目的是方便开发人员根据抽象类的格式来修改和创建新类
//抽象类主要用于被继承，有利于程序的扩展，主要使用于继承关系中的父类（超类）
//抽象类中不一定非要有抽象方法
//一个类中有抽象方法，那么这个类一定是抽象类
//抽象类中可以有普通方法（选择重写），和抽象方法（必须重写）
//抽象类中的抽象方法不能用private、final修饰
//抽象类不可被实例化
23.集合(Collection接口–List接口—ArrayList实现类、LinkedList实现类、Vector、Queue)
介绍Collection框架的结构
https://blog.csdn.net/coodlong/article/details/50835440
一、集合框架的概念与结构
1、Java中的集合框架是指一系列存储数据的接口和类，这些类和接口都位于java.util包中
2、 使用集合框架可以解决复杂的数据存储问题，Java中内置了丰富的集合框架
二、Collection
Collection是一种数据结构，是集合的最大接口，主要方法如下
返回类型 方法名称 描述
boolean add(Object o) 在集合末尾添加元素
int size() 返回集合列表中元素的个数
Object get(int index) 返回指定索引位置的元素，索引从0开始
boolean removeAll(Collectioncol) 删除集合中的所有元素
boolean contains(Object o) 判断集合中是否存在指定的元素
boolean remove(Object o) 从集合中删除元素
Object remove(int index) 从集合中删除指定索引位置的元素
void clear() 清除集合中的所有元素
Iterator iterator() 为Iterator接口实列化
三、List接口
返回类型 方法名称 描述
boolean add(Object o) 在集合末尾添加元素
int size() 返回集合列表中元素的个数
Object get(int index) 返回指定索引位置的元素，索引从0开始
boolean removeAll(Collection col) 删除集合中的所有元素
boolean contains(Object o) 判断集合中是否存在指定元素
boolean remove(Object o) 从集合中删除元素
Object remove(int index) 从集合中删除指定索引位置的元素
//list集合允许插入空元素
//clear()清除集合中的所有元素
//list.clear();//[]
List接口的常用方法
List接口的常用子类有：ArrayList和Vector
四、ArrayList用法类似于数组，且其容量可按需要动态调整，亦被称为动态数组
//集合相对于数组最大的特点在于：
//1.可以存储不同数据类型的数据
//2.使用集合不必考虑声明长度
//3.ArrayList集合底层使用Object数组来实现，也称为动态数组
//4.List集合能够按照存储元素的顺序保存，所以称为有序集合
//5.List集合可以存储重复的元素，使用不同下标来进行管理
//遍历list集合
//1.使用传统的for循环来遍历
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
System.out.println("---------增强for循环迭代----------");
//2.使用增强for迭代
for (Object obj : list) {
System.out.println(obj);
}
System.out.println("---------使用Iterator迭代器迭代----------");
//3.使用迭代器迭代
//通过list集合的iterator()获取得带器的实例iter
Iterator<Object> iter = list.iterator();
while(iter.hasNext()){ //hasNext()判断集合中有没有下一个元素
System.out.println(iter.next()); //next()获取这个元素
}
五、LinkedList表示链表的操作类，它同时实现了List和Queue接口。
LinkedList中的存放元素按照先进先出方式排序，LinkedList除实现上表中的方法外，还提供如下方法 ：
返回类型 方法名称 描述
void addFirst() 将指定元素插入此列表的开头
void addLast() 将指定元素添加到此列表的结尾
Object removeFirst() 移除并返回此列表的第一个元素
Object removeLast() 移除并返回此列表的最后一个元素
boolean add(Object o) 将指定的元素添加到列表中
//LinkedList中的存放元素按照先进先出方式排序
//LinkedList使用链表结构实现
//LinkedList因为链表结构实现添加，移除元素效率较高
//ArrayList查询遍历的效率较高
//将指定元素插入此列表的开头
link.addFirst("冰球");
//将指定元素添加到此列表的结尾
//link.add和link.addLast作用相似，add有一个布尔返回值
link.addLast("跳台滑雪");
//removeFirst()移除并返回此列表的第一个元素
Object obj1 = link.removeFirst();
//System.out.println(obj1);
//removeLast()移除并返回此列表的最后一个元素
Object obj2 = link.removeLast();
//System.out.println(obj2);
//将指定的元素添加到列表中
link.add(2,"高山滑雪");
//在当前的集合后方，添加一个集合到列表中
link.addAll(link1);
遍历
//使用增强for迭代
for (Object object : link) {
System.out.println(object);
}
//使用迭代器
//link.iterator();使用结合调用iterator()
//将迭代器的应用指向iterator()产生的实例
Iterator iter = link.iterator();
//在while()中调用hasNext()方法，判断集合中有误元素
while(iter.hasNext()){
//如果判断有元素则使用next()方法，获取该元素
iter.next();
}
六、Vector
Vector类能够实现可增长的对象数组；其大小可以根据需要增大或缩小
实例化Vector：
List list = new Vector()//list接口指向实现类的实例
ArrayList Vector
当元素存储达到指定容量时，自动增长为原容量的二分之一 当元素存储达到指定容量时，原容量自动增长一倍
非线程安全且性能更高 线程安全但性能较低
//Vector是一个线程安全的集合，性能相对较低
//一般使用在要求线程安全的场合当中，比如某些需要安全性特别高的系统当中
//在多线程的开发场景下，建议使用Vector，因为他是线程同步的
//ArrayList集合默认设计为线程争抢，可能会导致因为线程争抢出现异常
//用法基本同ArrayList相同
List list = new Vector();
七、Queue
//Java队列(Queue的常用方法)offer()
//offer,先进先出，只能移除队列的第一个元素，将新的元素加入到队伍最后
Queue queue = new LinkedList();
queue.offer("马化腾");
queue.offer("张朝阳");
queue.offer("李彦宏");
queue.offer("雷军");
queue.offer("丁磊");
System.out.println(queue);
//使用队列的第一个元素peek()
String name = (String)queue.peek();
System.out.println(name);
//使用队列的
//从队列头部移除元素poll()
queue.poll();
System.out.println(queue);
24.集合（Collection接口–Set接口-- HashSet 实现类、TreeSet 实现类）
//Java中的Set集合
//1.Set集合是一个无序集合
//2.Set集合不允许出现重复值
一、//Collection 接口 --> Set 接口 --> HashSet 实现类
Set<String> set = new HashSet<String>();
set.add("阿根廷");
set.add("巴西");
set.add("智利");
set.add("古巴");
set.add("哥伦比亚");
set.add("玻利维亚");
set.add("阿根廷");//重复添加的元素会覆盖之前的元素
set.add(null);//HashSet允许添加空元素
System.out.println(set);//排列无序，根据元素的哈希码排列顺序
System.out.println(set.size());//获取长度
System.out.println(set.contains("哥斯达尼加"));//判断是否存在
System.out.println(set.equals(set));//判断是否是同一个对象
System.out.println(set.hashCode());//获取哈希码
System.out.println(set.isEmpty());//判断是否为空
System.out.println(set.remove("阿根廷"));
System.out.println(set);
//Set结合的遍历
//使用普通循环，因为Set集合不存在索引，所以无法使用普通集合遍历
// for (int i = 0; i < set.size(); i++) {
// System.out.println(set.get(i));
// }
System.out.println("-------------增强for jdk1.8新语法------------");
//jdk1.8引入的新语法
set.forEach((Object obj) -> {
System.out.println(obj);
});
System.out.println("-------------增强for------------");
//使用增强for循环
for (Object object : set) {
System.out.println(object);
}
System.out.println("-------------Iterator------------");
//使用迭代器
Iterator<String> iter = set.iterator();
while(iter.hasNext()){
System.out.println(iter.next());
}
二、//Collection 接口 --> Set 接口 --> TreeSet 实现类
//TreeSet最大的特点就是能够实现自然排序
//按照数值的大小从小到大自然排序
Set<String> set = new TreeSet<String>();
set.add("鸿钧老祖");
set.add("太上老君");
set.add("元始天尊");
set.add("通天教主");
set.add("燃灯道人");
System.out.println(set);
Set<Double> set1 = new TreeSet<Double>();
set1.add(88.2);
set1.add(11.9);
set1.add(1.0);
set1.add(91.8);
set1.add(55.9);
System.out.println(set1);
//TreeSet的其他方法与HashSet基本一致，略
25.集合(Collection接口–Map接口–HashMap实现类、)
一、Map接口常用方法如下所示
返回类型 方法 描述
Object get(Object key) 根据key取得value
Object put(Obejct k,Object v) 向集合中加入元素
void clear() 清除Map集合
boolean isEmpty() 判断集合是否为空
boolean containsKey(Object object) 判断指定的key是否存在
boolean containsValue(Object value) 判断指定的value是否存在
Set keySet() Map中所有的key的集合
Object remove(Object key) 根据key删除对应的value
Collection values() 取出全部的value
int size() 获得集合的长度
Map接口的常用子类有：HashMap和Hashtable
二、HashMap
HashMap不允许出现重复键，但允许出现空键和空值
Map<String, String> map = new HashMap<String, String>();
//使用put方法来存储元素put(Object k,Object v)
map.put("姓名", "田");
map.put("电影", "天空之城");
map.put("城市", "武汉");
map.put("美食", "黄焖鸡");
map.put("兴趣", "动漫");
map.put("志向", "系统开发");
map.put("女友", "古典");
map.put("姓名", "陈");
map.put(null,"gameboy");
map.put("身体",null);
map.put(null,null);
//get(Object key)//根据KEY获取值
System.out.println("小田的兴趣是"+map.get("兴趣"));
//isEmpty()//判断是否为空
System.out.println(map.isEmpty());
//containsKey(Object object)//判断键是否存在
System.out.println(map.containsKey("小说"));
//containsValue(Object object)//判断值是否存在
System.out.println(map.containsValue("小姐姐"));
//remove(Object key)//根据键来移除元素
//System.out.println(map.remove("姓名"));
//size()//获取集合的长度
System.out.println(map.size());
//keySet()//Map中所有的key的集合 -- Set
System.out.println(map.keySet());
//values() //取出全部的value -- Collection
System.out.println(map.values());
//获得gameboy
System.out.println(map.get(null));//覆盖了
System.out.println(map.get("身体"));
//HashMap遍历键集合
System.out.println("-------------遍历键集合------------");
Set<String> set = map.keySet();//获取键集合
//jdk1.8增强for新语法
// set.forEach((Object obj)->{
// System.out.println(obj);
// });
//增强for遍历键集合
for (Object object : set) {
System.out.println(object);
}
//HashMap遍历值集合
System.out.println("-------------遍历值集合------------");
Collection<String> list = map.values();//获取值集合
//jdk1.8增强for新语法
// list.forEach((Object obj)->{
// System.out.println(obj);
// });
//使用迭代器遍历值集合
Iterator<String> iter = list.iterator();
while(iter.hasNext()){
System.out.println(iter.next());
}
//HashMap同时遍历键值集合
System.out.println("-------------同时遍历键值集合------------");
//方案1,现遍历键集，再遍历值集合
Set<String> set1 = map.keySet();//获取键集合
Iterator<String> iter1 = set1.iterator();
while(iter1.hasNext()){
//先获取键
String key = (String)iter1.next();
//再通过get方法获取key所对应的值得
System.out.println(key+"-"+map.get(key));
}
System.out.println("-------------同时遍历键值集合entrySet------------");
//方案2使用entrySet
Iterator<?> iter2 = map.entrySet().iterator();
while(iter2.hasNext()){
System.out.println(iter2.next());
}
三、HashTable
Hashtable不允许出现空键和空值
//HashTable实现同步集合（线程安全集合）效率偏低
//在非多线程的开发场景下，不建议使用
//HashTable的键和值都不可以为空
Map map = new Hashtable();
map.put("主公","刘备");
map.put("打手1","张飞");
map.put("打手2","关羽");
map.put(null,"诸葛亮");
map.put("钱庄",null);
//System.out.println(map.get("打手2")); //HashTable的键不可以为空
//System.out.println(map.get("钱庄")); //HashTable的值不可以为空
26、值传递+引用传递
//Java中值传递，引用传递的问题
public static int no = 10086;
public static String name = "移动客服";
public static Integer num = 9527;
public void change(int no, String name,Integer num,Student stu){
no = 10000;
name = "电信客服";
num = 9528;
stu.no = 10002;
stu.name = "pengsir2";
System.out.println(no+"号的"+name+","+num+"========传非引用数据类型");
System.out.println("我的编码改为"+stu.no+",工号改为"+stu.name+"====传递得一个对象");
}
public static void main(String[] args) {
Demo2 demo = new Demo2();
Student stu = new Student(666,"祝");
System.out.println("非引用初始值是"+no+","+name+","+num);
System.out.println("引用初始值是"+stu.no+","+stu.name);
demo.change(no,name,num,stu);
System.out.println("真的变了吗？");
//Java中的基础数据类型(byte,short,int,long,char,floot,double,boolean,以及他们的包装类)
//传递进方法进行运算后，其原有值不会发生改变---值传递
//但是除String的引用数据的类型则不会出现上述情况，值会发生改变---引用传递
System.out.println("我是"+no+"号"+name+"服务代号是"+num+"========值传递");
System.out.println("编号"+stu.no+"工号"+stu.name+"========引用传递");
}
27.泛型
//集合-泛型集合
//方法-泛型方法
//类-泛型类
一、泛型概述
泛型在建立对象时不指定类中属性的具体类型，而是在声明及实例化对象时由外部指定。泛型可以提高数据安全性
二、泛型应用
泛型的主要原理是声明类时通过标识表示类中某个属性的类型，或某方法的返回值及参数类型。此时声明和实例化类时只要指定需要的类型即可
泛型定义包括泛型类定义和泛型对象定义，其中泛型对象 定义的应用最为普遍
泛型对象定义：
类名称<具体类> 对象名称 = new 类名称<具体类>();
三、泛型集合
//泛型集合<String>
List<String> heroList = new ArrayList<String>();
heroList.add("刘备");
heroList.add("张飞");
heroList.add("关羽");
//泛型集合<Object>
List<Object> heroInfoList = new ArrayList<Object>();
heroInfoList.add("刘备");
heroInfoList.add(4);
heroInfoList.add(true);
Set<Book> bookset = new HashSet<Book>();
bookset.add(new Book("活着",45.5,"余华"));
bookset.add(new Book("三体",55.8,"刘慈欣"));
bookset.add(new Book("平凡的世界",35.5,"路遥"));
Map<String,Object> map = new HashMap<String,Object>();
map.put("list1", heroList);
map.put("list2", heroInfoList);
map.put("bookset", bookset);
四、泛型方法
//方法-泛型方法
//某一些方法可以不指定其数据操作的类型，
//为了提高这个方法的重用性，那么可以使用泛型来指定方法
//谁调用，谁传参，谁来决定这个方法操作的类型
//什么场景下需要设计泛型方法
//如果一个业务后某一个方法需要有不同类型的实行，那么可以不需要编写多个方法
//设计一个泛型方法就可以满足需求，避免的代码的冗余
public static <T> void printArray(T array[]){
//array我要传递进方法里的某个类型的数组，也是遍历的目标
//T表示在这个数组中，每一个元素的类型都是泛型的(未指定类型)
//t表示在这个数组中为每个元素起的临时变量名
System.out.println("数组中的元素分别是：");
for (T t : array) {
System.out.println(t);
}
}
public static void main(String[] args) {
System.out.println("使用int类型的数组");
Integer[] intArray = {11,22,33,44,55,66};
printArray(intArray);
System.out.println("使用String类型的数组");
String[] stringArray = {"老张","老李","老祝","老彭"};
printArray(stringArray);
}
五、泛型类
//类-泛型类
//使用场景：在不确定一个类需要返回什么数据类型结果，同时在业务上又要被重复使用的场合下编写
//泛型在建立对象时不指定类中属性的具体类型，PlayGame<T>
//而是在声明及实例化对象时由外部指定 。 PlayGame<String> play = new PlayGame<String>("《精灵宝可梦》");
//泛型可以提高类的数据安全性
public class PlayGame<T> {
private T object;
public PlayGame(T object) {
super();
this.object = object;
}
public void showType(){
System.out.println("当前类的类型是"+this.object.getClass().getName());
}
public T getObject() {
return object;
}
public void setObject(T object) {
this.object = object;
}
}
public class Test {
public static void main(String[] args) {
PlayGame<String> play = new PlayGame<String>("《精灵宝可梦》");
play.showType();
String game = play.getObject();
System.out.println("我小时候最喜欢玩的游戏就是"+game);
System.out.println("-------------------------------------");
PlayGame<Character> play1 = new PlayGame<Character>('牛');
play1.showType();
char game1 = play1.getObject();
System.out.println("小时候打拳皇97，那片小区我最"+game1);
}
}
28.String类的常用方法
一、基本概念
String类
在Java中，String并非基本数据类型，而是将字符串作为对象来处理。
java.lang.String类提供了一系列操作字符串的方法，使字符串的生成、访问和修改等操作更加容易和规范
二、创建String对象
String相关方法
方法名 功能描述
length() 返回此字符串的长度
subString(int beginIndex) 返回一个新字符串，它是此字符串的子字符串
valueOf(int i) 返回相应类型的字符串表示形式
compareTo(StringanotherStrin g) 比较两个字符串的大小
equals(Objects anObject) 比较两个字符串是否相等
concat(String str) 拼接字符串
charAt(int index) 返回指定索引处的 char 值
endsWith(String suffix) 测试此字符串是否以指定的后缀结束
format(String format, Object... args) 使用指定的格式字符串和参数返回一个格式化字符串
indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引
split(String regex) 根据给定的正规表达式的匹配来拆分此字符串
trim() 清除左右两端的空格
String str1 = "abc";
String str2 = "abc";
System.out.println(str1 == str2);//因为str1，str2都共享栈内存的空间所以他们相等
System.out.println(str1.equals(str2));
String str3 = new String("abc");
System.out.println(str1 == str3);//因为str3开辟了新内存地址所以和str1不等
System.out.println(str1.equals(str3));
str2 = str3;//让str2也引用了str3的地址，所以str2 == str3成立
System.out.println(str2 == str3);
System.out.println(str2 == str1);
System.out.println("-----------------String常用方法----------------");
String words = "我可以不同意你的观点，但是我誓死捍卫你说话的权利";
//length() 返回此字符串的长度
System.out.println(words.length());
//subString(int beginIndex) 返回一个新字符串，它是此字符串的子字符串
System.out.println(words.substring(4, 10));//从参数1开始，截取参数2的前一位
//System.out.println(words.substring(10, 4));//jdk1.7之后不允许此操作
System.out.println(words.substring(19));//如果只有一个参数的时候，将截取参数后面的字符
System.out.println(words.substring(3,6));
//valueOf(int i) 返回相应类型的字符串表示形式
int no1 = 9527;
String str5 = String.valueOf(no1);
String str6 = Integer.toString(no1);
System.out.println(str5);
System.out.println(str6);
//compareTo(String anotherString)比较两个字符串的字符编码差值,返回int
String name = "小明";
System.out.println(name.compareTo("丰润"));
//equals(Objects anObject)比较两个字符串是否相等
//0oO,1l之类的比对问题，需要注意
System.out.println("1".equals("l"));
//concat(String str) 拼接字符串
String str7 = "红海行动";
String str8 = "军事题材";
System.out.println(str7+str8);
System.out.println(str7.concat(str8));
//endsWith(String suffix) 测试此字符串是否以指定的后缀结束
String str9 = "胡萝卜";
String str10 = "白萝卜";
String str11 = "腌萝卜";
String str12 = "萝卜干";
System.out.println(str9.endsWith("萝卜"));
System.out.println(str10.endsWith("萝卜"));
System.out.println(str11.endsWith("萝卜"));
System.out.println(str12.endsWith("萝卜"));
//charAt(int index) 返回指定索引处的 char
String str13 = "有话好好说";
System.out.println(str13.charAt(4));
//indexOf(char ch) 返回指定字符在此字符串中第一次出现处的索引
System.out.println(str13.indexOf("好"));
//lastOndexOf(char ch) 返回指定字符在此字符串中最后一次出现处的索引
System.out.println(str13.lastIndexOf("好"));
//split(String regex) 根据给定的正规表达式的匹配来拆分此字符串
String students = "吴@汪@黄";
String[] names = students.split("@");
System.out.println(names);
System.out.println(names.length);
for (String string : names) {
System.out.println(string);
}
//trim() 清除左右两端的空格
//注意：字符串中间的空格无法清除
String str20 = " 共产主义接 班 人 ";
System.out.println(str20.length());
System.out.println(str20.trim().length());
29.String类、StringBuffer类和StringBuilder类
一、StringBuffer类和StringBuilder类
String的实例为不可变对象，一旦被创建就不能修改其值
StringBuffer的实例是可变对象。对StringBuffer进行修改时不会重新创建对象，线程安全
StringBuilder的实例是可变对象。对StringBuilder进行修改时不会重新创建对象，线程非安全
效率上 StringBuilder > StringBuffer >String （拼接大量字符串的情况下）
//对StringBuffer StringBuilder进行修改时不会重新创建对象，线程安全
//所以处理大量字符串的时，他们的效率远高于String
二、创建StringBuffer对象
语法 说明
StringBuffer() 创建一个空的可变字符串，起始容量为16个字符长度（默认长度）
StringBuffer(int index) 以起始长度为index创建一个空的可变字符串
StringBuffer(String str) 创建一个可变字符串，初始化为str
StringBuffer类相关方法
方法名 功能描述
append(String str) 将指定的字符串追加到此字符序列
insert(int offset, String str) 将字符串插入此字符序列中
setCharAt() 创建一个可变字符串，初始化为str
reverse() 将此字符序列用其反转形式取代
deleteCharAt(int index) 移除此序列指定位置的char
String str1 = new String("abc");
//String在处理多字符串连接的时使用+或concat方法，这样会导致内存使用率降低
//不断开辟新的空间，导致内存的分配的压力过大，效率降低
//str1+"123"+"456"+"9527"//每连接一次就会新开辟一次内存空间
//创建StringBuffer对象
//一般用于拼接大量字符串，特别是根据条件拼接sql语句（数据库查询语句）经常使用
StringBuffer str2 = new StringBuffer();//str2字符默认长度16,赋值时字符串长度不能超过16
StringBuffer str3 = new StringBuffer(20);//设置默认长度20
StringBuffer str4 = new StringBuffer("汪杰");
//str4 = str4 + "是一个";//StringBuffer对象不能和String对象连接
//append(String str) 将指定的字符串追加到此字符序列
//StringBuffer仅仅开辟一个空间采用在该空间(append)追加的方式添加字符串。提高内存的使用效率
str2.append("是一个").append("烟酒生").append("白酒一般喝一斤").append("抽烟一天一两根");
System.out.println(str2);
//
// //insert(int offset, String str) 将字符串插入此字符序列中
// str4.insert(2,"不");
// System.out.println(str4);
//
// //setCharAt(int index,char ch)//根据下标字符串中的字符
// str4.setCharAt(9, '。');
// System.out.println(str4);
//
// //reverse(); 将此字符序列用其反转形式取代
// StringBuffer str5 = new StringBuffer("清晨我上马");
// System.out.println(str5.reverse());
//
// //deleteCharAt(int index) 移除此序列指定位置的char
// str4.deleteCharAt(2);
// System.out.println(str4);
30.Date类+SimpleDateFormat类+Calendar类
一、Date类
Java在Date类中封装了有关日期和时间的信息
二、SimpleDateFormat类
SimpleDateFormat类是用于格式化和解析日期的具体类
格式化时间时，“H”表示24小时制，“h”表示12小时制。
//获取当前时间
//date对象默认获得的是以美国时区为标准的日期展示方法（操作系统当前时间）
Date date = new Date();
System.out.println("今天的日期是："+date);
//如果将这个日期转换成中国地区日期展示的格式呢？
//可以使用SimpleDateFormat类进行转换
//小写y获的年你，大写M获得月，小写d获取日，hh小时(12),HH(24小时)，mm分钟，ss秒钟
// G 年代标志符
// y 年
// M 月
// d 日
// h 时 在上午或下午 (1~12)
// H 时 在一天中 (0~23)
// m 分
// s 秒
// S 毫秒
// E 星期
// D 一年中的第几天
// F 一月中第几个星期几
// w 一年中第几个星期
// W 一月中第几个星期
// a 上午 / 下午 标记符
// k 时 在一天中 (1~24)
// K 时 在上午或下午 (0~11)
// z 时区
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
//调用SimpleDateFormat的格式化方法format将日期类格式化成字符串
String newDate = sdf.format(date);
System.out.println("格式化后的日期为："+newDate);
//将格式化后的时间字符串转换成Date类型，使用SimpleDateFormat的parse方法
date = sdf.parse(newDate);
System.out.println("将字符串再次转成日期类型："+date);
//从日期中获取年，月，日，时，分，秒
//一个方法被划上了中划线，表示不推荐时候，但是还是有效的
int year = date.getYear();
int month = date.getMonth();
//从date获取年月日的方法，现在是不推荐再使用了。
三、Calendar类
Calendar类比Date类更灵活，可以修改或设置日历
//Calendar类为抽象类，通过getInstance()方法返回一个Calendar对象。
//并通过getTime()方法获取时间 ?
Calendar calender = Calendar.getInstance();
Date date = calender.getTime();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
System.out.println("今天是："+sdf.format(date));
//调整日期到去年的今天,使用Calendar类的add方法来调整日期
calender.add(Calendar.YEAR, -1);
String lastYear = sdf.format(calender.getTime());
System.out.println("去年的今天是："+lastYear);
//通过Calendar类获取年月日时分秒
Calendar now = Calendar.getInstance();
//获取当前系统时间
Date date = now.getTime();
System.out.println("当前日期是："+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(date));
//通过get方法传入常量获取年
int year = now.get(Calendar.YEAR);
System.out.println("今年是"+year+"年");
//获取月份（月份在日期类中是从0-11计算的）
int MARCH = now.get(Calendar.MONTH);
System.out.println("已经进入"+(MARCH+1)+"月了");
//获取日期Calendar.DATE月中的天
int day1 = now.get(Calendar.DATE);
System.out.println("今天是"+day1+"号");
//获取日期Calendar.DATE月中的天
int day2 = now.get(Calendar.DAY_OF_WEEK)-1;
if(day2 == 0){
System.out.println("今天是礼拜天");
}else{
System.out.println("今天是礼拜"+day2);
}
//获取时，分，秒
int hour = now.get(Calendar.HOUR_OF_DAY);
int minute = now.get(Calendar.MINUTE);
int second = now.get(Calendar.SECOND);
System.out.println("时分秒为："+hour+":"+minute+":"+second);
}
31.异常处理
一、为什么需要异常处理
保证程序不因出现异常而中止运行，必须要对出现的异常进行处理
二、什么是异常
在Java编程中，异常是程序运行过程中发生的错误。若处理不当，它会终止程序的运行
三、异常的分类
Error类通常用于描述Java运行系统中的内部错误以及资源耗尽的错误等，一般是指JVM错误。
//在默认情况下抛出Error,Exception都是由Java虚拟机来完成的
//如果出现了Exception没有被主动处理，那么虚拟机将会处理这个异常
//打印出异常所在位置，异常类型，异常原因
public static void test0(int no1,int no2){
System.out.println(no1/no2);//如果没有主动捕获，JVM会处理异常，并且终止程序
System.out.println("end~!");//将不会运行
}
public static void test1(int no1,int no2){
try {//主动使用try-catch处理异常，程序会继续往下运行
System.out.println(no1/no2);
} catch (Exception e) {
System.out.println("除数不能为0");
}
System.out.println("end~!");
}
public static void test2(int no1,int no2){
try {//主动使用try-catch处理异常，程序会继续往下运行
System.out.println(no1/no2);
} catch (Exception e) {
System.out.println("除数不能为0");
}
String[] names = {"张三","李四","王五"};
System.out.println(names[3]);
System.out.println("end~!");
}
public static void test3(int no1,int no2){
try {//主动使用try-catch处理异常，程序会继续往下运行
System.out.println(no1/no2);
} catch (ArithmeticException e) {
System.out.println("除数不能为0");
}
try {
String[] names = {"张三","李四","王五"};
System.out.println(names[3]);
} catch (IndexOutOfBoundsException e) {
System.out.println("数组下标越界");
}
System.out.println("end~!");
}
Error类异常比较严重，仅靠修改程序本身不能恢复执行，被称为致命性异常
Exception类被称为非致命性异常，可以通过捕获处理后正常运行 ，分为两种：编译时异常和运行时的异常
//1.运行时异常：代码编写的语法通过，但是由于代码不够严谨，造成的各种问题，一般无需主动捕获，
//可以通过强化代码的严谨度来规避问题
//2.编译时异常：往往是一些不可预知的问题，或者是语法上不过问题。那么可以通过主动捕获异常来解决
RuntimeException异常又被称为运行时异常，即程序在运行阶段出现的异常；RuntimeException之外的异常又被称为编译时异常，即程序在编译阶段出现的异常
四、程序中常见的异常类型
异常类 说明
NullPointerException 访问Null对象的方法
IllegalArgumentException 接收非法参数
ClassNotFoundException 不能加载所需要的类
ArithmeticException 算术运算异常，如除数为零
ArrayIndexOutOfBoundsException 数组小于或大于数组的长度
InputMisMatchException 接收的数据类型与实际输入的类型不匹配
NumberFormatException 格式化数据异常
IOException 文件读写异常
//Java中常见的Excetipn
//throws 抛出异常不做处理，谁调用谁处理
//有些情况下，代码所在的层次从设计角度上没有权限处理异常，或则开发者在当前业务中无法处理该异常
//那么就可以选择throws的方式，将这个异常抛出。谁调用谁处理。
//throws 后面接异常名称需要方法之后。
public void test1() throws ParseException{
String date = "2018-3";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date newDate = sdf.parse(date);
System.out.println(newDate);
System.out.println("转换的是时间格式不正确~~！");
}
//1.尽量不要在主方法上抛出异常，也就是说，异常抛到主方法必须解决
//2.throws抛出异常，但是并不意味着处理了异常。当异常出现时，如果没有主动捕获
//系统将默认有JVM来处理异常，但是JVM处理异常之后，程序会中断！！！
public static void main(String[] args){
Demo4 demo = new Demo4();
//业务A
try {
demo.test1();
} catch (ParseException e) {
System.out.println("时间转换出现异常！");
}
//业务B
System.out.println("同事A的代码写的太好了~");
}
//小总结：什么情况下使用try-catch，什么情况下使用throws
//1.在必须处理异常的情况下（编译时异常，或者不确定的运行时异常）应该处理，以避免程序出现中断
//2.在当前的代码层次没有处理异常的权限时或者，实在无法处理的时候可使用throws抛出，交由其他层次的代码处理
//3.try-catch主动捕获，使用throws抛出是没有做处理的有中断程序的隐患
//throw 抛出异常后，程序终止
public class Demo5 {
public void checkAge(){
System.out.println("请输入您的年龄");
Scanner sc = new Scanner(System.in);
int age = sc.nextInt();
if(age <0 || age>= 150){
throw new RuntimeException("您输入的年龄不合法");
}else {
System.out.println("我今年"+age);
}
}
public static void main(String[] args) {
Demo5 demo = new Demo5();
demo.checkAge();
System.out.println("我今天真的这岁数了！");
}
六、自定义异常
（一）为什么需要自定义异常
在实际开发中，为了更加直观地描述异常信息，方便开发人员根据异常信息快速定位异常发生的位置，可以使用自定义异常
/有些异常是不是运行时异常，也不是编译时异常
//系统提供的异常往往在业务上，不能给我们的项目提供更多的服务
//而是根据业务来制定的自定义异常
（二）概念
开发者自己定义的异常，称为自定义异常
自定义异常继承自Exception
（三）如何创建自定义异常
七、在异常中需要了解的几个方法
//1.getMessage();获取异常原因，返回字符串
//2.toString();获取异常的信息，原因，返回字符串
//3.printStackTrace();打印异常信息，原因，所在位置，返回值void
public static void main(String[] args) {
Demo6 demo = new Demo6();
try {
demo.test(10, 0);//如果一旦出现异常，则系统会立即创建一个ArithmeticException的对象
} catch (ArithmeticException e) {
//System.out.println("除数不能为0");
System.out.println(e.getMessage());
System.out.println(e.toString());
e.printStackTrace();
}
八、异常使用细节
32.反射
一、Java中的反射机制
反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；
对于任意一个对象，都能够调用它的任意一个方法和属性；
这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
//通过反射的机制来获得实例
//Java中通过Class的forName方法可以找到类名所对应的类，这就是Java反射
try {
Class<?> stuClass1 = Class.forName("day9.part2.Student");
//也可以通过类型.class的方式反向的获得这个类
Class<?> stuClass2 = Student.class;
//通过实例.getClass()来反向获得这个类
Class<?> stuClass3 = new Student().getClass();
System.out.println(stuClass1);
System.out.println(stuClass2);
System.out.println(stuClass3);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
try {
Class<?> Student = Class.forName("day9.part2.Student");
//通过getMethods()获取方法列表
Method[] methods = Student.getMethods();
System.out.println("Student类中的方法如下：");
for (Method method : methods) {
System.out.println(method);
}
//通过getInterfaces()获取所有的实现接口
Class[] inters = Student.getInterfaces();
System.out.println("Student类中实现的接口有：");
for (int i = 0; i < inters.length; i++) {
System.out.println(inters[i]);
}
//通过getSuperclass()获取父类
System.out.println("Student类的父类是：");
Class father = Student.getSuperclass();
System.out.println(father);
//通过getConstructors()获取所有的构造方法
System.out.println("Student类所有的构造方法：");
Constructor[] cons = Student.getConstructors();
for (Constructor constructor : cons) {
System.out.println(constructor);
}
//Student stu = new Student();实例化生成对象
//通过newInstance()以反射的特性来获得实例
//反射机制多应用于发编译，或者底层框架的开发，快速产生多个类的实体
Student stu = (Student) Student.newInstance();
// stu.setId(27149);
// stu.setName("陈永仁");
stu.getMoney();
stu.coding();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}