Java（二）--面向对象

十.封装

1.访问权限不用加

在c++中是访问权限：属性/行为：

class Person{
	public:
		void speak(){
			cout<<"666";
		}
};

在Java中是访问权限属性/行为：

class Person{
	public void speak(){
	    cout<<"666";
	}
};

2.和c++一样类中对象可以没有初始化

为什么要刻意强调这一点呢？因为与c++不同的是java方法中建立变量没有初始化会报错。但是类中对象没有初始化会像c++一样分配初始值。
整型的初始值是0。浮点型是0.0。布尔型是false。引用类型是null。

3.对象的创建

前面讲过java是通过new来创建对象的。

//无参构造
Student student1=new Student();
//有参构造
Student student2=new Student("张三",19);

补充：
Java中没有析构函数。
set和get方法可以通过IDEA的快捷键alt+insert进行快速生成。当然后期会使用lombok来简化书写。

4.this关键字

c++中是这么写的this->
java中是这么写的this.

5.静态成员

c++是这么调用的Person::m_A
Java是这么调用的Person.m_A

6.类的分类

【1】Java中专门用来描述一类事物的类就叫做Javabean类，简单说就是里面没有main方法。
【2】里面有main方法的类叫做测试类，因为有main方法，所以可以运行，主要用来测试本类和其他类的方法书写是否正确。
【3】专门提供方法让别人使用的就是工具类。最大的特点就是变量和方法都是静态的。

注：我们一般在类中添加main方法来测试该类的书写是否正确。

例如下面这个代码

public class JwtUtil {
    //有效期为
    public static final Long JWT_TTL =15*24* 60 * 60 *1000L;// 60 * 60 *1000  一个小时
    //设置秘钥明文
    public static final String JWT_KEY = "Zmx5aW5ncGln";//flyingpig

    public static String getUUID(){
        String token = UUID.randomUUID().toString().replaceAll("-", "");
        return token;
    }

    /**
     * 生成jtw
     * @param subject token中要存放的数据（json格式）
     * @return
     */
    public static String createJWT(String subject) {
        JwtBuilder builder = getJwtBuilder(subject, null, getUUID());// 设置过期时间
        return builder.compact();
    }

    /**
     * 生成jtw
     * @param subject token中要存放的数据（json格式）
     * @param ttlMillis token超时时间
     * @return
     */
    public static String createJWT(String subject, Long ttlMillis) {
        JwtBuilder builder = getJwtBuilder(subject, ttlMillis, getUUID());// 设置过期时间
        return builder.compact();
    }

    private static JwtBuilder getJwtBuilder(String subject, Long ttlMillis, String uuid) {
        SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
        SecretKey secretKey = generalKey();
        long nowMillis = System.currentTimeMillis();
        Date now = new Date(nowMillis);
        if(ttlMillis==null){
            ttlMillis=JwtUtil.JWT_TTL;
        }
        long expMillis = nowMillis + ttlMillis;
        Date expDate = new Date(expMillis);
        return Jwts.builder()
                .setId(uuid)              //唯一的ID
                .setSubject(subject)   // 主题  可以是JSON数据
                .setIssuer("flyingpig")     // 签发者
                .setIssuedAt(now)      // 签发时间
                .signWith(signatureAlgorithm, secretKey) //使用HS256对称加密算法签名, 第二个参数为秘钥
                .setExpiration(expDate);
    }

    /**
     * 创建token
     * @param id
     * @param subject
     * @param ttlMillis
     * @return
     */
    public static String createJWT(String id, String subject, Long ttlMillis) {
        JwtBuilder builder = getJwtBuilder(subject, ttlMillis, id);// 设置过期时间
        return builder.compact();
    }

    public static void main(String[] args) throws Exception {
      String jwtKey = "flyingpig";
        String encodedKey = Base64.getEncoder().encodeToString(jwtKey.getBytes());
        System.out.println(encodedKey);
    }

    /**
     * 生成加密后的秘钥 secretKey
     * @return
     */
    public static SecretKey generalKey() {
        byte[] encodedKey = Base64.getDecoder().decode(JwtUtil.JWT_KEY);
        SecretKey key = new SecretKeySpec(encodedKey, 0, encodedKey.length, "AES");
        return key;
    }
    //解析JWT令牌
    public static Claims parseJwt(String jwt) {
        SecretKey secretKey = generalKey();
        return Jwts.parser()
                .setSigningKey(secretKey)
                .parseClaimsJws(jwt)
                .getBody();
    }
}

然后我们就可以直接通过类名.方法的格式直接对里面的方法为其他类提供服务。

十一.继承

【1】语法：

public class Student extends Person{}

【2】Java中所有的继承都是公有继承，即公有的仍然是公有，私有的还是私有。

【3】子类和父类同名成员

访问子类同名成员--son.m_A或者this.m_A
访问父类--super.m_A

c++中是类名::变量名，而Java中用son和this代表子类，super代表父类。

【4】Java中无多继承

【5】方法重写

    @Override
    public Integer getIdByTeacherName(String teacherName) {
        Integer teacherId=teacherMapper.getIdByName(teacherName);
        return teacherId;
    }

与c++一个很大的区别是重写方法前面要加上一个@Override注解。什么是注解呢？Override注解又有什么用呢？

注释是给程序员看的，而注释是给虚拟机和电脑看的。
@Override是重写注解，是放在重写后的方法上，如果重写的方法语法错误，就会有红色波浪线。

【6】java使用super()调用父类的构造方法

十二.多态

1.什么是多态？

多态，顾名思义就是多种形态。
首先要明确父类或者子类的对象都可以赋值给父类引用。
而当用父类的引用调用一个方法，会根据当前父类的引用或指针指向什么类型去调用对应的实现，然后执行不同的过程，就类似变换多种形态。
举个例子，动物类都有叫这个方法，如果将狗类对象赋值给动物类引用，则执行的叫是狗的汪汪叫，如果赋值的是猫类对象，则是猫叫，赋值的是老鼠类对象，则是老鼠叫。
为什么只说方法，不说变量，因为多态只会对方法起作用。通过多态，我们可以提高代码的复用性。

2.多态的实现

多态是通过抽象的父类+子类继承实现的（在c++中的关键字是virtual，在Java中是abstract）

【1】抽象的父类

//抽象类
public abstract class Animal {
    public void printName(){
        System.out.println("Animal");
    }
    //抽象方法
    public abstract void speak();
}

格式为public abstract class 类名{}；的类称为抽象类。
格式为public abstract 返回值类型方法名（参数列表）;的方法成为抽象方法。

注：（1）如果一个类中存在抽象方法，那么该类就必须声明为抽象类。例如上面的Animal 类，使用abstract关键字声明抽象类。抽象类不一定有抽象方法，但有抽象方法一定是抽象类。
（2）抽象类中定义的抽象方法无实现。

【2】子类继承

子类继承后一定要重写父类抽象类中的所有抽象方法，要不然子类也得定义为抽象类。

重写抽象方法：

public class Cat extends Animal{
    public void speak() {
        System.out.println("喵喵喵");
    }
}

public class Dog extends Animal{
    public void speak() {
        System.out.println("汪汪汪");
    }
}

public class Person extends Animal{
    public void speak() {
        System.out.println("666");
    }
}

除非继续定义为抽象类：

public abstract class Person extends Animal{
}

【3】多态的使用--就是使用子类对象赋值给父类引用，那么调用父类引用的方法就会使用其对应子类的实现。

public class Main {
    public static void main(String[] args){
        Animal animal=new Dog();
        animal.speak();
        animal=new Cat();
        animal.speak();
        animal=new Person();
        animal.speak();
    }
}

十三.接口

接口是什么，就是一种特殊的抽象类，类中所有的方法都是抽象方法。
关键字是interface和implements。

1.接口的实现

【1】定义接口:就是将abstract class换成interface

public interface Animal {
    void speak();
}

【2】继承接口：就是将extend换成implements

public class Cat implements Animal{
    public void speak() {
        System.out.println("喵喵喵");
    }
}

public class Dog implements Animal{
    public void speak() {
        System.out.println("汪汪汪");
    }
}

public class Person implements Animal{
    public void speak() {
        System.out.println("666");
    }
}

【3】使用和多态一样

public class Main {
    public static void main(String[] args){
        Animal animal=new Dog();
        animal.speak();
        animal=new Cat();
        animal.speak();
        animal=new Person();
        animal.speak();
    }
}

2.接口的特点

【1】接口支持多继承，一个类可以实现多个接口。
【2】接口不能实例化，不能new对象。
【3】接口没有构造方法
【4】接口成员变量的默认修饰符是public static final
接口成员方法的默认修饰符是public abstract
所以这些修饰符可以省略不写，还有出这些之外的修饰符也不能写。

3.接口的意义

那么接口有什么特殊意义呢？为什么要把只有抽象函数的抽象类特意的提出来，叫做接口，并刚给它特殊的关键字和定义方法？

接口的意义主要是定义规范和规则。接口的特点就是所有继承它的类都要去实现其中的所有抽象方法。
比如当你是架构师，你不用编写所有的代码，只需要编写接口，那么让其他程序员继承这个接口，他就需要去实现其中的所有方法。
又比如同一套api在不同的环境下有不同的实现，比如java操作数据库的jdbc的api，数据库类型有很多，mysql,Oracle等。
所以java公司它只是规定接口，规定要实现哪些方法和功能，至于具体的实现交给各个数据库公司提供。这就是制定规范。

十四.包装类

Java 中的包装类指的是一组用于封装基本数据类型（如 int、float、boolean 等）的类，使得这些基本数据类型具有面向对象的特性和功能。每个基本数据类型都有对应的包装类，例如 Integer、Float、Boolean 等。

包装类提供了将基本数据类型转换成对象的功能，这样就可以在面向对象的环境中使用这些基本数据类型，并且可以对它们进行一些操作。另外，通过使用包装类，可以将基本数据类型存储到集合类等数据结构中，这些数据结构要求使用对象而不是基本数据类型。

除了提供基本数据类型的封装之外，包装类还包含一些方法和常量，比如 compareTo() 方法可以用于比较两个包装类对象的值大小，MAX_VALUE 和 MIN_VALUE 常量可以用于获取某个基本数据类型的取值范围等。

Java 中的包装类主要有以下几个：

Integer 对应于 int
Float 对应于 float
Double 对应于 double
Boolean 对应于 boolean
Character 对应于 char

这些包装类都位于 java.lang 包中，因此在 Java 编程中可以直接使用，无需额外导入。

十五.数据结构类

熟悉List（链表），Queue（队列），Stack（栈）等类，不仅以后刷算法题需要用到，List在开发中也经常用到。

初始化都是这种格式：

List<Integer> integerList=new List<>();
Queue<Integer> integerQueue=new Queue<>();
Stack<Integer> integerStack=new Stack<>();

例：List常见api:add,remove等

Queue和Stack常见api：
push()【插入元素】
pop()【移除元素，队列先进先出，栈后进先出】
peek()【栈顶的元素和队首的元素，简单说就是如果执行移除操作要移除的元素是什么】
empty()【检查是否为空】