java学习笔记
涨知识1：制作项目的文档
Scanner 扫描仪 input 输入
习惯1：
在程序中描述业务实体的类，我们称为：实体类
如：Student、Goods、Dvd
在程序中描述处理业务逻辑的类,我们称为：业务类
如：demo
不同的类，应该放在不同的包中进行管理，这样的程序层次更清晰
实体类也称pojo，一般放在：org.java.entity
描述业务处理过程的类：org.java.demo
与数据库交互：org.java.dao
涨知识2：正则表达式
String类型 的一个正则表达式，用于判断数据是否满足某一种数据格式
regexp—正则表达式
String类的matches方法，用于判断，字符串是否与正则表达式的格式要求一致
在正则表达式中
\d--------代表0-9之间的任意的一个数字（由于Java中不能直接写\，使用在Java中要使用正则表达式，需要用两个\\）
\D--------代表不是0-9之间的数字
\d\d----代表2个任意数字
\d{2}-----代表2个任意数字
\d{3,8}----3-8位数字
\w---------不区分大小写的任意字母或1个数字
\w{18}----代表18个不区分大小写的字母或数字
[a-z]--------任意的1个小写字母
[A-Z]--------任意的1个大写字母
[a-zA-Z]----不区分大小写的任意1个字母
[2-5]---------2-5之间的任意1个数字
[k-y]----------k-y之间的任意1个字母
abc------------内容必须是abc
.--------------代表任意1个字符
a----------a只能出现且必须出1次
a？-------a可以出现的次数 0-1次
a+----------a可以出现1~多次
a*----------a可以出现0~多次
1(3|5|7|8|9)--------2位数，且第1位必须是1，第2位在35789中任选1位
1(3|5|7|8|9)\d{9}--------手机号码的正则表达式
\d{3}-\d{8} | \d{4}-\d{7,8}-----座机电话号码的格式
[1-9]\d{16}(\d|x)----------------------身份证的格式
\w+@\w{2,6}\.(com|cn)--------------邮箱格式
[1-9]\d{4,10}-----------//10000~99999999999的qq
涨知识3： StringBuffer
String------字符串类型
stringBuffer--------字符串类型 buffer缓冲
hashCode() 返回此字符串的哈希码
append() 在原有的数据基础上追加新的内容
currentTimeMillis() 从1970年到当前时间的毫秒数
string与stringBuffer的区别：
1.String是一个长度不可改变的字符串
string s =“abc”; -------------------3个
s = “abc”+“12345”;
string类型，在创建以后，它的内容不能改变，如果改变它的内容，在内存中，会分配一个新的空间，来存放这个数据，它已经不是原来的对象了（对象创建的越多，耗费的内存越大，程序效果越不好！）
2.stringBuffer 它是一个长度可变的字符串，不会创建新的对象，只是在原来的地址上进行修改。
3.什么时候用string类型，什么时候用stringBuffer类型；
@1如果要频繁的拼接字符串，使用stringBuffer（耗时断 ，不占内存，不产生新对象，性能更好）。
@2如果不频繁的拼接内容，只是简单的存储数据，string类型会更快。
stringBuffer的常用方法：
stringBuffer sf=new StringBuffer();
sf.append("新内容"); //在原内容的尾部追加新内容
sf.toString(); //将stringbuffer转换成string类型
sf.reverse(); //将字符串的内容反向
涨知识4：集合类的使用
集合 ：也成为“动态数组”
集合的工具类：Collections
ArrayList集合
**特点：**1.集合用于存放一组相同类型的数据(同数组)
2.集合通过下标访问元素(同数组)**
3.集合的大小，不用固定，可以动态改变(与数组的差异)
4.允许重复数据
5.采用一种队列的数据结构：先进先出，后进后出（类似于火车进山洞）
拓展：栈：先进后出，后进先出（类似于弹夹装子弹）
创建集合:
ArrayList<数据类型> list = new ArrayList<数据类型>();
//声明：<>里面只能是引用类型
LinkedList集合
LinkedList集合，它的底层是采用的一种双向链表，它提供了一组方法，可以快速的操作集合的头部与尾部的元素
LinkedList<数据类型> list = new LinkedList<>();
list.addFirst(元素); //将元素添加到列表的头部
list.addLast(元素);//将指定元素添加到此列表的结尾
list.getFirst(); 返回此列表的第一个元素。
list.getLast(); 返回此列表的最后一个元素。
removeFirst(); 移除集合
中的第一个元素
removeLast(); 移除集合中的最后一个元
【ArrayList集合的特点】
1、它的底层是一种动态数组，它是基于下标访问元素的
2、它在遍历集合时，会特别快
3、它在增加、删除数据时，集合的数据位置要改变，性能上相对差一些
@@@@@@它在遍历时比较快，增删时慢一些
【LinkedList集合的特点】
1、它的底层是基于双向链表实现的
2、它在增删或者是删除数据时，不需要改变数据的位置，所以速度比较快
3、它在遍历时，相对会慢一些
@@@@它在增删改，遍历时相对慢一睦
如果遍历操作多，一般建议使用ArrayList,如果增删比较多一般使用LinkedList性能更好
一次添加多个数据到集合中
HashSet集合(和上一个很相似)
**特点：**1.集合用于存放一组相同类型的数据(同数组)
2.集合通过下标访问元素(同数组)**
3.集合的大小，不用固定，可以动态改变(与数组的差异)
4.不允许重复数据
5.存放的数据是无序的
拓展：栈：先进后出，后进先出（类似于弹夹装子弹）
创建集合:
HashSet<数据类型> list = new HashSet<数据类型>();
//声明：<>里面只能是引用类型
HashMap集合(购物车)
这种集合不是通过下标访问，它是一种：键、值对集合
**特点：**1.存储数据时，要同时设置:键、值（一个键对应一个值）
2.取数据时，要通过键取到对应的值
3.HashMap中的键，不允许出现重复值（如果键重复，后一次的值会覆盖之前的值）
4.存放数据没有顺序
ArrayList示例：
//创建集合
ArrayList<String> list = new ArrayList<String>();
//向集合添加数据-------add();（增）
list.add(1);//自动添加到尾部
list.add("andi",1)//指定添加到下标1
//根据下标，从集合获得数据
int val=list.get(下标)；
//获得集合的数据个数
int len = list.size();
//判断集合是否包含数据（查）
boolean flag=list.contains(值);
//从集合，移除元素(删)
list.remove(如果值与下标有重复，优先删除下标);
//清空集合
list.clear();
//判断集合是否为空
isEmpty();
//用于代码测试，写一些死数据
ArrayList<Student> list=new ArrayList<Student>();
list.add(new Student(1,"刘备",80));
list.add(new Student(2,"孙尚香",90));
//实际应用是下面这种
ArrayList<Student> list=new ArrayList<Student>();
Student s1=new Student();
s1.id=1;
s1.name="刘备";
s1.score=80;
排序：
//旧方法排序
//将随机生成的数据从小到大排序
for (int i = 0; i < arrsArrayList.size(); i++) {
for (int j = 0; j < arrsArrayList.size()-1-i; j++) {
//将相邻的两个数作比较，大的往后放
if(arrsArrayList.get(j)>arrsArrayList.get(j+1)) {
//将大的数值先存放在变量中
int temp=arrsArrayList.get(j);
//将小的值往前排
arrsArrayList.set(j, arrsArrayList.get(j+1));
//最后将大的值往后放
arrsArrayList.set(j+1, temp);
}
}
}
//新方法排序 接口排序
Collections.sort(list);------该方法，可以对ArrayList集合排序（升序）
抽奖-------(去重复值）
Random r=new Random();
ArrayList<Integer> list=new ArrayList<Integer>();
//生出七个随机数存入集合
while (list.size()<7) {
int num=r.nextInt(36)+1;
if (!list.contains(num)) {//判断集合中是存在该数值
list.add(num);//存入数组中
}
}
//排序
Collections.sort(list);
//输出
for (Integer integer : list) {
System.out.print(integer+" ");
}
HashMap示例:
HashMap<Integer, String> map=new HashMap<Integer, String>();
map.put(1, "刘备");//存数据
map.put(2, "孙尚香");
map.put(3, "刘禅");
/**第一种方法（老方法）
Set<Integer> keys =map.keySet();//获得map中所有的键
System.out.println("编号"+"\t"+"姓名");
for (int integer : keys) {//通过键取得相应值
System.out.println(integer+"\t"+map.get(integer));
}
*/
//第二种方法 取得map中的所有值
Collection<String> val=map.values();
for (String str : val) {
System.out.println(str);
}
map.get(1);//通过键取值
map.size();//存 储的数据个数
map.remove(3);//删除数据
map.clear();//清空数据
map.containsKey(1);//判断是否存在键
map.containsValue(2);//判断是否存在值
涨知识5：随机数类的使用
随机数：
在Java中，产生随机数的方式，主要有两种：
第1种： double val=Math.random();
//得到一个介于0到1之间的浮点数，最小值，有可能取到0，
第2种：Random rd = new Random();
int val = rd.nextInt(N);
//得到介于0到N-1之间的int数值
涨知识6：访问修饰符
private----------私有的------->只能在当前类访问
public -----------公开的 ------->访问范围最大，任何位置都能访问
作用：用于限制数据的访问
快捷键 右键–>source—>and setters
//如何使用
public class Student{//创建学生类，并创建私密属性
private string name;//用户名称
private string pwd;//用户密码
public void setName(string name){//存数据
this.name=name;//把接受到的参数，赋值给类中的私密属性
}
public void setpwd(string pwd){
this.pwd=pwd;//把接受到的参数，赋值给类中的私密属性
}
public void getName(){//获取私密属性的值
return name;
}
public void getpwd(string pwd){
this.pwd=pwd;//取数据
}
}
public class java_9 {
public static void main(String[] args) {
ArrayList<Student> list=new ArrayList<Student>();//创建学生集合
Student student=new Student();//实例化一个学生对象
student.setName("张三");//调用方法传入值
student.getNmae();//获取姓名属性
}
}
涨知识7：ASCII的转换
//将ASCII转换成字符
int val=66;
char chr=(char) val;
//将字符转换为ASCII
char chr ='A';
int val=chr;
涨知识8：数组
一维数组
1.如何声明数组：
数据类型[ ] 数组名字 = new 数据类型 [数组的大小];
int [ ] arrs = new int [6]; //创建一个大小为6的数组
arrs[0]=111; //通过数组的下标给每个位置赋值
arrs[1]=222;
arrs[2]=333;
2.先定义数组，再通过下标给数组赋值
int [ ] arrs=new int [3];
arrs[0]=3;
3.定义数组时直接给数组赋值
int arrs[ ]=new int[ ]{11,22,33}
简化：int arrs[ ]={11,22,33}
4.获取数组的长度
列：int len= 数组名.length;--------后面没有括号的叫属性；
数组名.length();-------后面有括号的叫方法;
5.针对于数组的循环遍历两种方式：
@1：采用传统的for循环，通过下标取值
for(int i=0;i<arrs.length;i++){
}
@2:使用for循环增强（forEach）//只能在对数组遍历取值时才可以使用
for(数组类型 变量名 : 数组名称){
}
6.java中对数组的排序：
数组中的数组按规律分3种：
1、无序排列：3，2，1，5，7
2、升序排列：(从小到大)1，2，3，4，5
3、降序排列:（从大到小）5，4，3，2，1
排序方法：
@1冒泡排序：相邻的两个数相互之间作比较，大的向后放
/*升序排列*/
int[] arrs= {5,4,3,2,1};
//外层循环 找多个最大值 i代表已经找到几个最大值
for (int i = 0; i < arrs.length; i++) {
//内层循环 只能找到一个最大值
for (int j = 0; j < arrs.length-1-i; j++) {
//将相邻的两个数作比较，大的往后放
if(arrs[j]>arrs[j+1]) {
//将大的数值先存放在变量中
int temp=arrs[j];
//将小的值往前排
arrs[j]=arrs[j+1];
//最后将大的值往后放
arrs[j+1]=temp;
}
}
}
for (int i : arrs) {
System.out.print(i+"\t");
}
/*降序排列*/
for (int i = 0; i < arrs.length; i++) {
for (int j = 0; j < arrs.length-1-i; j++) {
if(arrs[j].sum<arrs[j+1].sum) {
Stu temp=arrs[j+1];
arrs[j+1]=arrs[j];
arrs[j]=temp;
}
}
}
@2选择排序：用每一个数分别与后面的每个数进行比较，小的值向前放
int[] arrs= {6,4,8,3,9};
for (int i = 0; i < arrs.length-1; i++) {
for (int j = i+1; j < arrs.length; j++) {
if (arrs[i]>arrs[j]) {
int temp=arrs[i];
arrs[i]=arrs[j];
arrs[j]=temp;
}
}
}
for (int i : arrs) {
System.out.print(i+"\t");
}
java中提供了一个数组的工具类
Arrays.sort(数组名)
只能进行升序排列
用接口实现对象数组排序
二维数组
int [ ] arrs = new int [ 3 ];------------------一维数组
int [ ] [ ] arrs = new int [ 2 ] [ 3 ];--------二维数组
一位数组：用于存放一组相同类型的数据
二维数组：用于存放一维数组的数组就是二维数组
int [ ] [ ] arrs =new int [ 2 ] [ 3 ];
//2-------------当前二维数组中，可以包含2个一维数组
//3-------------每一个一维数组中，可以存放3个int类型的数据
给二维数组赋值的两种方法：
@1先声明，后赋值：
int [ ] [ ] arrs =new int [ 2 ] [ 3 ];
arrs [ 0 ][ 0 ]=11;//第1个一维数组中的第1个值
arrs [ 0 ][ 1 ]=22;//第1个一维数组中的第2个值
arrs [ 0 ][ 2 ]=33;//第1个一维数组中的第3个值
arrs [ 1 ][ 0 ]=44;//第2个一维数组中的第1个值
arrs [ 1 ][ 1 ]=55;//第2个一维数组中的第2个值
arrs [ 1 ][ 2 ]=66;//第2个一维数组中的第3个值
@2声明时直接赋值：
int [ ] [ ] arrs = {
{1,2,3},{4,5,6} b
};
//遍历二维数组的通用方法
//第一种用for嵌套取值
for(int i=0;i<2;i++){
for(int j=0;j<3;j++){
system.out.print(arrs[i][j])
}
system.out.println("")
}
//第二种用forEach取值
for (int[] k : arrs) {
System.out.println(k[0]+"\t"+k[1]+"\t"+k[2]+"\t");
}
//动态接受的通用方法
Scanner scanner=new Scanner(System.in);
int[][] arrs=new int[2][3];
for (int i = 0; i < 2; i++) {//i--控制输入的第几个学生
for (int j = 0; j < 3; j++) {//j----控制的第几门成绩
System.out.print("请输入第"+(i+1)+"学生的第"+(j+1)+"门成绩：");
arrs[i][j]=scanner.nextInt();
}
System.out.println(" ");
}
对象数组
对象类名[ ] stu=new 对象类名 [ 存储对象的个数];
Student[] stu =new Student[3];
示例：
//创建对象数组
Student_1[] stu=new Student_1[3];
//为对象赋值
Student_1 s1=new Student_1();
s1.setId(1);
s1.setStuName("aaa");
s1.setScore(90);
//将对象添加到数组中
stu[0]=s1;
找出对象数组中分数最高或最低的对象
//设定最大值是第一个对象
Student_1 max=stu[0];//最大值
Student_1 min=stu[0];//最小值
//判断 如果比它大 那么就替换它
for (int i = 1; i < stu.length; i++) {
if (max.getScore()<stu[i].getScore()) {
max=stu[i];
}
对象数组用冒泡排序
//冒泡排序
for (int i = 0; i < stu.length-1; i++) {
for (int j = 0; j < stu.length-1-i; j++) {
//用学生成绩比较大小
if (stu[j].getScore()>stu[j+1].getScore()) {
//将最大的值提取到中转站中
Student_1 temp=stu[j];
//将值小的往前放
stu[j]=stu[j+1];
//再将值最大的数据赋值给数组最后一个下标
stu[j+1]=temp;
}
}
}
对象数组使用选择排序
//选择排序
for (int i = 0; i < stu.length; i++) {
for (int j = i; j < stu.length; j++) {
if (stu[i].getScore()>stu[j].getScore()) {
Student_1 temp=stu[i];
stu[i]=stu[j];
stu[j]=temp;
}
}
}
涨知识9：类与对象
三个核心：封装、多态、继承
1、对象
面向对象编程：OOP
对象的特征：---------对象的属性
对象的行为：---------对象的方法
例如：当前这个鼠标（对象必须是真实存在的一个具体事物）
属性：颜色、材质、价格、外型
方法：滑动、拖拽、点击
2、类
把一组对象共同拥有的属性与方法抽取出来，形成的数据类型，称为：类（class）
3、类与对象之间的关联：
类相当于一个模板，产生出具体的实例，称为：对象
把一组对象共同拥有的属性与方法抽取出来形成数据，称：类
类比对象更大
产生对象的语法：
类名 对象名 = new 类名 （）；
Student stu = new Student();
new---创建对象的关键字，创建时系统会分配内存
对象数组
Student[ ] arrs = new Student[ 3 ];
此数组存放的是Student类型的数据
涨知识10：方法
递归：自己调用自己的方法
public void add(){
add();
}
一个方法由两部分构成：
public void show（）-------1.方法声明
{
----------2.方法体
}
按类型可以分为两大类：
1、主方法（主函数）
public static void main(String[ ] args){
}
特点：
1、类中有了主函数，当前类才可以直接运行，否则，只能 被其他类调用
2、一个类中，最多只能有一个主函数
3、主函数不能被用户调用，它只能被操作系统调用
4、主函数中不能直接调用普通方法,如果要调用普通方法， 必须先创建当前类的实例（对象）,然后通过对象调用类 中的普通方法
5、主函数中，不能直接使用类中的普通全局变量，如果要 访问普通全局变量，也要先创建对象，再通过对象方法
2、普通方法（除了主方法之外的所有方法，都称为普通方法）
public static void 方法名(){
}
特点：
1、 一个类中可以包含多个普通方法
2、普通方法之间,可以相互调用
3、普通方法，可以直接访问全局变量
3、普通方法分4种类型
1、没有参数，没有返回值的方法
public void 方法名(){
}
2、有参数，没有返回值的方法
public void 方法名(数据类型 参数名){
}
3、没有参数，有返回值的方法
public 数据类型 方法名(){
return 值; //谁调用此方法，值就返回给谁
}
4、有参数，有返回值的方法
public 数据类型 方法名(数据类型 参数名){
return 值;
}
4、toString()方法
类中有toString()方法，该方法必须返回String类型的数据
public String toString(){
//快捷生成toString()方法 右键+Source+Generate toString();
}
情况1：如果对象存在toString()，该方法将会被自动调用
情况2：如果对象没有toString()，将会输出对象的地址信息
5、构造方法
作用：该方法是系统在实例化对象要调用的方法
快捷键----source->methods
//构造方法
public 类名(){
}
特点1：构造方法名称必须与类同名
特点2：构造方法不能知道返回类型（包括void也不能指定）
特点3：构造方法只能被系统调用，用户无法调用
特点4：构造方法是一个类中第一个被调用的方法
//1、不带参数的构造方法 目的：用于创建对象实例
public Stu(){
}
//2、带参数的构造方法 目的：在创建对象实例时，直接给对象赋值
public Stu(int id,String name,int score){
this.id=id; //this:当前类
//快捷键 右键+source+generate constructors from
}
1.如果类中，只包含带参数的构造方法，在实例化对象时，就必须传递构造方法需要的参数
2.一个类中，可以同时包含多个构造方法，可以带参数，也可以不带参数，在创建对象，系统将根据是否携带参数来判断，调用哪一个构造方法实例对象
3.如果类中没有显示声明任何构造方法，系统将生成一个默认不带参数的构造方法(不可见)
4.用户如果在类中指定任何构造方法，系统就不在生成默认构造方法
5.一般如果在类写了带参的构造方法，都建议再编写一个不带参数的构造方法（好习惯）
6、全局变量与局部变量
全局变量:在方法外部声明的变量，我们称为“全局变量”，除了主函数 之外的所有普通方法都可以直接使用
public class demo01 {
int number=0;//全局变量
public static void main(String[] args) {
}
}
局部变量：在方法内部声明的变量，我们称为“局部变量”，它只能在 当前方法内部使用
public void show(){
int number=0;//局部变量
}
//全局变量与局部变量允许重名，但如果普通方法内有局部变量会优先输出局部变量值。
涨知识11：string字符串
定义一个字符串变量：
String msg="hello world";
1、length();
作用：获得字符串的长度（空格也要算长度）
int len = msg.length();
2、trim();
作用：去掉字符串两边的空格
msg = msg.trim();
3、toUpperCase();
将字符串中的字母全部转换成大写
toLowerCase();
将字符串中的字母全部转换成小写
4、charAt()
char val = msg.charAt(下标);
根据下标从字符串取到指定的字符
5、substring()
作用：从字符串截取指定内容
语法有两种:
语法1： String val = msg.substring(开始下标，结束下标);
//从字符串的开始下标处截取内容，一直截取到结束下标处（它包含开始下标处的字符，但不包含结束下标处的字符）
语法2： String val = msg.substring(开始下标);
//从字符串的开始下标处截取内容，一直截取到最后
6、replace()
作用：用于将字符串指定的旧数据，用新数据替换
String value = msg.replace("旧数据","新数据");
7、equals()
作用：用于比较字符串的值是否相等
注意：==不能用字符值的比较，它比较的是字符串的内存地址
如果两个字符串要比较值是否相等，要用equals方法
boolean flag = name.equals("jack")
这种方式比较时，要区分字母的大小写
boolean flag = name.equalsIgnoreCase("ABC");
这种方式比较时,不区分字母的大小写
8、startsWith()
判断字符串是否是以指定内容开头
boolean flag = msg.startsWith("刘");
9、endsWith()
判断字符串是否是以指定内容结尾
boolean flag = msg.endsWith("刘");
10、contains()
判断字符串是否包含指定内容（不限位置）
boolean flag = msg.contains("刘");
11、format()
作用：用于指定字符串的格式，给字符串动态设置参数
String date = String.format("%s年%s月%s日", year,month,day);
涨知识12 数据传递方式
在java中，传递数据的方式有两种:
1、按值传递
给方法传递的参数时，传递的是变量的副本，在方法中，对参数的修改，并不会影响到本身的数据变化
按值传递的数据：
1、8种基本数据类
3、8种封装类
2、String
2、按引用传递（按地址传递）
给方法传递参数时，传递的是数据对应的内存地址，对参数的修改，会影响到数据本身的变化
下列数据，会按引用传递:
1、对象
2、数组
3、集合
按值传递：对参数的修改，不会影响到数据本身的变化
按引用传递：对参数的修改，会影响到数据本身的变化
涨知识：装箱与拆箱
基本数据类型 包装类
short-----------------------Short
int-------------------------Integer
long------------------------Long
float-----------------------Float
double----------------------Double
char------------------------Character
boolean---------------------Boolean
byte------------------------Byte
Integer:
//最常用的方法：
1、parseInt("字符串")
作用：将字符串转换成int类型
方法：int sum=Integer.parseInt("123")；
2、toSting();
作用：将数值转换成字符串类型
用法：String msg=num.toString();
Character:
//最常用的方法：
1、isDigit()
作用：判断当前字符是否是一个数组是返回true
boolean flag=character.isDigit(Val);
涨知识13 oop面向对象
所有面向对象都有三个重要特性：
1.封装
将属性与方法组成在一起，形成一个不可分割的整天，属性私有，通过共有方法进行访问
2.继承 extends
//目的：子类继承父类，可以自动拥有父类的方法与属性，并且还可以定义自己的方法与属性
语法：public 子类 extends 父类{
}
//父类：称为超类（super class） 基类
//子类：称为派生类
基本原则： 1.java中，一个子类只能继承一个父类
2.java中，一个父类可以派生多个子类
3.在java中，所有的类都是直接或间接的继承：Object
4.子类继承父类以后，可以拥有父类的方法与属性（但父类的方法与属性采用private修饰时，子类不能继承）
方法重写（override）
如果父类中有eat（）方法，子类也有eat（）方法，则父类的方法会被覆盖，优先调用子类eat（）方法
注意：子类重写父类方法时，方法名称，参数个数，类型，顺序，返回值都要与父类保持一致 （只有子类与父类之间有继承关系，才会有重写的概念
方法重载（overload）
在一个类中，有多个方法，方法名称一样，参数列表不同（参数个数、类型、顺序不同）
注意：方法重载与返回值无关
super.方法();--------如果子类重写了父类，则只能通过super.方法()来调用父类的方法，可以出现在方法的任何位置
super();-------------调用父类的构造方法，它只能出现在子类的构造方法中的第一行代码
在创建实例对象时：
1.如果类之间有继承关系，会首先调用父类的构造方法，然后再调用子类
2.创建子类对象时，系统也会先调用父类的构造方法
类中可以包含带参的构造方法，也能包含不带参的（在创建子类对象时，系统默认调用父类中不带参的构造方法）
如果父类中只有一个带参的构造方法，子类不能直接继承父类（此时只能在子类的构造方法中，通过super()方法，向父类传递参数，并且super()必须是子类构造方法中的第一行代码）
4种修饰符
如果是不同包的子类，访问protected，则访问形式是：
子类 obj = new 子类();
obj.父类中·的protected修饰的属性或方法
2个系统关键字
final:它是一种修饰符，可以修饰类、属性、方法
final class 类名
修饰类，表示这个类不能被其他类继承
public final void 方法名(){}
修饰方法，表示该方法不允许被子类重写
Public final String mas=“jack”;
修饰属性，表示该属性是一个常量，赋值以后值不允许被改变
static:(静态的)它是一个修饰符，一般用于修饰方法、属性
static 修饰方法：表示当前方法是一个静态方法（类方法）
例如： public static void show(){
}
类中的静态方法，可以通过类名直接调用方法，而不需要再去创建类的实例(当然通过对象，也还是可以调用静态方法)
注意：静态方法会消耗更多资源，非必要不轻易使用
**静态方法的特点：**1、静态方法，可以通过类名直接访问
2、静态方法，只能访问静态变量，不能访问普通全局变量
3、静态方法可以直接调用其他的静态方法，但不能直接调用普通方法（必须通过类的实例方法才能访问普通方法）
4、普通方法可以直接访问静态方法和变量
静态方法的属性：
一个类不论被实例化多少次，用了static后，只会初始化一次 （而普通属性会一直初始化）
静态块：
static { 代码; }
静态块是一个类中最优先执行的代码（它比构造方法还要优先），一般用于给类中的属性赋初始值，静态块只能被操作系统调用，用户无法调用
3多态
同一个对象，在不同环境下的表现形式
注意：1.不允许直接实例化
2. 抽象类 obj=new 抽象类();--------------错误写法
3. 抽象类 obj=new 抽象类的子类();------------正确创建的方式
2
一个抽象类，可以存在抽象方法和非抽象方法
子类继承抽象类，必须重写父类的抽象方法，可以不重写非抽象方法
抽象类不一定会有抽象方法，但有抽象方法的类一定是抽象类
涨知识14：时间
1.通过util包中的Date获取
Date date=new Date();//创建一个当前日期类，获得系统时间
date.toLocalString();//格式化输出日期，但已过时
date.getTime();//返回1970-1-1到当前所间隔的毫秒数
yyyy:年 1000/3600/24/365
MM：月 1000/3600/24/30
dd：日 1000/3600/24
HH：小时 1000/3600
mm：分钟 1000/60
ss：秒 1000
E：星期
SimpleDateFormat sf=new SimpleDateFormat("yyyy-MM-dd")
Date date=sf.parse(time);
String msg=sf.format(date);//将日期格式的数据转换成指定格式的字符串
示例：
//将字符串转换成日期类型
String time="2020-02-18";//计算当前日期到1970-1-1间隔的毫秒数
SimpleDateFormat sf=new SimpleDateFormat("yyyy-MM-dd")
Date date=sf.parse(time);//将字符串转换成日期格式
long val=date.getTime()/1000/3600/24/365;//得到相差的年份
//将日期类型转换成字符串
SimpleDateFormat sf=new SimpleDateFormat("yyyy-MM-dd")
Date date= new Date();
String res=sf.format(date);
//输入一个身份证，计算年龄
//例：42092220001003571X
str=sc.next();
1、先截取年月日
string year=str.substring(6,10);
string month=str.substring(10,12);
string day=str.substring(12,14);
2.将string类型转换成日期类型
string bir=year+"-"+month+"-"+day;
SimpleDateFormat sf=new SimpleDateFormat("yyyy-MM-dd");
Date time=sf.parse(bir);//转换成日期
3.计算两个日期之间的毫秒数
Date date=new Date();//获取系统时间
long val=time.getTime()-date.getTime();
4.输出
year=val/1000/60/60/24/365;
month=val/1000/60/60/24;
2.通过Util包的Calendar 获取
3.通过Util包的Calendar 获取时间，分别获取年月日时分秒
涨知识:15抽象方法
一个完整的方法包含两部分：
1.方法声明
2.方法体
**目的：**可以定制一些标准（抽象方法），要求继承的子类必须强制实现这些标准(子类必须重写这些方法)
**优势：**使用抽象类可以体现出java的多态，不同的子类去实现父类的抽象方法，实现的功能也不同
public voidshow(){
方法体;
}
//只声明，不包含方法体的方法，我们称为抽象方法
public abstract class 类{
public abstract void show();
}
**注意：**1.一个类继承抽象类，必须重写父类的抽象方法，但如果子类也是抽象类，则不用重写。
2.一个类继承抽象类，需要把该抽象类以及抽象类的父类中所有的抽象方法全部实现
3.抽象类，可以有抽象方法，也可以有非抽象方法；
创建示例：
子类 obj=new 子类();//正确
父类 obj=new 子类();//正确
子类 obj=new 父类();///错误（不能让父类指向子类）
涨知识16.接口 interface
**作用：**与抽象类非常相似，用于定义标准（定义抽象方法），让子类实现标准（必须重写这些抽象方法）
接口中所有方法，必须是抽象方法，不能有方法的实现
声明：
//接口的声明方法：
public interface 接口名{
public abstract void 方法名();
}
//子类实现接口语法：
public class 子类 implements 接口名{
重写父类的抽象方法
}
//创建接口实现的方法：
接口 obj=new 接口的实现类();
//注意：接口不能直接实例化，要通过子类的创建
interface 与 abstract class (接口与抽象的区别)：
1. 抽象类中可以有抽象方法也可以非抽象方法，接口只能有抽象方法
**2.**类与抽象类的关系是：继承关系
class 子类 extends 抽象类
类与接口之间是实现关系
class 子类 implements 接口
**3.**一个类只能继承一个抽象类，但可以同时实现多个接口
**4.**接口中可以定义变量，但值不允许改变
**使用接口的实际案例：**集合中的对象，按对象的某一个属性来排序
**使用接口的好处：**1.强制子类必须重写某些方法
2.通过接口，可以隐藏代码实现的细节（不安全 ）
3.使用接口，当底层代码改变以后，代码不需要进行过多修改
//以前创建集合是：
ArrayList<e> list = new ArrayList<e>();//这种方式，无法隐藏细节
List<e> list=new ArrayList<e>();//这种方式会隐藏实现细节
接口的用法
----------------------------------------------
1、子类继承一个接口
public class 子类 implements 接口名{
重写父类的抽象方法
}
-----------------------------------------------
2、子类继承多个接口
public class 子类 implements 接口名1，接口名2，接口名3{
重写父类的抽象方法
}
-------------------------------------------------
3、子类继承父类，并实现接口
public class 子类 extends 父类 implements 接口名{
重写父类的抽象方法
}
------------------------------------------------
4、接口继承接口
public interface 接口名 implements 接口名{
}
接口的分类
1、自定义接口：需要我们自己定义
2、系统提供的接口：由系统提供，用户可以直接使用
~与集合相关的接口：
*【List】
ArrayList:遍历快，增删慢
LinkedList:增删快，遍历慢
*【map】
HashMap:非线程安全
HagTable:线程安全
*【set】
hashSet
*【Collection】
~与排序相关的接口：
1、数组排序
Arrays.sort(数组);
2、集合排序
Collections.sort(集合);
3、对集合排序（集合中存放的是对象，要求按对象中的某个属性排序）
*1：第一步，向集合里添加数值
List<Student_1> list=Arrays.asList(new Student_1(1,"张三",90),new Student_1(3,"王五",98),new Student_1(2,"小明",80));
Collections.sort(list);
2：第二步，让student_1继承Comparable并重写排序方法
public class Student_1 implements
<Student_1>{
@Override
public int compareTo(Student_1 stu) {
return (int) (stu.mathscore-this.mathscore);
}
}
可以实现多态
public class test {
public static void main(String[] args) {
List<Integer> list=new ArrayList<Integer>();
list.add(11);
}
public void show(List<Integer> list) {//将集合作为参数传入
System.out.println(list);
}
}
17.异常处理(Exception)
异常是程序在运行过程中，出现的不正常的情况，程序中如果产生异常，将会中断正在执行的程序，异常不是错误,只要对异常进行处理，程序可以继续运行。
异常可分为两类：
第一类：运行时异常 RuntimeException
运行时异常，是由于用户操作问题产生的，这一类异常是可以避免的。
第二类：受检查异常
这一类异常，是由于程序设计原因造成的，用户无法避免，用户必须解决才能运行。
**异常处理：**对程序中异常处理后，程序可以继续运行。
如果产生的异常与捕获的异常类型不一致，则不会执行catch代码
//自己处理异常的五种方法
1.第一种方式：
try{
//再次出编写可能出错的代码
}catch(可能会出现的错误类型 ex){
//出错后的运行代码
}
2.第二种方式：
try{
}catch(异常类型1 ex){
}catch(异常类型2 ex){
}catch(异常类型3 ex){
}
3.第三种方式：
try{
}catch(异常类型1 ex){
}catch(异常类型2 ex){
}catch(Exception ex){
}
Exception :所有的异常都能处理，所以一般放在最后兜底，只能放在最后面。
4.第四种方式：
try{
}catch(Exception ex){
e.printStackTrace();//会打印出错的是哪一行，方便调错
}
5.第五种方式：
try{
}catch(Exception ex){
e.printStackTrace();
}finally{
此处的代码，是程序在最后必须要执行的代码（不论程序有没有异常都会运行）
}
//一般连接数据库的时候，在finally里面关闭资源
throws 关键字，用于声明方法要抛出异常
throw 关键字，用于在代码中，手动抛出异常
// 异常处理的第一种机制：使用try...catch自己处理
try{
}catch(Exception ex){
e.printStackTrace();
}
//第二种机制：使用throws将异常向上抛，谁调用方法，谁处理异常
public void show() throws 异常类型1 异常类型2{
}
public void show() throws Exception{
throw new Exception("xxxx");
}
18、整数自动补0
DecimalFormat df=new DecimalFormat("00");//两位数格式
int number=df.foramt(number);//格式输出 如：number=5
system.out.println(number);//结果输出 05
19、整数自动补齐小数位的0
int number=myNumber(5);//整数5
//结果输出5.00
public static String myNumber(int number){//补齐数字的后两位小数
NumberFormat format=NumberFormat.getNumberInstance();
format.setMinimumFractionDigits(2);
format.setGroupingUsed(false);
return format.format(number);
}
20、内部类
在一个类中包含另一个类，被包含的类就是：内部类
public class test{
public static void main(String[] args) {//外部类
new test2().show();
}
static public class test2{//内部类
public void show() {
System.out.println("这是内部类");
}
}
}
21、匿名内部类
public class test{
public static void main(String[] args) {//外部类
new tet() {//tet是一个接口类
@Override
public void show() {//匿名内部类重写接口方法
System.out.println("匿名内部类");
}
}.show();//调用show方法
}
}
匿名内部类的对象集合排序
List<Student_1> list=Arrays.asList(new Student_1(1, "张三", 98),new Student_1(2, "王五", 30),new Student_1(2, "李四", 90));
Collections.sort(list,new Comparator<Student_1>() {
@Override
public int compare(Student_1 o1, Student_1 o2) {
// o1-o2:升序
// o2-o1:降序
return (int) (o2.mathscore-o1.mathscore);
}
});
for (Student_1 student_1 : list) {
System.out.println(student_1);
}
ows将异常向上抛，谁调用方法，谁处理异常
public void show() throws 异常类型1 异常类型2{
}
public void show() throws Exception{
throw new Exception("xxxx");
}
## 18、整数自动补0
```java
DecimalFormat df=new DecimalFormat("00");//两位数格式
int number=df.foramt(number);//格式输出 如：number=5
system.out.println(number);//结果输出 05
19、整数自动补齐小数位的0
int number=myNumber(5);//整数5
//结果输出5.00
public static String myNumber(int number){//补齐数字的后两位小数
NumberFormat format=NumberFormat.getNumberInstance();
format.setMinimumFractionDigits(2);
format.setGroupingUsed(false);
return format.format(number);
}
20、内部类
在一个类中包含另一个类，被包含的类就是：内部类
public class test{
public static void main(String[] args) {//外部类
new test2().show();
}
static public class test2{//内部类
public void show() {
System.out.println("这是内部类");
}
}
}
21、匿名内部类
public class test{
public static void main(String[] args) {//外部类
new tet() {//tet是一个接口类
@Override
public void show() {//匿名内部类重写接口方法
System.out.println("匿名内部类");
}
}.show();//调用show方法
}
}
匿名内部类的对象集合排序
List<Student_1> list=Arrays.asList(new Student_1(1, "张三", 98),new Student_1(2, "王五", 30),new Student_1(2, "李四", 90));
Collections.sort(list,new Comparator<Student_1>() {
@Override
public int compare(Student_1 o1, Student_1 o2) {
// o1-o2:升序
// o2-o1:降序
return (int) (o2.mathscore-o1.mathscore);
}
});
for (Student_1 student_1 : list) {
System.out.println(student_1);
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
