Java笔记-高级篇（1）

最新推荐文章于 2022-05-22 15:25:49 发布

小猿若白

最新推荐文章于 2022-05-22 15:25:49 发布

阅读量244

点赞数 1

分类专栏： Java笔记

本文链接：https://blog.csdn.net/qq_42288512/article/details/89303731

版权

Java笔记专栏收录该内容

4 篇文章 0 订阅

订阅专栏

第四章面向对象

面向对象思想三大特征：封装继承(接口）多态
一.封装：将属性私有化，提供公开的方法访问这些私有属性
1.第一步：将属性私有化，使用private修饰的属性将变成私有属性，其他的类都无法直接访问
2.第二步：提供公开方法访问私有属性
使用封装好处：安全（隐私），校验
二.继承：子类具有父类的一般特征以及自身的特有特征//传递性，关联性，分类
子类
指定Demoa类的父类Demo
子类Demoa继承父类Demo的一般（非私有的）特性(属性和方法)
改写（重写）：子类和父类的方法定义相同，方法的实现不同
子类产生的对象可以声明为子类也可以声明成父类
子类与父类之间的关系可以看成小类和大类之间的关系
super：引用当前类的父类对象，必须在子类构造器的第一行书写，super(构造器);
1.子类对父类继承下来的内容进行操作
2.子类自身特有的特性
//如果定义成父类类型，只能使用父类所拥有的非私有方法
3.为什么要使用父类类型：兼容
注意：
1.先父类后子类，产生子类对象前，必须首先产生当前子类的父类对象
2.默认情况下调用的是父类的无参数构造器
3.当父类没有书写无参构造器时，必须在当前子类第一行调用指定构造器super(实参列表);
Object类是JAVA中所有类的直接或者间接父类，extends Object 可省略
int 原始数据类型，它就不是一个类（自定义数据类型）
总结：
1.子类继承父类内容，在子类重写时，其实使用的就是父类的特征
2.子类可以覆盖父类的非私有内容
3.父类私有的内容，如果子类不定义，就不能继承引用
4.无法进行隔代传递（如果父类将它所继承的内容标注为私有的，子类无法继承）

三.多态：一种事物具有多种形态表现的特征，多态分为：方法的重写和方法的重载，多态是面向对象的核心思想
方法的重写：子类重写父类的方法，重写的是方法内容（方法体/方法实现）
方法的重载：在一个类中，如果多个方法之间方法名相同，形式参数列表(个数，类型，顺序)不同

方法修饰符
1）static(静态的)：可以修饰三个地方：属性(静态变量/类变量) 方法(静态方法/类方法) 块(静态块):在类被加载时，会按照顺序依次执行，并且只能执行一次

区别：被静态的(static)修饰的内容(属性类型和块)就不在由对象而产生，会在类被加载时产生(调用)
静态方法和成员方法的区别：
1.成员方法必须通过成员调用，静态方法可以通过类调用
2.静态方法的生命周期比成员方法的长，先有静态方法后有成员方法
3.成员方法可以直接调用静态方法的内容，而静态方法不可以直接调用成员方法的内容
4.静态方法中不能使用this关键字，不能使用成员变量

2）final(最终的)
类：修饰类，这个不能被继承
属性：修饰属性，这个属性值不能更改，使用final修饰的属性必须赋初值（构造器不管final修饰的属性）
方法：修饰方法，这个方法不能被重写

3）abstract(抽象的)
类：当类中有一个方法是抽象方法时，这个类也必须定义成抽象类
方法：当方法仅有定义而未有实现时，这个方法为抽象方法（未完成方法）
注意：
1.抽象类不能被new，抽象类不能产生对象
2.抽象方法是一个未完成的方法，需要子类去完成(实现)这个方法，所以不能abstract和final同时修饰一个地方
3.如果抽象类中有已经实现的方法，如何调用
3.1可以将已实现方法定义成静态方法，通过类直接调用
3.2可以通过子类来实现父类方法的方式直接调用
3.3在产生对象时，顺道将未实现的方法一同实现
4.抽象类可以不书写抽象方法
JAVA定义一个常量
public static final 数据类型常量名=值;
常量名:必须全大写，多个单词之间使用_隔开
访问修饰符

本类同包子类其他
public + + + +
Protected + + + -
缺省的(都不写) + + - -
Private + - - -

接口：
1.是一个规范，它是抽象方法的集合
2.一个类可以继承一个父类，一个类可以实现多个接口
3.接口中的方法都是公开方法
4.接口中的属性都是常量
5.接口不能被new，接口中不存在构造器
6.接口可以继承另一个接口
抽象类是个类，类中的方法可以有非抽象的，只能是一个常量，可以有其他作用域

obj是一个数组对象Object
eg：public void a(int … obj){}//正无穷个int 型变量

//Integer就是int

泛型：T就是泛型
public class F2{
T t;//声明一个变量t,类型为T
}

枚举enum（常量值）
public enum F3{
A,B,C,D;//类似数组的效果
}
一.常用类–字符串（String)
1.如何产生一个字符串（字符串序列）类
String a=“abc”;//产生一个字符串
String b=new String(original:“abc”);//通过产生对象方式，产生一个字符串
String c=new String();//产生一个空字符串
char[] arr={‘a’,b’,‘c’);
String d1=new Stirng(arr);//按照字符数组的方式产生一个字符串
String d2=new String(arr,offset:0,count:1);//上边的重载写法，后两个参数，从数组第几个开始，获取几个
byte[] arr2={97,98,99};
String e1=new String(arr);//按照一个字节数组方式产生一个字符串
String e2=new String(arr,offset:0,count);//上边的重载写法，后两个参数，从数组第几个开始，获取几个
建立new之后就会产生新对象（定义后不相等，但值相等）

String类：字符串常量，String的值不能修改，它隶属于Java.lang包（这个包不需要导入）
常见方法：
1.获取字符串长度//public int length();
2.获取指定位置的字符//public char charAt(int index);
3.获取到字符串去掉前后空格的形式//public String trim();（目标字符串没有改变）
4.获取到指定字符或字符串在目标字符串中的第一个位置，如果不存在返回-1；
//public int indexOf(int ch);
//public int indexOf(String ch);
5.获取到指定字符或字符串在目标字符串中的最后一个位置，如果不存在返回-1；
//public int lastIndexOf(int ch);
//public int lastIndexOf(String ch);
6.str1.equals(str2);
equals： public boolean equals(String str):判断两个字符串的值是否相等（忽略大小写）
==：判断两个变量的地址是否相等
7.获取到目标字符串的大写和小写的形式
str1.toUpperCase();
str1.toLowerCase();
8.str1.equalsIgnoreCase(str2);
str1.coneat(str2);//将str1和str2拼接成一个新的字符串
9获取到目标字符串从第几个开始，到自然结束的新字符串.
str1.substring（第几个）//eg：str1.substring（3）
str2.substring(第几个开始数，到第几个结束)//eg:str2.substring(2,4)
10分割字符串:将目标字符串按照相应格式进行分割，分割成一个字符串数组
Sting[] arr=str.splt(regex:",");
11.替换目标字符串中相应内容为指定内容
Sting[] arr=str,replace(target:“s”,replacement:“t”);
12.获取到字符串的字符数组形式
str.toCharArray();
13.判断字符串是否为空
str.isEmpty();//结果为boolean型
14.判断字符串是否以什么开头/结尾
str.startsWith();//结果为boolean型
str.endsWith();//结果为boolean型
15.获取目标字符串的字符串形式
str,toString();
16.str.intern();获取声明变量的副本形式

**二.StringBuffer:**线程安全的可变字符序列//单线程安全
可变长度的字符串
构造一个其中不带字符的字符串缓冲区，其初始容量为16个字符
StringBuffer s1=new StringBuffer();
构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容
StringBuffer s2=new StringBuffer(“abc”);
构造一个不带字符，但具有指定初始容量的字符串缓冲区
StringBuffer s3=new StringBuffer(capacity:3);
常见方法
StringBuffer str=new StringBuffer(“abc”);
str.length();
str.toString();//转换为String类型
str.reverse();//反转
str.append();//追加 str.concat()//拼接
str.insert(offset:3,str:“a”);//在第四元素之前插入一个a，其他元素后移
str.delete(3,5);//从1开始数，删除第4个到第6的值

将String->StrnigBuffer
将StringBuffer->String
String与StringBuffer的区别：
1.String是一个字符串常量，值不能被修改，StringBuffer是一个字符串缓冲区值可以修改
2.String的值因为不能修改所以共享，而StringBuffer不能共享
3.如果字符串被频繁大量修改建议使用StringBuffer，效率高些，反之使用String

**三.StringBuilder:**一个线程不安全的可变字符序列//多线程不安全
字符串缓冲区是单线程

四.正则表达式
[abc] a,b或c(简单类)
[^abc] 任何字符，除了a,b,c（否定）
[a-zA-Z] a-z或A-Z两头字母在内（范围）（并集）
[a-z&&[def]] d e f(交集）
. 代表任意字符
\d 代表0-9数字 [0-9]
\D 代表非数字[^0-9]
^ 正则的开始
$ 正则的结束
数量词
X? 一次或一次也没有
X* 零次或多次
X+ 一次或多次
X{n}; 恰好n次
X{n,} 至少n次
X{n,m}; 至少n次，但不超过n次

五.数学类：Math
常用的数学运算，这个类不能被new，也就是说无法产生这个类的对象，这个类的方法和属性都是静态的
类型变量=Math.random();//获取一个随机小数，它的范围是0-1
类型变量=Math.max(99,1);获取两个数的最大值
类型变量=Math.min(99,1);//获取两个数的最小值
类型变量=Math.floor(3.66);//向下取整
类型变量=Math.round(6.33)//四舍五入
类型变量=Math.ceil(3.14);//向上取整
类型变量=Math.PI;//获取圆周率，它是一个常量
类型变量=Math.E;//获取E，它是一个常量
类型变量=Math

六.Object类：获取一个副本
clone：创建并返回此类对象的一个副本
equals：比较两个对象的地址是否相等//等同于==的作用
finalize：当垃圾回收器确定没有这个对象的更多引用时（使用），这个对象会调用这个方法清扫它
getClass：得到当前对象的类型，返回这个类型
hashCode：返回该对象的哈希码值
notify：唤醒当前等待的线程
notifyAll：唤醒所有等待的线程
wait：让当前的线程等待，(long timeout):超过指定的时间量前，让当前线程等待
Object equals比较的是地址，String equals比较的是值（因为重写了）
hashCode：内容码值，String将他重写了，只要值相同的，地址就相同

七.时间类：Date获取时间
Date d1=new Date();//获取当前时间（当前系统时间）
Date d2=new Date(year:119,month:2,date:3)//获取指定时间119（1900+119）:公元年元从1900年的1月1号开始计时，第一天周日，month:从0开始
Date d2=new Date(year:119,month:2,date:3,hrs:2,min:3,sec:4)
标准基准时间（历元）1970年1月1日
Date date=new Date();//获取当前距离历元相差的毫秒数

Date date=new Date()//时间格式化类
SimpleDateFormat sdf=new SipmleDateFormat(pattern:“yyyy年MM月dd日 HH:mm:ss”);
String formatDate =sdf.format(date);
System.out.println(formatDate);
/*
yyyy:年
MM:月
dd:日
d:星期
HH:24时
hh:12时
mm:分
ss:秒
*/
八.日历类
如果父类的构造器都是私有的，子类无法调用该父类的构造器
Calendar calendar=Calendar.getInstance();//获取日历类的对象
int year= calendar.get(Calendar.YEAR);
int month= calendar.get(Calendar.MONTH);
int date= calendar.get(Calendar.DAY_OF_MONTH);

int hour1= calendar.get(Calendar.HOUR_OF_DAY);

int hour2=calendar.get(Calendar.HOUR);
int minute=calendar.get(Calendar.MINUTE);
int second=calendar.get(Calendar.SECOND);
int day=calendar.get(Calendar.DAY_OF_WEEK
封装类：八大封装类
八个原始数据类型，原始数据类型没有方法
为了让原始数据类型可以进行相应操作
提出了对这些原始数据类型进行封装操作
八个原始类型的封装类：Integer Character Double Float Long Boolean Byte Short
两个原始数据类型比较的是值
一个原始数据类型和引用数据类型比较的是值
两个引用数据类型比较的是地址
Integer：
Integet.MAX_VALUE;
Integet.MIN_VALUE;
Integet.parseInt()//将类型转化为int型
Integet.parseInt(变量名: ,radix:几进制)//将类型转化为int型的十进制数
Integet.toBinaryString()二进制
Integet.toOctalString()八进制
Integet.toHexString()十六进制

第五章异常处理

异常：程序在运行中出现不正常的现象叫异常，它会终止正在运行的程序
异常的分类：所有的异常都有一个共同的父类Exception
Exception划分：

运行时异常：代码编译通过，但在运行时出现问题的异常，RuntimeException
编译时异常：连编译都无法通过的异常，它没有共同的父类

（1）代码有可能出现异常：当产生异常时，进入catch块进行处理

抓住异常，并处理它：try catch finally
抛出异常，不管它：throw throws
1）将可能出现的代码块使用try括起来（这里面的代码块就是可能出现异常的区域）
2）使用catch块对异常进行相应的处理（处理方案）
（2）代码有可能产生异常：如果代码未出现异常，会执行完try的内容后，不再执行catch内容，结束异常处理逻辑
（3）代码有可能出现异常，结果发生了异常，产生的异常对象和将要处理的异常类型未匹配上，异常处理失败，终止代码执行
ArithmeticException：数学异常
ArrayIndexOutOfBoundException：数组越界异常
ClassCastException：类型转换异常
ClassNotFoundException：未找到类异常
NullPointException：空指针异常
NumberFormatException：数字格式化异常
RuntimeException：运行时异常
StringIndexOutOfBoundException：字符串索引越界异常
FileNotFoundException：文件未找到异常
IOException：进行输入输出时出现的异常
ConnectException：网络通讯异常
SocketException：通信连接异常
SQLException：数据库连接异常
异常处理：抓住异常
如果出现异常，首先匹配第一个catch块，匹配上进入处理方案，然后结束异常处理
未匹配上，开始匹配下一个catch块，依次执行
多重catch块的问题：先书写子类，后书写父类，（父类更通用，子类更具体）

引入finally块：
try:可能出现的异常代码块
catch：对异常的处理方案
finally:不管发生什么情况，都会执行的代码块
try{ //只有一个
}catch(异常对象){//可以多个
}finally{//只有一个
总会执行的代码块
}
final:方法修饰符，修饰类属性方法，类不能被继承，属性值不能修改，方法不能被重写
finalize：Object的一个方法：当对象没有被过多引用时，会调用这个方法来清除它
finally：异常处理，不管发生什么，都会执行的代码块

异常处理->抛出异常
throws:
出现异常了，将异常抛出去，谁使用了我的方法，谁处理异常
e.getMessage()
e.printStackTrace()
手动产生的异常必须在调用时强制处理
自定义异常：创建一个类，让这个类继承Exception或者它的子类

异常和错误：
异常：程序在运行中出现不正常的现象叫异常，它会终止正在运行的程序
错误：一个正常的程序在进行过程中出现了不正常现象，这些现象程序员无法处理(如：内存溢出)，他就是一个错误，有一个父类Error
Error和Exception有一个共同的父类：Throwable