Javase基础知识

置顶 BigBigmin

已于 2022-06-29 21:23:38 修改

阅读量295

点赞数 1

文章标签： java 开发语言后端

于 2021-12-26 23:25:06 首次发布

本文链接：https://blog.csdn.net/BigBigmin/article/details/122152762

版权

一、面想对象

三大特征

封装

封装，即隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别；将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合，形成“类”，其中数据和函数都是类的成员。

生活案例：
ATM , 电线
Java中封装的理解：
将某些东西进行隐藏，然后提供相应的方式进行获取。

隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

封装的好处：提高代码的安全性

代码：

public class Girl {//女孩
    //属性：
    private int age;
    //读取年龄：
    public int getAge(){
        return age;
    }
    //设置年龄：
    public void setAge(int age){
        if(age >= 30 ){
            this.age = 18;
        }else{
            this.age = age;
        }
    }
}

测试方法：

public class Test {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //创建一个Girl类的对象：
        Girl girl = new Girl();
        /*g.age = 33;
        System.out.println(g.age);*/
        //设置年龄：
        g.setAge(31);
        //读取年龄：
        System.out.println(girl.getAge());
    }
}

上面的代码，对于属性age来说，我加了修饰符private，这样外界对它的访问就受到了限制，现在我还想加上其他的限制条件，但是在属性本身上没有办法再加了，所以我们通过定义方法来进行限制条件的添加。
以属性为案例：
进行封装：
（1）将属性私有化，被private修饰–> 加入权限修饰符
一旦加入了权限修饰符，其他人就不可以随意的获取这个属性
（2）提供public修饰的方法让别人来访问/使用
（3）即使外界可以通过方法来访问属性了，但是也不能随意访问，因为咱们在方法中可以加入限制条件。

加深练习:
代码：

public class Student {
    //属性：
    private int age;
    private String name;
    private String sex;
    //加入对应的setter和getter方法：
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        if("男".equals(sex) || "女".equals(sex) ){//sex是男 或者 是 女
            this.sex = sex;
        }else{
            this.sex = "男";
        }
    }
    //加入构造器：
    public Student(){
    }
    public Student(int age,String name,String sex){
        this.age = age;
        this.name = name;
        //this.sex = sex;
        this.setSex(sex);
    }
}

测试类：

public class Test {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //创建一个Student对象：
        Student s1 = new Student();
        s1.setName("张三");
        s1.setAge(19);
        s1.setSex("女");
        System.out.println(s1.getName()+"---"+s1.getAge()+"----"+s1.getSex());//张三---19----女
        Student s2 = new Student(18,"李四","asdfsadf");
        System.out.println(s2.getName()+"---"+s2.getAge()+"----"+s2.getSex());//李四---18----男
    }
}

继承

在这里插入图片描述
特点：

父类：

public class Person {
    //属性：
    private int age;
    private String name;
    private double height;
    //提供setter getter方法：
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getHeight() {
        return height;
    }
    public void setHeight(double height) {
        this.height = height;
    }
    //方法：
    public void eat(){
        System.out.println("可以吃饭。。。");
    }
    public void sleep(){
        System.out.println("可以睡觉。。。");
    }
}

子类：

public class Student extends Person {//子类Student 继承  父类Person
    //属性：
    private int sno;//学号
    public int getSno() {
        return sno;
    }
    public void setSno(int sno) {
        this.sno = sno;
    }
    //方法：
    public void study(){
        System.out.println("学生可以学习");
    }
}

测试类：

public class Test {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //创建子类Student的对象
        Student s = new Student();
        s.setSno(1001);
        s.setAge(18);
        s.setName("菲菲");
        s.setHeight(180.4);
        System.out.println("学生名字为："+s.getName()+",学生的年纪："+s.getAge());
        //访问方法：
        s.study();
        s.eat();
        s.sleep();
    }

结果：

学生名字为：张三,学生的年纪：18
学生可以学习
可以吃饭。。。
可以睡觉。。。

继承中成员方法的访问特点

不重名
重名
看new的是谁，先用谁的方法，子类没有找父类-子债父偿

方法的重写

1.概述：子类有一个和父类一模一样的方法
2.访问特点：看new的是谁，先调用谁，子类没有找父类
3.注解：@Override–>可以检测此方法是不是重写方法
4.前提：子父类继承父类
5.注意事项：
·子类方法覆盖父类方法，必须要保证权限大于等于父类权限。
public protected 默认（default） private
· 子类方法覆盖父类方法，返回值类型、函数名和参数都要一模一样。
·私有方法不能被重写（父类私有成员子类是不能继承的）
·子类方法重写父类方法，子类的方法返回值要是父类方法值得子类或者一样

总结：方法的重写就是和父类一模一样。
在这里插入图片描述

继承中子父类构造方法的访问特点

在这里插入图片描述

#### 继承中super的使用（在子类中） ![在这里插入图片描述](https://img-blog.csdnimg.cn/2fc628f45c0948bcb03e94e54b847fa7.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAQmlnQmlnbWlu,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center) 【1】super:指的是：父类的【2】super可以修饰属性，可以修饰方法；在子类的方法中，可以通过 super.属性 super.方法的方式，显示的去调用父类提供的属性，方法。在通常情况下，super.可以省略不写： ![在这里插入图片描述](https://img-blog.csdnimg.cn/f9161e71411f41aeb18f5b69fdf01cdc.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAQmlnQmlnbWlu,size_20,color_FFFFFF,t_70,g_se,x_16)

在特殊情况下，当子类和父类的属性重名时，你要想使用父类的属性，必须加上修饰符super.，只能通过super.属性来调用
在特殊情况下，当子类和父类的方法重名时，你要想使用父类的方法，必须加上修饰符super.，只能通过super.方法来调用
在这种情况下，super.就不可以省略不写。
在这里插入图片描述
【3】super修饰构造器：
其实我们平时写的构造器的第一行都有：super() -->作用：调用父类的空构造器，只是我们一般都省略不写
（所有构造器的第一行默认情况下都有super(),但是一旦你的构造器中显示的使用super调用了父类构造器，那么这个super()就不会给你默认分配了。如果构造器中没有显示的调用父类构造器的话，那么第一行都有super(),可以省略不写）
在这里插入图片描述

如果构造器中已经显示的调用super父类构造器，那么它的第一行就没有默认分配的super();了
在这里插入图片描述

在构造器中，super调用父类构造器和this调用子类构造器只能存在一个，两者不能共存：
因为super修饰构造器要放在第一行，this修饰构造器也要放在第一行：
在这里插入图片描述

改正二选一即可：
在这里插入图片描述

【4】以后写代码构造器的生成可以直接使用IDEA提供的快捷键：alt+insert
在这里插入图片描述

继承的好处：提高代码的复用性
父类定义的内容，子类可以直接拿过来用就可以了，不用代码上反复重复定义了

需要注意的点：
父类private修饰的内容，子类实际上也继承，只是因为封装的特性阻碍了直接调用，但是提供了间接调用的方式，可以间接调用。
总结：
（1）继承关系：

父类/基类/超类
子类/派生类
子类继承父类一定在合理的范围进行继承的子类 extends 父类

（2）继承的好处：

提高了代码的复用性，父类定义的内容，子类可以直接拿过来用就可以了，不用代码上反复重复定义了
便于代码的扩展
为了以后多态的使用。是多态的前提。

（3）父类private修饰的内容，子类也继承过来了。
（4）一个父类可以有多个子类。
（5）一个子类只能有一个直接父类。
但是可以间接的继承自其它类。
（6）继承具有传递性：
Student ->继承自 Person ->继承自Object
Object类是所有类的根基父类。
所有的类都直接或者间接的继承自Object。

多态

【1】多态跟属性无关，多态指的是方法的多态，而不是属性的多态。
【2】案例代入：

public class Animal {//父类：动物：
    public void shout(){
        System.out.println("我是小动物，我可以叫。。。");
    }
}

狗类：

public class Dog extends Animal{
    //喊叫：
    public void shout(){
        System.out.println("我是小狗，我可以汪汪叫");
    }
    public void guard(){
        System.out.println("我是小狗，我可以看家护院，保护我的小主人。。。");
    }
}

猪类：

public class Pig extends Animal{
    public void shout(){
        System.out.println("我是小猪，我略略略的叫");
    }
    public void eat(){
        System.out.println("我是小猪，我爱吃东西。。");
    }
}

小女孩类：

public class Girl {
    //跟狗玩耍：
    /*public void play(Dog dog){
        dog.shout();
    }*/
    //跟猪玩耍：
    /*public void play(Pig pig){
        pig.shout();
    }*/
    //跟小动物玩耍：
    public void play(Animal an){
        an.shout();
    }
}

测试类：

public class Test {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
    	//具体的小女孩：--》女孩的对象
        Girl girl = new Girl();
        //具体的狗---》狗的对象：
        //Dog dog = new Dog();
        //小女孩跟狗玩：
        //girl.play(dog); //我是小狗，我可以汪汪叫
        
        //具体的猪：--》猪的对象
        //Pig pig = new Pig();
        //小女孩跟猪玩：
        //girl.play(pig); //我是小猪，我略略略的叫
        //---上面写的这两种方法不够灵活---//
        
        //具体的动物：--》动物的对象：
        //Dog dog = new Dog();
        Pig pig = new Pig();
        Animal an = pig;   //Animal an = new Pig();
        girl.play(an);  //我是小猪，我略略略的叫
    }
}

【3】总结：
（1）先有父类，再有子类：–》继承先有子类，再抽取父类 ----》泛化
（2）什么是多态：
多态就是多种状态：同一个行为，不同的子类表现出来不同的形态。
多态指的就是同一个方法调用，然后由于对象不同会产生不同的行为。

（3）多态的好处：
为了提高代码的扩展性，符合面向对象的设计原则：开闭原则。
开闭原则：指的就是扩展是开放的，修改是关闭的。
注意：多态可以提高扩展性，但是扩展性没有达到最好。-- 反射
（4）多态的要素：
一，继承： Cat extends Animal ,Pig extends Animal, Dog extends Animal
二，重写：子类对父类的方法shout()重写
三，父类引用指向子类对象：

Pig p = new Pig();
Animal an = p;
将上面的代码合为一句话：Animal an = new Pig();
=左侧：编译期的类型
=右侧：运行期的类型

向下转型，向上转型

在这里插入图片描述

想访问到eat()方法和weight属性：

public class Demo {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        Pig p = new Pig();
        Animal an = p;//转型：向上转型                         转型
        an.shout(); //我是小猪，我嗯嗯嗯的叫
        //加入转型的代码：
        //将Animal转为Pig类型： 
        Pig pig = (Pig)an ;//转型：向下转型                    转型
        pig.eat(); //我是小猪，我爱吃东西。。
        pig.age = 10;
        pig.weight = 60.8;
    }
}

对应内存：
在这里插入图片描述

抽象类

【1】抽象类和抽象方法的关系：抽象类中可以定义0-n个抽象方法。
【2】抽象类作用：
在抽象类中定义抽象方法，目的是为了为子类提供一个通用的模板，子类可以在模板的基础上进行开发，先重写父类的抽象方法，然后可以扩展子类自己的内容。抽象类设计避免了子类设计的随意性，通过抽象类，子类的设计变得更加严格，进行某些程度上的限制。
使子类更加的通用。
【3】代码：

//4.一个类中如果有方法是抽象方法，那么这个类也要变成一个抽象类。
//5.一个抽象类中可以有0-n个抽象方法
public abstract class Person {
    //1.在一个类中，会有一类方法，子类对这个方法非常满意，无需重写，直接使用
    public void eat(){
        System.out.println("一顿不吃饿得慌");
    }
    //2.在一个类中，会有一类方法，子类对这个方法永远不满意，会对这个方法进行重写。
    //3.一个方法的方法体去掉，然后被abstract修饰，那么这个方法就变成了一个抽象方法
    public abstract void say();
    public abstract void sleep();
}
//6.抽象类可以被其他类继承：
//7.一个类继承一个抽象类，那么这个类可以变成抽象类
//8.一般子类不会加abstract修饰，一般会让子类重写父类中的抽象方法
//9.子类继承抽象类，就必须重写全部的抽象方法
//10.子类如果没有重写父类全部的抽象方法，那么子类也可以变成一个抽象类。
class Student extends Person{
    @Override
    public void say() {
        System.out.println("我是东北人，我喜欢说东北话。。");
    }
    @Override
    public void sleep() {
        System.out.println("东北人喜欢睡炕。。");
    }
}
class Demo{
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //11.创建抽象类的对象：-->抽象类不可以创建对象
        //Person p = new Person();
        //12.创建子类对象：
        Student s = new Student();
        s.sleep();
        s.say();
        
        //13.多态的写法：父类引用只想子类对象：
        Person p  = new Student();
        p.say();
        p.sleep();
    }
}

接口

【1】接口声明格式：

[访问修饰符] interface 接口名 [extends 父接口1，父接口2…] {
常量定义；
方法定义；
}

【2】代码：

package com.msb.test04;
/**
 * 1.类是类，接口是接口，它们是同一层次的概念。
 * 2.接口中没有构造器
 * 3.接口如何声明：interface
 * 4.在JDK1.8之前，接口中只有两部分内容：
 * （1）常量：固定修饰符：public static final
 * （2）抽象方法：固定修饰符：public abstract
 * 注意：修饰符可以省略不写，IDE会帮你自动补全，但是初学者建议写上，防止遗忘。
 */
public interface TestInterface01 {
    //常量：
    /*public static final*/ int NUM = 10;
    //抽象方法：
    /*public abstract*/ void a();
    /*public abstract*/ void b(int num);
    /*public abstract*/ int c(String name);
}
interface TestInterface02{
    void e();
    void f();
}
/*
5.类和接口的关系是什么？ 实现关系  类实现接口：
6.一旦实现一个接口，那么实现类要重写接口中的全部的抽象方法：
7.如果没有全部重写抽象方法，那么这个类可以变成一个抽象类。
8.java只有单继承，java还有多实现
一个类继承其他类，只能直接继承一个父类
但是实现类实现接口的话，可以实现多个接口
9.写法：先继承 再实现：extends Person implements TestInterface01,TestInterface02
 */
class Student extends Person implements TestInterface01,TestInterface02 {
    @Override
    public void a() {
        System.out.println("---1");
    }
    @Override
    public void b(int num) {
        System.out.println("---2");
    }
    @Override
    public int c(String name) {
        return 100;
    }
    @Override
    public void e() {
        System.out.println("---3");
    }
    @Override
    public void f() {
        System.out.println("---4");
    }
}
class Test{
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //10.接口不能创建对象：
        //TestInterface02 t = new TestInterface02();
        TestInterface02 t = new Student();//接口指向实现类 ---》多态
        //11.接口中常量如何访问：
        System.out.println(TestInterface01.NUM);
        System.out.println(Student.NUM);
        Student s = new Student();
        System.out.println(s.NUM);
        TestInterface01 t2 = new Student();
        System.out.println(t2.NUM);
    }
}

【3】接口的作用是什么？
定义规则，只是跟抽象类不同地方在哪？它是接口不是类。
接口定义好规则之后，实现类负责实现即可。

【4】
继承：子类对父类的继承
实现：实现类对接口的实现

【5】多态的应用场合：
（1）父类当做方法的形参，传入具体的子类的对象
（2）父类当做方法的返回值，返回的是具体的子类的对象
（3）接口当做方法的形参，传入具体的实现类的对象
（4）接口当做方法的返回值，返回的是具体的实现类的对象

【6】接口和抽象类的区别：

在这里插入图片描述

在JDK1.8之后，新增非抽象方法

在JDK1.8之前，接口中只有两部分内容：
（1）常量：固定修饰符：public static final
（2）抽象方法：固定修饰符：public abstract

在JDK1.8之后，新增非抽象方法：
（1）被public default修饰的非抽象方法：
注意1：default修饰符必须要加上，否则出错
注意2：实现类中要是想重写接口中的非抽象方法，那么default修饰符必须不能加，否则出错。

public interface TestInterface {
    //常量：
    public static final int NUM= 10;
    //抽象方法：
    public abstract void a();
    //public default修饰的非抽象方法：
    public default void b(){
        System.out.println("-------TestInterface---b()-----");
    }
}
class Test implements TestInterface{
    public void c(){
        //用一下接口中的b方法：
        b();//可以
        //super.b();不可以
        TestInterface.super.b();//可以
    }
    @Override
    public void a() {
        System.out.println("重写了a方法");
    }
    @Override
    public void b() {
    }
}

（2）静态方法：
注意1：static不可以省略不写
注意2：静态方法不能重写

public interface TestInterface2 {
    //常量：
    public static final int NUM = 10;
    //抽象方法：
    public abstract  void a();
    //public default非抽象方法；
    public default void b(){
        System.out.println("-----TestInterface2---b");
    }
    //静态方法：
    public static void c(){
        System.out.println("TestInterface2中的静态方法");
    }
}
class Demo implements TestInterface2{
    @Override
    public void a() {
        System.out.println("重写了a方法");
    }
    public static void c(){
        System.out.println("Demo中的静态方法");
    }
}
class A {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        Demo d = new Demo();
        d.c(); //Demo中的静态方法
        Demo.c(); //Demo中的静态方法
        TestInterface2.c();//TestInterface2中的静态方法
    }
}

疑问：为什么要在接口中加入非抽象方法？？？
如果接口中只能定义抽象方法的话，那么我要是修改接口中的内容，那么对实现类的影响太大了，所有实现类都会受到影响。
现在在接口中加入非抽象方法，对实现类没有影响，想调用就去调用即可。

this关键字

【1】创建对象的过程：
（1）在第一次遇到一个类的时候，对这个类要进行加载，只加载一次。
（2）创建对象，在堆中开辟空间
（3）对对象进行初始化操作，属性赋值都是默认的初始值。
（4）new关键字调用构造器，执行构造方法，在构造器中对属性重新进行赋值

在这里插入图片描述

从上面的效果能够看到：this指代的就是当前对象：
从内存上看：
在这里插入图片描述

this关键字用法：

this可以修饰属性：

总结：当属性名字和形参发生重名的时候，或者属性名字和局部变量重名的时候，都会发生就近原则，所以如果我要是直接使用变量名字的话就指的是离的近的那个形参或者局部变量，这时候如果我想要表示属性的话，在前面要加上：this.修饰

如果不发生重名问题的话，实际上你要是访问属性也可以省略this.

public class Person {
    //属性
    int age;
    String name;
    double height;
    //空构造器
    public Person(){
    }
    //有参构造器
    public Person(int age,String name,double height){
        this.age = age;
        this.name = name;
        this.height = height;
    }
    //方法：
    public void eat(){
        int age = 10;
        System.out.println(age);//就近原则，age指的是离它近的age--》局部变量的age
        System.out.println(this.age);//这里指代的就是属性的age
        System.out.println("我喜欢吃饭");
    }
}

this修饰方法：

总结：在同一个类中，方法可以互相调用，this.可以省略不写。

public class Person {
    //属性
    int age;
    String name;
    double height;
    //空构造器
    public Person(){
    }
    //有参构造器
    public Person(int age,String name,double height){
        this.age = age;
        this.name = name;
        this.height = height;
    }
    //方法：
    /*public void eat(){
        int age = 10;
        System.out.println(age);//就近原则，age指的是离它近的age--》局部变量的age
        System.out.println(this.age);//这里指代的就是属性的age
        System.out.println("我喜欢吃饭");
    }*/
    public void play(){
        /*this.*/eat();
        System.out.println("抽烟");
        System.out.println("喝酒");
    }
    public void eat(){
        System.out.println(/*this.*/age);
        System.out.println("烫头");
    }
}

this可以修饰构造器：

总结：同一个类中的构造器可以相互用this调用，注意：this修饰构造器必须放在第一行

public class Person {
    //属性
    int age;
    String name;
    double height;
    //空构造器
    public Person(){
    }
    //有参构造器
    public Person(int age,String name,double height){
        this(age,name);
        this.height = height;
    }
    public Person(int age,String name){
        this(age);
        this.name = name;
    }
    public Person(int age){
        this.age = age;
    }
    //方法：
    /*public void eat(){
        int age = 10;
        System.out.println(age);//就近原则，age指的是离它近的age--》局部变量的age
        System.out.println(this.age);//这里指代的就是属性的age
        System.out.println("我喜欢吃饭");
    }*/
    public void play(){
        /*this.*/eat();
        System.out.println("上网");
        System.out.println("洗澡");
    }
    public void eat(){
        System.out.println(/*this.*/age);
        System.out.println("吃饭");
    }
}

static关键字

static可以修饰：属性，方法，代码块，内部类。

static修饰属性；

一般推荐访问方式：可以通过类名.属性名的方式去访问

public class MsbStudent {
    //属性：
    String name;
    static String age;
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        MsbStudent.age = "今天女朋友70大寿！";  //访问方式1
        //创建学生对象：
        MsbStudent s1 = new MsbStudent();
        s1.name = "张三";
        //s1.age = "今天生日";         //访问方式2
        System.out.println(s1.age);   //今天女朋友70大寿！
    }
}

static修饰方法

static修饰属性总结：
（1）在类加载的时候一起加载入方法区中的静态域中
（2）先于对象存在
（3）访问方式：对象名.属性名类名.属性名（推荐）

public class Demo {
    int id;
    static int sid;
    public void a(){
        System.out.println(id);
        System.out.println(sid);
        System.out.println("------a");
    }
    //1.static和public都是修饰符，并列的没有先后顺序，先写谁后写谁都行
    static public void b(){
        //System.out.println(this.id);//4.在静态方法中不能使用this关键字
        //a();//3.在静态方法中不能访问非静态的方法
        //System.out.println(id);//2.在静态方法中不能访问非静态的属性
        System.out.println(sid);
        System.out.println("------b");
    }
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //5.非静态的方法可以用对象名.方法名去调用
        Demo demo = new Demo();
        demo.a();
        //6.静态的方法可以用   对象名.方法名去调用  也可以 用  类名.方法名 （推荐）
        Demo.b();
        demo.b();
       
    }
}

final关键字

修饰变量

public class Test {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //第1种情况：
        //final修饰一个变量，变量的值不可以改变，这个变量也变成了一个字符常量，约定俗称的规定：名字大写
        final int A = 10;//final修饰基本数据类型
        //A = 20; 报错：不可以修改值
        //第2种情况：
        final Dog d = new Dog();//final修饰引用数据类型，那么地址值就不可以改变
        //d = new Dog(); -->地址值不可以更改
        //d对象里面的属性依然可以改变：
        d.age = 10;
        d.weight = 13.7;
        //第3种情况：
        final Dog d2 = new Dog();
        a(d2);
        //第4种情况：
        b(d2);
    }
    public static void a(Dog d){
        d = new Dog();
    }
    public static void b(final Dog d){//d被final修饰 ，指向不可以改变
        //d = new Dog();  --》报错
    }
}

修饰方法

final修饰方法，那么这个方法不可以被该类的子类重写：
在这里插入图片描述

修饰类

final修饰类，代表没有子类，该类不可以被继承：
一旦一个类被final修饰，那么里面的方法也没有必要用final修饰了（final可以省略不写）
在这里插入图片描述
【4】案例：JDK提供的Math类：看源码发现：
（1）使用Math类的时候无需导包，直接使用即可：

（2）Math类没有子类，不能被其他类继承了
在这里插入图片描述

（3）里面的属性全部被final修饰，方法也是被final修饰的，只是省略不写了
原因：子类没有必要进行重写。

（4）外界不可以创建对象：
Math m = new Math();
在这里插入图片描述
（5）发现Math类中的所有的属性，方法都被static修饰
那么不用创建对象去调用，只能通过类名.属性名类名.方法名去调用

二、异常

【1】在什么情况下，try-catch后面的代码不执行？
（1）throw抛出异常的情况
（2）catch中没有正常的进行异常捕获
（3）在try中遇到return

【2】怎么样才可以将 try-catch后面的代码必须执行？
只要将必须执行的代码放入finally中，那么这个代码无论如何一定执行。

【3】return和finally执行顺序？
先执行finally最后执行return

【4】什么代码会放在finally中呢？
关闭数据库资源，关闭IO流资源，关闭socket资源。

【5】有一句话代码很厉害，它可以让finally中代码不执行!
System.exit(0);//终止当前的虚拟机执行

代码：

public class Test3 {
    public static void main(String[] args) {
        //实现一个功能：键盘录入两个数，求商：
        try{
            Scanner sc = new Scanner(System.in);
            System.out.println("请录入第一个数：");
            int num1 = sc.nextInt();
            System.out.println("请录入第二个数：");
            int num2 = sc.nextInt();
            System.out.println("商："+num1/num2);
            System.exit(0);//终止当前的虚拟机执行
            return;
        }catch(ArithmeticException ex){
            //throw ex;
        }finally {
            System.out.println("----谢谢你使用计算器111");
        }
    }
}

异常分类

在这里插入图片描述
注意：程序中语法错误，逻辑错误都不属于上面的Error，Exception

【2】运行时异常：

public class Test5 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //运行时异常：
        int[] arr = {1,2,3};
        System.out.println(arr.length);
        /*int[] arr2 = null;
        System.out.println(arr2.length);*/
        System.out.println(arr[10]);
    }
}

【3】检查异常：
处理方式1：try-catch嵌套try-catch

public class Test6 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //检查异常：
        try {
            try {
                Class.forName("com.msb.test01.Test").newInstance();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

处理方式2：多重catch

public class Test6 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //检查异常：
        try {
            Class.forName("com.msb.test01.Test").newInstance();
        } catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

处理方式3：throws

public class Test6 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        //检查异常：
        Class.forName("com.msb.test01.Test").newInstance();
    }
}

throw和throws的区别

public class Test7 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) throws Exception {
        //实现一个功能：两个数相除，当除数为0的时候，程序出现异常。
        /*try {
            devide();
        } catch (Exception e) {
            e.printStackTrace();
        }*/
        devide();
    }
    public static void devide() throws Exception {
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入第一个数：");
        int num1 = sc.nextInt();
        System.out.println("请录入第二个数：");
        int num2 = sc.nextInt();
        if(num2 == 0 ){//除数为0 ，制造异常。
            //制造运行时异常：
            /*throw new RuntimeException();*/
            //制造检查异常：
            /*try {
                throw new Exception();
            } catch (Exception e) {
                e.printStackTrace();
            }*/
            throw new Exception();
        }else{
            System.out.println("商："+num1/num2);
        }
    }
}

总结：
throw和throws的区别：
（1）位置不同：
throw：方法内部
throws: 方法的签名处，方法的声明处

（2）内容不同：
throw+异常对象（检查异常，运行时异常）
throws+异常的类型（可以多个类型，用，拼接）

（3）作用不同：
throw：异常出现的源头，制造异常。
throws:在方法的声明处，告诉方法的调用者，这个方法中可能会出现我声明的这些异常。然后调用者对这个异常进行处理：
要么自己处理要么再继续向外抛出异常

自定义异常

自定义的异常可以继承：运行时异常

public class MyException extends RuntimeException {
    
    static final long serialVersionUID = -70348971907L;
    
    public MyException(){
    }
    public MyException(String msg){
        super(msg);
    }
}

也可以继承检查异常：

public class MyException extends Exception {
    static final long serialVersionUID = -70348971907L;
    public MyException(){
    }
    public MyException(String msg){
        super(msg);
    }
}

如果继承的是运行时异常，那么在使用的时候无需额外处理
如果继承的是检查异常，那么使用的时候需要try-catch捕获或者throws向上抛

三、常用类

包装类

【1】什么是包装类：
以前定义变量，经常使用基本数据类型，
对于基本数据类型来说，它就是一个数，加点属性，加点方法，加点构造器，
将基本数据类型对应进行了一个封装，产生了一个新的类，—>包装类。
int,byte…—>基本数据类型
包装类—>引用数据类型

【2】对应关系：

基本数据类型	对应包装类型	继承关系
byte	Byte	Number—》Object
int	Integer	Number—》Object
long	Long	Number—》Object
float	Float	Number—》Object
double	Double	Number—》Object
char	Character	Object
boolean	Boolean	Object

【3】已经有基本数据类型了，为什么要封装为包装类？
（1）java语言面向对象的语言，最擅长的操作各种各样的类。
（2）以前学习装数据的—》数组，int[] String[] double[] Student[]
以后学习的装数据的—》集合，有一个特点，只能装引用数据类型的数据

Integer

【1】直接使用，无需导包：
在这里插入图片描述
【2】类的继承关系：

【3】实现接口：

【4】这个类被final修饰，那么这个类不能有子类，不能被继承：

【5】包装类是对基本数据类型的封装：对int类型封装产生了Integer

【6】类的历史：

【7】属性：

//属性：
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
        //“物极必反”原理：
        System.out.println(Integer.MAX_VALUE+1);
        System.out.println(Integer.MIN_VALUE-1);

【8】构造器（发现没有空参构造器）

（1）int类型作为构造器的参数：

Integer i1 = new Integer(12);

在这里插入图片描述

（2）String类型作为构造器的参数：

Integer i2 = new Integer("12");
        Integer i3 = new Integer("abcdef");

在这里插入图片描述

【9】包装类特有的机制：自动装箱自动拆箱：

//自动装箱：int--->Integer
        Integer i = 12;
        System.out.println(i);
        //自动拆箱：Integer--->int
        Integer i2 = new Integer(12);
        int num = i2;
        System.out.println(num);

（1）自动装箱自动拆箱是从JDK1.5以后新出的特性
（2）自动装箱自动拆箱：将基本数据类型和包装类进行快速的类型转换。
验证：
在这里插入图片描述

可以自定打断点测试是否走入valueOf方法中：
在这里插入图片描述

【10】常用方法：
valueOf方法的底层：

在这里插入图片描述

package com.msb;
/**
 * @Auther: msb-zhaoss
 */
public class Test04 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //compareTo：只返回三个值：要么是0,-1,1
        Integer i1 = new Integer(6);
        Integer i2 = new Integer(12);
        System.out.println(i1.compareTo(i2));// return (x < y) ? -1 : ((x == y) ? 0 : 1);
        //equals:Integer对Object中的equals方法进行了重写，比较的是底层封装的那个value的值。
        //Integer对象是通过new关键字创建的对象：
        Integer i3 = new Integer(12);
        Integer i4 = new Integer(12);
        System.out.println(i3 == i4);//false 因为==比较的是两个对象的地址
        boolean flag = i3.equals(i4);
        System.out.println(flag);
        //Integer对象通过自动装箱来完成：
        Integer i5 = 130;
        Integer i6 = 130;
        System.out.println(i5.equals(i6));//true
        System.out.println(i5 == i6);
        /*
        如果自动装箱值在-128~127之间，那么比较的就是具体的数值
        否在，比较的就是对象的地址
         */
        //intValue() :作用将Integer--->int
        Integer i7 = 130;
        int i = i7.intValue();
        System.out.println(i);
        //parseInt(String s) :String--->int:
        int i8 = Integer.parseInt("12");
        System.out.println(i8);
        //toString:Integer--->String
        Integer i10 = 130;
        System.out.println(i10.toString());
    }
}

## 日期相关类 ### JDK1.8新增日期时间

JDK1.0中使用java.util.Date类 --》第一批日期时间API
JDK1.1引入Calendar类 --》第二批日期时间API
缺陷：
可变性 : 像日期和时间这样的类应该是不可变的。
偏移性 : Date中的年份是从1900开始的，而月份都从0开始。
格式化 : 格式化只对Date有用，Calendar则不行。
JDK1.8新增日期时间API --》第三批日期时间API

LocalDate/LocalTime/LocalDateTime

public class Test09 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //1.完成实例化：
        //方法1：now()--获取当前的日期，时间，日期+时间
        LocalDate localDate = LocalDate.now();
        System.out.println(localDate);
        LocalTime localTime = LocalTime.now();
        System.out.println(localTime);
        LocalDateTime localDateTime = LocalDateTime.now();
        System.out.println(localDateTime);
        //方法2：of()--设置指定的日期，时间，日期+时间
        LocalDate of = LocalDate.of(2010, 5, 6);
        System.out.println(of);
        LocalTime of1 = LocalTime.of(12, 35, 56);
        System.out.println(of1);
        LocalDateTime of2 = LocalDateTime.of(1890, 12, 23, 13, 24, 15);
        System.out.println(of2);
        //LocalDate,LocalTime用的不如LocalDateTime多
        //下面讲解用LocalDateTime：
        //一些列常用的get***
        System.out.println(localDateTime.getYear());//2020
        System.out.println(localDateTime.getMonth());//JUNE
        System.out.println(localDateTime.getMonthValue());//6
        System.out.println(localDateTime.getDayOfMonth());//14
        System.out.println(localDateTime.getDayOfWeek());//SUNDAY
        System.out.println(localDateTime.getHour());//22
        System.out.println(localDateTime.getMinute());//22
        System.out.println(localDateTime.getSecond());//6
        //不是set方法，叫with
        //体会：不可变性
        LocalDateTime localDateTime2 = localDateTime.withMonth(8);
        System.out.println(localDateTime);
        System.out.println(localDateTime2);
        //提供了加减的操作：
        //加：
        LocalDateTime localDateTime1 = localDateTime.plusMonths(4);
        System.out.println(localDateTime);
        System.out.println(localDateTime1);
        //减：
        LocalDateTime localDateTime3 = localDateTime.minusMonths(5);
        System.out.println(localDateTime);
        System.out.println(localDateTime3);
    }
}

DateTimeFormatter

public class Test10 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //格式化类：DateTimeFormatter
        //方式一:预定义的标准格式。如: ISO_LOCAL_DATE_TIME;ISO_LOCAL_DATE;IS0_LOCAL_TIME
        DateTimeFormatter df1 = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
        //df1就可以帮我们完成LocalDateTime和String之间的相互转换：
        //LocalDateTime-->String:
        LocalDateTime now = LocalDateTime.now();
        String str = df1.format(now);
        System.out.println(str);//2020-06-15T15:02:51.29
        //String--->LocalDateTime
        TemporalAccessor parse = df1.parse("2020-06-15T15:02:51.29");
        System.out.println(parse);
        //方式二:本地化相关的格式。如: oflocalizedDateTime()
        //参数：FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT
        //FormatStyle.LONG :2020年6月15日 下午03时17分13秒
        //FormatStyle.MEDIUM: 2020-6-15 15:17:42
        //FormatStyle.SHORT:20-6-15 下午3:18
        DateTimeFormatter df2 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT);
        //LocalDateTime-->String:
        LocalDateTime now1 = LocalDateTime.now();
        String str2 = df2.format(now1);
        System.out.println(str2);
        //String--->LocalDateTime
        TemporalAccessor parse1 = df2.parse("20-6-15 下午3:18");
        System.out.println(parse1);
        //方式三: 自定义的格式。如: ofPattern( "yyyy-MM-dd hh:mm:ss") ---》重点，以后常用
        DateTimeFormatter df3 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
        //LocalDateTime-->String:
        LocalDateTime now2 = LocalDateTime.now();
        String format = df3.format(now2);
        System.out.println(format);//2020-06-15 03:22:03
        //String--->LocalDateTime
        TemporalAccessor parse2 = df3.parse("2020-06-15 03:22:03");
        System.out.println(parse2);
    }
}

Math类

【1】直接使用，无需导包：

【2】final修饰类，这个类不能被继承：

【3】构造器私有化，不能创建Math类的对象：
![在这里插入图片描述](https://img-blog.csdnimg.cn/9ceee9461d3c45818210265988302469.png

不能：
在这里插入图片描述

【4】Math内部的所有的属性，方法都被static修饰：类名.直接调用，无需创建对象：
在这里插入图片描述
【5】常用方法：

public class Test01 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //常用属性：
        System.out.println(Math.PI);
        //常用方法：
        System.out.println("随机数："+Math.random());//[0.0,1.0)
        System.out.println("绝对值："+Math.abs(-80));
        System.out.println("向上取值："+Math.ceil(9.1));
        System.out.println("向下取值："+Math.floor(9.9));
        System.out.println("四舍五入："+Math.round(3.5));
        System.out.println("取大的那个值："+Math.max(3, 6));
        System.out.println("取小的那个值："+Math.min(3, 6));
    }
}

【6】静态导入：

public class Test01 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //常用属性：
        System.out.println(PI);
        //常用方法：
        System.out.println("随机数："+random());//[0.0,1.0)
        System.out.println("绝对值："+abs(-80));
        System.out.println("向上取值："+ceil(9.1));
        System.out.println("向下取值："+floor(9.9));
        System.out.println("四舍五入："+round(3.5));
        System.out.println("取大的那个值："+max(3, 6));
        System.out.println("取小的那个值："+min(3, 6));
    }
    //如果跟Math中方法重复了，那么会优先走本类中的方法（就近原则）
    public static int random(){
        return 100;
    }
}

Random类

import java.util.Random;
/**
 * @Auther: msb-zhaoss
 */
public class Test02 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。
        System.out.println("随机数："+Math.random());
        //学习Random类
        //（1）利用带参数的构造器创建对象：
        Random r1 = new Random(System.currentTimeMillis());
        int i = r1.nextInt();
        System.out.println(i);
        //（2）利用空参构造器创建对象：
        Random r2 = new Random();//表面是在调用无参数构造器，实际底层还是调用了带参构造器
        System.out.println(r2.nextInt(10));//在 0（包括）和指定值（不包括）之间均匀分布的 int 值。
        System.out.println(r2.nextDouble());//在 0.0 和 1.0 之间均匀分布的 double 值。
    }
}

在这里插入图片描述

String类

【1】直接使用，无需导包：
在这里插入图片描述
【2】形象说一下字符串：

【3】

String str = “abc”;
"abc"就是String类下的一个具体的对象

【4】字符串是不可变的：？？？？
在这里插入图片描述
【5】这个String类不可以被继承，不能有子类：

【6】String底层是一个char类型的数组

验证：

常用方法

【1】构造器：底层就是给对象底层的value数组进行赋值操作。

 //通过构造器来创建对象：
        String s1 = new String();
        String s2 = new String("abc");
        String s3 = new String(new char[]{'a','b','c'});

【3】常用方法：

String s4 = "abc";
        System.out.println("字符串的长度为："+s4.length());
        String s5 = new SZtring("abc");
        System.out.println("字符串是否为空："+s5.isEmpty());
        System.out.println("获取字符串的下标对应的字符为："+s5.charAt(1));

【4】equals:

String s6 = new String("abc");
String s7 = new String("abc");
System.out.println(s6.equals(s7));

在这里插入图片描述

【5】String类实现了Comparable，里面有一个抽象方法叫compareTo，所以String中一定要对这个方法进行重写：4

String s8 = new String("abc");
        String s9 = new String("abc");
        System.out.println(s8.compareTo(s9));

在这里插入图片描述

【6】常用方法：

//字符串的截取：
        String s10 = "abcdefhijk";
        System.out.println(s10.substring(3)); //defhijk
        System.out.println(s10.substring(3, 6));//def  [3,6) 
        //字符串的合并/拼接操作：
        System.out.println(s10.concat("pppp")); //abcdefhijkpppp
        //字符串中的字符的替换：
        String s11 = "abcdeahija";
        System.out.println(s11.replace('a', 'u'));  //ubcdeuhiju
        //按照指定的字符串进行分裂为数组的形式：
        String s12 = "a-b-c-d-e-f";
        String[] strs = s12.split("-");
        System.out.println(Arrays.toString(strs));//[a, b, c, d, e, f]
        //转大小写的方法：
        String s13 = "abc";
        System.out.println(s13.toUpperCase());  //ABC
        System.out.println(s13.toUpperCase().toLowerCase()); //abc
        //去除收尾空格：
        String s14 = "    a  b  c    "; 
        System.out.println(s14.trim()); //a  b  c
        //toString()
        String s15 = "abc";
        System.out.println(s15.toString()); //abc
        //转换为String类型：
        System.out.println(String.valueOf(false)); //false

String的内存分析

【1】字符串拼接：

public class Test02 {
//这是一个main方法，是程序的入口：
public static void main(String[] args) {
String s1 = “a”+“b”+“c”;
String s2 = “ab”+“c”;
String s3 = “a”+“bc”;
String s4 = “abc”;
String s5 = “abc”+“”;
}
}
上面的字符串，会进行编译器优化，直接合并成为完整的字符串，我们可以反编译验证：
在这里插入图片描述

然后在常量池中，常量池的特点是第一次如果没有这个字符串，就放进去，如果有这个字符串，就直接从常量池中取：

内存：
在这里插入图片描述

【2】new关键字创建对象：

String s6 = new String("abc");

内存：开辟两个空间（1.字符串常量池中的字符串 2.堆中的开辟的空间）
在这里插入图片描述

【3】有变量参与的字符串拼接：

public class Test03 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        String a = "abc";
        String b = a + "def";
        System.out.println(b);
    }
}

a变量在编译的时候不知道a是“abc”字符串，所以不会进行编译期优化，不会直接合并为“abcdef”
反汇编过程：为了更好的帮我分析字节码文件是如何进行解析的：

利用IDEA中的控制台：

在这里插入图片描述

StringBuilder类

可变和不可变字符串

【1】String—》不可变
在这里插入图片描述
【2】StringBuilder—》可变
可变，在StringBuilder这个对象的地址不变的情况下，想把“abc”变成“abcdef”是可能的，直接追加即可

public class Test02 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        System.out.println(sb.append("abc")==sb.append("def"));//true
    }
}

常用方法

【1】StringBuilder常用方法：

public class Test03 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        StringBuilder sb=new StringBuilder("nihaojavawodeshijie");
        //增
        sb.append("这是梦想");
        System.out.println(sb);//nihaojavawodeshijie这是梦想
        //删
        sb.delete(3, 6);//删除位置在[3,6)上的字符
        System.out.println(sb);//nihavawodeshijie这是梦想
        sb.deleteCharAt(16);//删除位置在16上的字符
        System.out.println(sb);//nihavawodeshijie是梦想
        //改-->插入
        StringBuilder sb1=new StringBuilder("$23445980947");
        sb1.insert(3, ",");//在下标为3的位置上插入 ,
        System.out.println(sb1);
        StringBuilder sb2=new StringBuilder("$2你好吗5980947");
        //改-->替换
        sb2.replace(3, 5, "我好累");//在下标[3,5)位置上插入字符串
        System.out.println(sb2);
        sb.setCharAt(3, '!');
        System.out.println(sb);
        //查
        StringBuilder sb3=new StringBuilder("asdfa");
        for (int i = 0; i < sb3.length(); i++) {
            System.out.print(sb3.charAt(i)+"\t");
        }
        System.out.println();
        //截取
        String str=sb3.substring(2,4);//截取[2,4)返回的是一个新的String，对StringBuilder没有影响
        System.out.println(str);
        System.out.println(sb3);
    }
}

【2】StringBuffer常用方法：

public class Test03 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        StringBuffer sb=new StringBuffer("nihaojavawodeshijie");
        //增
        sb.append("这是梦想");
        System.out.println(sb);//nihaojavawodeshijie这是梦想
        //删
        sb.delete(3, 6);//删除位置在[3,6)上的字符
        System.out.println(sb);//nihavawodeshijie这是梦想
        sb.deleteCharAt(16);//删除位置在16上的字符
        System.out.println(sb);//nihavawodeshijie是梦想
        //改-->插入
        StringBuilder sb1=new StringBuilder("$23445980947");
        sb1.insert(3, ",");//在下标为3的位置上插入 ,
        System.out.println(sb1);
        StringBuilder sb2=new StringBuilder("$2你好吗5980947");
        //改-->替换
        sb2.replace(3, 5, "我好累");//在下标[3,5)位置上插入字符串
        System.out.println(sb2);
        sb.setCharAt(3, '!');
        System.out.println(sb);
        //查
        StringBuilder sb3=new StringBuilder("asdfa");
        for (int i = 0; i < sb3.length(); i++) {
            System.out.print(sb3.charAt(i)+"\t");
        }
        System.out.println();
        //截取
        String str=sb3.substring(2,4);//截取[2,4)返回的是一个新的String，对StringBuilder没有影响
        System.out.println(str);
        System.out.println(sb3);
    }
}

String、StringBuffer、StringBuilder区别与联系

String类是不可变类，即一旦一个String对象被创建后，包含在这个对象中的字符序列是不可改变的，直至这个对象销毁。
StringBuffer类则代表一个字符序列可变的字符串，可以通过append、insert、reverse、setChartAt、setLength等方法改变其内容。一旦生成了最终的字符串，调用toString方法将其转变为String
JDK1.5新增了一个StringBuilder类，与StringBuffer相似，构造方法和方法基本相同。不同是StringBuffer是线程安全的，而StringBuilder是线程不安全的，所以性能略高。通常情况下，创建一个内容可变的字符串，应该优先考虑使用StringBuilder
```
         StringBuilder:JDK1.5开始  效率高   线程不安全
         StringBuffer:JDK1.0开始   效率低    线程安全
```