Java学习笔记（四）
final关键字
概念：final 关键字代表最终、不可改变的
常见的四种用法：
- 可以用来修饰一个类
- 可以用来修饰一个方法
- 可以用来修饰一个局部变量
- 可以用来修饰一个成员变量
final关键字修饰类
当 final 关键字用来修饰一个类的时候，这个类不能有任何子类，不能使用一个 final 类作为父类
格式：
public final class 类名称{
//....
}
注意：一个类如果是 final 的，那么其中所有的成员方法都无法进行覆盖重写
final关键字修饰方法
当 final 关键字修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写
格式：
修饰符 final 返回值类型 方法名称(参数列表){
//方法体
}
注意事项：
对于类，方法来说，abstract关键字和final关键字不能同时使用，因为矛盾
final关键字修饰局部变量
一旦使用 final 来修饰局部变量，那么这个变量就不能进行更改
一次赋值，终身不变
- 对于基本数据类型来说，不可变说的是变量当中的数据不可改变
- 对于引用类型来说，不可变说的是变量中的地址值不可改变
final关键字修饰成员变量
对于成员变量来说，如果使用了 final 关键字修饰，那么这个变量照样是不可变的
- 由于成员变量具有默认值，所以用了 final 之后必须手动赋值，不会再给默认值了
- 对于 final 的成员变量，要么使用直接赋值，要么通过构造方法赋值，二者选其一
- 如果通过构造方法赋值，必须保证类当中所有重载的构造方法，都最终会对 final 的成员变量进行赋值
四种权限修饰符
Java中有四种权限修饰符：
//权限大小:
public > protected > (default) > private
| public | protected | default | private | |
|---|---|---|---|---|
| 同一个类(我自己) | yes | yes | yes | yes |
| 同一个包(我邻居) | yes | yes | yes | no |
| 不同包子类(我儿子) | yes | yes | no | no |
| 不同包非子类(陌生人) | yes | no | no | no |
注意事项：(default)并不是关键字，而是根本不写
内部类
概念：一个类的内部包含另一个类
分类：
- 成员内部类
- 局部内部类（包含匿名内部类）
成员内部类
定义格式：
修饰符 class 外部类名称{
修饰符 class 内部类名称{
//...
}
//....
}
注意：内用外，随意访问，外用内，需要内部类对象
public class Body{//外部类
public class Heart{//成员内部类
//内部类的方法
public void beat(){
System.out.println("心脏跳动");
System.out.println("我叫：" + name);//正确写法
}
}
//外部类的成员变量
private String name;
//外部类的方法
public void methodBody(){
System.out.println("外部类的方法");
Heart heart = new Heart();
heart.beat();
}
public String getName(){
return name;
}
public void setName(String name){
this.name = name;
}
}
如何使用成员内部类
-
间接使用：在外部类的方法中，使用内部类，然后main方法只是调用外部类的方法
-
直接使用：
公式：
外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();
public class Demo{
public static void main(String[] args){
Body body = new Body();//外部类的对象
//间接使用：通过外部类的对象，调用外部类的方法，里面简介调用了内部类Heart
body.methodBody();
//直接使用：使用公式
Body.Heart heart = new Body().new Heart();
heart.beat();
}
}
内部类的同名变量访问
/*
如果出现了重名现象，那么格式是：外部类名称.this.外部类成员变量名
*/
public class Outer{
int num = 10;//外部类的成员变量
public class Inner{
int num = 20;//内部类的成员变量
public void methodInner(){
int num = 30;//内部类方法的局部变量
System.out.println(num);//局部变量，就近原则 30
System.out.println(this.num);//内部类的成员变量 20
System.out.println(Outer.this.num);//外部类的成员变量 10
}
}
}
public class Demo{
public static void main(String[] args){
Outer.Inner obj = new Outer().new Inner();
obj.methodInner();
}
}
局部内部类
如果一个类是定义再一个方法内部，那么这就是一个局部内部类
“局部”：只有当前所属的方法才能使用它，出了这个方法外面就不能使用了
定义格式：
修饰符 class 外部类名称{
修饰符 返回值类型 外部方法名称(参数列表){
class 局部内部类名称{
//...
}
}
}
public class Outer{
public void methodOuter(){
class Inner{//局部内部类
int num = 10;
public void methodInner(){
System.out.println(num);//10
}
}
Inner inner = new Inner();
inner.methodInner();
}
}
public class Demo{
public static void main(String[] args){
Outer outer = new Outer();
outer.methodOuter();//10
}
}
定义一个类的时候，权限修饰符规则：
- 外部类：public / (default)
- 成员内部类：public / protected / (default) / private
- 局部内部类：什么都不写
局部内部类的 final 问题
/*
局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是有效final的
从Java 8+开始，只要局部变量事实不变，那么final关键字可以省略
原因：
1、new出来的对象在堆当中
2、局部变量是跟着方法走的，在栈内存当中
3、方法运行结束后，立刻出栈，局部变量就会立马消失
4、但是new出来的对象会在堆当中持续存在，直到垃圾回收消失
*/
public class MyOuter{
public void methodOuter(){
final int num = 10;//所在方法的局部变量
class MyInner{
public void methodInner(){
System.out.println(num);
}
}
}
}
匿名内部类
如果接口的实现类（或者是父类的子类）只需要使用唯一的一次，那么这种情况下就可以省略该类的定义，而改为使用匿名内部类
格式：
接口名称 对象名 = new 接口名称(){
//覆盖重写所有抽象方法
};
public interface MyInterface{
void method();
}
public class MyInterfaceImpl implements MyInterface{
@Overrid
public void method(){
System.out.println("覆盖重写了方法");
}
}
public class Demo{
public static void main(String[] args){
//实现接口通过多态方式调用方法
MyInterface obj = new MyInterfaceImpl();
obj.method();//覆盖重写了方法
//使用匿名内部类
MyInterface obj = new MyInterface(){
@Overrid
public void method(){
System.out.println("匿名内部类实现了方法");
}
};
obj.method();//匿名内部类实现了方法
}
}
注意事项：
对格式“new 接口名称() {…}”解析
- new代表拆功能键对象的动作
- 接口名称就是匿名内部类需要实现那个接口
- {…}这才是匿名内部类的内容
另外还需要注意
-
匿名内部类，在创建的时候，只能使用唯一一次
如果希望多次创建对象，而且类的内容一样的话，那么就必须单独定义实现类了
-
匿名对象，在调用方法的时候，只能调用唯一一次
如果希望同一个对象，调用多次方法，那么必须给对象起个名字
-
匿名内部类是省略了实现类/子类名称，但是匿名对象是省略了对象名称
强调:匿名内部类和匿名对象不是一回事！！！
Object类
概念：java.lang.Object类是Java语言的根类，即所有类的父类，它中描述的所有方法子类都可以使用，在对象实例化的时候，最终找的父类就是Object
如果一个类没有特别指定父类，那么默认则继承Object类
public class MyClass /*extends Object*/{
//..
}
toString方法
toString的作用：以良好的格式，更方便的展示对象中的属性值
public String toString() //返回该对象的字符串表示
class Student extends Object {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
public class ObjectDemo {
public static void main(String[] args) {
Student s = new Student();
s.setName("林青霞");
s.setAge(30);
System.out.println(s);
System.out.println(s.toString());
}
}
//结果
//Student{name='林青霞', age=30}
//Student{name='林青霞', age=30}
equals方法
equals方法的作用：用于对象之间的比较，返回true和false的结果
/*
equals方法源码：
public boolean equals(Object obj){
return (this == obj); 那个对象调用的方法，方法中的this就是那个对象
}
基本数据类型：比较的是值
引用数据类型：比较的是对象的地址值
*/
public boolean equals(Object obj) //代表其他某个对象是否与次对象相等
调用成员方法equals并指定参数为另一个对象，则可以判断这两个对象是否相等：
- 默认地址比较
如果没有覆盖重写equals方法，那么Object类中默认进行==运算符的对象地址比较
- 对象内容比较
如果希望进行对象的内容比较，即所有或指定的部分成员变量相同就判断两个对象相同，则可以 覆盖重写equals方法
class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public boolean equals(Object o) {
//this -- s1
//o -- s2
if (this == o) return true;
//getClass() != o.getClass()使用反射技术，判断o是否是Student类型，等效于 obj instance Student
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o; //student -- s2
if (age != student.age) return false;
return name != null ? name.equals(student.name) : student.name == null;
}
}
public class ObjectDemo {
public static void main(String[] args) {
Student s1 = new Student();
s1.setName("林青霞");
s1.setAge(30);
Student s2 = new Student();
s2.setName("林青霞");
s2.setAge(30);
//需求：比较两个对象的内容是否相同
System.out.println(s1.equals(s2));
}
}
Objects类的equals方法
对两个对象进行比较，防止空指针异常
//源码
public static boolean equals(Object a,Object b){
return (a==b) || (a != null && a.equals(b));
}
String s1 = null;
String s2 = "abc";
boolean result = Objects.equals(s1,s2);//false
日期时间类
Date类
概述：java.util.Date类表示特定的瞬间，精确到毫秒
public Date() //自动设置当前系统时间的毫秒值
public Date(long date) //自定义毫秒时刻，以表示自从标准基准时间(称为“历元(epoch)”,即1970年1月1日00:00:00 GMT)以来的指定毫秒数
注意：我们处于东八区，所以我们的基准时间为1970年1月1日8时0分0秒
public class Demo {
public static void main(String[] args) {
//public Date()：分配一个 Date对象，并初始化，以便它代表它被分配的时间，精确到毫秒
Date d1 = new Date();
System.out.println(d1);//Sun Apr 04 17:13:20 CST 2021
//public Date(long date)：分配一个 Date对象，并将其初始化为表示从标准基准时间起指定的毫秒数
long date = 1000*60*60;
Date d2 = new Date(date);
System.out.println(d2);//Thu Jan 01 09:00:00 CST 1970
}
}
常用方法：
public long getTime() //获取的是日期对象从1970年1月1日 00:00:00到现在的毫秒值
public void setTime(long time)//设置时间，给的是毫秒值
public class Demo{
public static void main(String[] args) {
//创建日期对象
Date d = new Date();
//public long getTime():获取的是日期对象从1970年1月1日 00:00:00到现在的毫秒值
// System.out.println(d.getTime());
// System.out.println(d.getTime() * 1.0 / 1000 / 60 / 60 / 24 / 365 + "年");
//public void setTime(long time):设置时间，给的是毫秒值
// long time = 1000*60*60;
long time = System.currentTimeMillis();
d.setTime(time);
System.out.println(d);//Sun Apr 04 17:15:38 CST 2021
}
}
SimpleDateFormat类
概述：SimpleDateFormat是一个具体的类，用于以区域设置敏感的方式格式化和解析日期
构造方法：
public SimpleDateFormat() //构造一个SimpleDateFormat，使用默认模式和日期格式
public SimpleDateFormat(String pattern) //构造一个SimpleDateFormat使用给定的模式和默认的日期格式
SimpleDateFormat类的常用方法
- 格式化(从Date到String)
- public final String format(Date date)：将日期格式化成日期/时间字符串
- 解析(从String到Date)
- public Date parse(String source)：从给定字符串的开始解析文本以生成日期
public class SimpleDateFormatDemo {
public static void main(String[] args) throws ParseException {
//格式化：从 Date 到 String
Date d = new Date();
// SimpleDateFormat sdf = new SimpleDateFormat();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
String s = sdf.format(d);
System.out.println(s);//2021年04月04日 17:19:16
System.out.println("--------");
//从 String 到 Date
String ss = "2048-08-09 11:11:11";
//ParseException
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date dd = sdf2.parse(ss);
System.out.println(dd);//Sun Aug 09 11:11:11 CST 2048
}
}
日期工具类案例
-
案例需求
定义一个日期工具类(DateUtils)，包含两个方法：把日期转换为指定格式的字符串；把字符串解析为指定格式的日期，然后定义一个测试类(DateDemo)，测试日期工具类的方法
public class DateUtils {
private DateUtils() {}
/*
把日期转为指定格式的字符串
返回值类型：String
参数：Date date, String format
*/
public static String dateToString(Date date, String format) {
SimpleDateFormat sdf = new SimpleDateFormat(format);
String s = sdf.format(date);
return s;
}
/*
把字符串解析为指定格式的日期
返回值类型：Date
参数：String s, String format
*/
public static Date stringToDate(String s, String format) throws ParseException {
SimpleDateFormat sdf = new SimpleDateFormat(format);
Date d = sdf.parse(s);
return d;
}
}
public class DateDemo {
public static void main(String[] args) throws ParseException {
//创建日期对象
Date d = new Date();
String s1 = DateUtils.dateToString(d, "yyyy年MM月dd日 HH:mm:ss");
System.out.println(s1);
String s2 = DateUtils.dateToString(d, "yyyy年MM月dd日");
System.out.println(s2);
String s3 = DateUtils.dateToString(d, "HH:mm:ss");
System.out.println(s3);
System.out.println("--------");
String s = "2048-08-09 12:12:12";
Date dd = DateUtils.stringToDate(s, "yyyy-MM-dd HH:mm:ss");
System.out.println(dd);
}
}
Calendar类
概述：
-
Calendar 为特定瞬间与一组日历字段之间的转换提供了一些方法，并为操作日历字段提供了一些方法
-
Calendar 提供了一个类方法 getInstance 用于获取这种类型的一般有用的对象。
-
该方法返回一个Calendar 对象。
-
其日历字段已使用当前日期和时间初始化：Calendar rightNow = Calendar.getInstance();
Calendar类常用方法
public int get(int field) //返回给定日历字段的值
public abstract void add(int field, int amount) //根据日历的规则，将指定的时间量添加或减去给定的日历字段
public final void set(int year,int month,int date) //设置当前日历的年月日
public class CalendarDemo {
public static void main(String[] args) {
//获取日历类对象
Calendar c = Calendar.getInstance();
//public int get(int field):返回给定日历字段的值
int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH) + 1;
int date = c.get(Calendar.DATE);
System.out.println(year + "年" + month + "月" + date + "日");//2021年4月4日
//public abstract void add(int field, int amount):根据日历的规则，将指定的时间量添加或减去给定的日历字段
//需求1:3年前的今天
// c.add(Calendar.YEAR,-3);
// year = c.get(Calendar.YEAR);
// month = c.get(Calendar.MONTH) + 1;
// date = c.get(Calendar.DATE);
// System.out.println(year + "年" + month + "月" + date + "日");
//需求2:10年后的10天前
// c.add(Calendar.YEAR,10);
// c.add(Calendar.DATE,-10);
// year = c.get(Calendar.YEAR);
// month = c.get(Calendar.MONTH) + 1;
// date = c.get(Calendar.DATE);
// System.out.println(year + "年" + month + "月" + date + "日");
//public final void set(int year,int month,int date):设置当前日历的年月日
c.set(2050,10,10);
year = c.get(Calendar.YEAR);
month = c.get(Calendar.MONTH) + 1;
date = c.get(Calendar.DATE);
System.out.println(year + "年" + month + "月" + date + "日");//2050年11月10日
}
}
System类
System类的常用方法
public static void exit(int status) //终止当前运行的 Java 虚拟机，非零表示异常终止
public static long currentTimeMillis() //返回当前时间(以毫秒为单位)
/*
在控制台输出1-10000，计算这段代码执行了多少毫秒
*/
public class SystemDemo {
public static void main(String[] args) {
// 获取开始的时间节点
long start = System.currentTimeMillis();
for (int i = 1; i <= 10000; i++) {
System.out.println(i);
}
// 获取代码运行结束后的时间节点
long end = System.currentTimeMillis();
System.out.println("共耗时：" + (end - start) + "毫秒");
}
}
186
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
