Java基础

后端 java java基础

发布时间 : 2023-04-26 17:30

字数:3.5k 阅读 :

Java 三大特性

封装 + 继承 + 多态

什么是面向对象？

面向对象是一种编程思想，是面向过程思想的衍生，将复杂的事情简单化，将我们从事情的执行者变成指挥者

在java中我们可以将任何事务看成一个对象，其有三大特征封装 + 继承 + 多态

1. 封装： 隐藏对象的内部特性和行为

好处：  
· 保护内部的状态。
· 禁止对象之间的不良交互提高模块化
· 对象的行为可以被单独的改变或者是扩展，提高了代码的可用性和可维护性。

2. 继承： 从基类(父类)获取字段和方法的能力

好处：  
· 提供了代码的重用性，可以在不修改基类的情况下给现存的类添加新特性。

3. 多态： 给不同的底层数据类型做相同的接口展示

好处：  
· 一个多态类型上的操作可以应用到其他类型的值上面

	重写（Overriding）	重载（Overloading）
类的数量	父子类、接口与实现类	本类
方法名称	一致	一致
参数列表	一定不能修改	必须修改
返回类型	一定不能修改	可以修改
异常	可以减少或删除，但不能扩展

重载
public void out(){
    System.out.println("参数"+null);
}
//参数数目不同
public void out(Integer n){
    System.out.println("参数"+n.getClass().getName());
}

Java 基本数据类型包装类型

1、包装类是对象，拥有方法和字段，对象的调用都是通过引用对象的地址，基本类型不是

2、包装类型是引用的传递，基本类型是值的传递

3、声明方式不同，基本数据类型不需要new关键字，而包装类型需要new在堆内存中进行new来分配内存空间

4、存储位置不同，基本数据类型直接将值保存在值栈中，而包装类型是把对象放在堆中，然后通过对象的引用来调用他们

5、初始值不同，eg： int的初始值为 0 、 boolean的初始值为false 而包装类型的初始值为 null

6、使用方式不同，基本数据类型直接赋值使用就好，而包装类型是在集合如 coolection Map时会使用

Java 反射

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制

class User{
    private Integer age = 11;
    private String name = "jack";

    public User(){
        super();
    }

    public User(Integer age, String name) {
        this.age = age;
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}


//-----------获取这个类
// 方法一 根据类名路径
Class user = Class.forName("com.yifan.reflex.User");
// 方法二 已知这个类
Class user = Class.forName(User.class.getName());

//-----------创建这个类的实例对象
//无参
 User user = (User) user.newInstance();
//有参
//获得构造对象
Constructor<User> constructor = user.getConstructor(Integer.class, String.class);
User hahah = constructor.newInstance(1, "hahah");

Java 多线程实现方法

1 , 继承 thread 类,重写 run 方法 ==单继承局限性==

2 , 实现 Runnable 接口，重写 run 方法 ==避免单继承局限性,灵活方便,方便同一个对象被多个线程使用==

3 , 实现 Callable 接口，重写 call 方法（有返回值,）

4 , 使用线程池

线程的5大状态

创建 —-> 就绪 —-> 堵塞 —-> 运行 —–> 死亡

Thread中， join() 方法的作用是等待调用的线程完成后，才能继续用下运行。

synchronized 锁的对象是变化的量就是锁的共享资源

synchronized 同步方法锁的默认是这个对象

public synchronized void add

synchronized 同步代码块锁的可以是任意对象

synchronized(obj){}

synchronized锁的是什么

https://blog.csdn.net/djrm11/article/details/88386719?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.nonecase&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.nonecase

Java 集合

list 有序可以重复链表实现 ArrayList（动态数组）查询快， LinkedList（双向链表）删除插入快

set 无序元素不允许重复，可以插入null

数组是静态集合是动态

Array 是指定固定大小的，而 ArrayList 大小是自动扩展的。

数组线性排列，执行效率和检查是最快

HashMap 的实现原理？

HashMap 基于 Hash 算法实现的，我们通过 put(key,value)存储，get(key)来获取。当传入 key 时，HashMap 会根据 key. hashCode() 计算出 hash 值，根据 hash 值将 value 保存在 bucket 里。当计算出的 hash 值相同时，我们称之为 hash 冲突，HashMap 的做法是用链表和红黑树存储相同 hash 值的 value。当 hash 冲突的个数比较少时，使用链表否则使用红黑树。

HashSet 是基于 HashMap 实现的,HashSet 不允许重复的值。

数组转 List：使用 Arrays. asList(array) 进行转换。

List 转数组：使用 List 自带的 toArray() 方法。

HashMap底层数据结构

Jdk8之前：数组+链表

Jdk8后：数组+链表+红黑树

如何复制一个Java对象（浅克隆与深度克隆）

浅克隆 : 实现 Cloneable 接口并重写 Object 类中的 clone() 方法

clone一个对象时，只clone了里面的某些属性，对象里面的对象不能被克隆出来

深克隆 : 实现 Serializable 接口，通过对象的序列化和反序列化实现克隆，可以实现真正的深度克隆

譬如Person类中有两个对象，一个是Arm，一个是Address

现在我们的需求是，克隆一个Person对象，但是不要它的Address属性，仅克隆除Address外的所有属性

我们在不想被序列化的属性上加一个关键字 transient

package com.yifan.clone;

import java.io.Serializable;

/**
 * @Author YIFan
 * @Date 2020/7/15 14:13
 * @Version 1.0
 */
public class Arm implements Serializable {

    private String armName;


    public void setArmName(String armName) {
        this.armName = armName;
    }

    public String getArmName() {
        return armName;
    }
}

package com.yifan.clone;

import java.io.*;

/**
 * @Author YIFan
 * @Date 2020/7/15 14:13
 * @Version 1.0
 */
public class Person implements Serializable {

    private Integer age;
    private String name;
    private Arm arm;

    public void setArm(Arm arm) {
        this.arm = arm;
    }

    public Arm getArm() {
        return arm;
    }

    /*
     * 深度克隆
     *
     * */

    public Object deepClone() throws IOException, ClassNotFoundException {
        // 将对象写到流里
        ByteArrayOutputStream stream = new ByteArrayOutputStream();
        ObjectOutputStream outputStream = new ObjectOutputStream(stream);
        outputStream.writeObject(this);

        // 从流里读出来
        ByteArrayInputStream inputStream = new ByteArrayInputStream(stream.toByteArray());
        ObjectInputStream iStream1 = new ObjectInputStream(inputStream);
        return iStream1.readObject();
    }


    public Person(Integer age, String name) {
        this.age = age;
        this.name = name;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public String getName() {
        return name;
    }
}

package com.yifan.clone;

import java.io.IOException;

/**
 * @Author YIFan
 * @Date 2020/7/15 14:20
 * @Version 1.0
 */
public class Tset {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Person person = new Person(15,"jack");
        Arm arm = new Arm();
        arm.setArmName("qweqr");
        person.setArm(arm);

        Person clone = (Person)person.deepClone();

        System.err.println("修改前------");
        System.err.println("clone --> "+clone.getArm().getArmName());
        System.err.println(clone.getName());

        System.err.println("修改后------");
        clone.getArm().setArmName("ahhhh");
        clone.setName("lucy");
        System.err.println("clone --> "+clone.getArm().getArmName());
        System.err.println("person --> "+person.getArm().getArmName());
        System.err.println(clone.getName());
    }
}

数据加密算法

1，对称加密

加密解密使用同一密钥

DES，3DES，RC4，RC5，RC6，AES，IDEA

2，非对称加密

指加密和解密使用不同密钥

RSA、ECC（移动设备用）、Diffie-Hellman、El Gamal、DSA（数字签名用）

3，Hash算法

MD2、MD4、MD5、HAVAL、SHA、SHA-1、HMAC、HMAC-MD5、HMAC-SHA1

Java 8

Predicate接口

在这里插入图片描述

Predicate 断言