05.java面向对象-泛型

最新推荐文章于 2024-07-06 13:51:47 发布
最新推荐文章于 2024-07-06 13:51:47 发布
阅读量1.3k 收藏 31
点赞数 29
分类专栏： java面向对象高级部分补充 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_54915265/article/details/135444018
版权

05. java面向对象-泛型

01. 泛型引入

1. 看一个需求

  1. 请编写程序，在ArrayList中，添加3个Dog对象
  2. Dog对象含有name 和 age ，并输出name和age（要求使用getXxx()）
    先使用传统方式来解决 – 引出泛型
import java.util.ArrayList;

@SuppressWarnings("all")
public class Generic01 {
    public static void main(String[] args) {
        //使用传统方式来解决
        ArrayList list = new ArrayList();
        list.add(new Dog("旺财", 10));
        list.add(new Dog("发财", 1));
        list.add(new Dog("小黄", 2));

        //假如我们程序员，不小心添加了一只猫
        list.add(new Cat("招财猫", 8));

        //遍历
        for (Object obj : list) {
            //向下转型
            Dog dog = (Dog) obj;
            System.out.println(dog.getName() + "-" + dog.getAge());
        }

    }
}
class Dog {
    private String name;
    private int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", 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;
    }
}
class Cat { //Cat类
    private String name;
    private int age;

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", 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;
    }
}

代码中我们添加了三个Dog类型，但是也添加了Cat类型。编译器无法发现，运行后会出现异常ClassCastException

2. 使用传统方法的问题解析

  1. 不能对假如到集合 ArrayList中的数据类型进行约束（不安全）
  2. 遍历的时候，需要进行类型转换，如果结合中的数据量过大，对效率有影响

3. 用泛型来解决前面的问题

import java.util.ArrayList;

/**
 * 02. 用泛型解决问题
 **/
@SuppressWarnings("all")
public class Generic02 {
    public static void main(String[] args) {
        //使用泛型来解决问题
        //1. 当我们 ArrayList<Dog> 表示存放到 ArrayList 集合中的元素是Dog类型
        //2. 如果编译器发现添加的类型，不满足要求，就会报错
        //3. 在遍历时，可以直接取出Dog类型而不是 Object
        ArrayList<Dog> list = new ArrayList<Dog>();
        list.add(new Dog("旺财", 10));
        list.add(new Dog("发财", 1));
        list.add(new Dog("小黄", 2));

//        list.add(new Cat("招财猫", 8)); //加入不进去
        //使用泛型
        for (Dog dog : list) {
            System.out.println(dog.getName() + "-" + dog.getAge());
        }
    }
}
class Dog {
    private String name;
    private int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", 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;
    }
}
class Cat { //Cat类
    private String name;
    private int age;

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", 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;
    }
}

02. 泛型的理解和好处

1. 泛型的好处

  1. 编译时，检查添加元素类型，提高了安全性
  2. 减少了类型转换的次数，提高效率
    1. 不使用泛型 Dog - 加入 -> Object - 取出 -> Dog//放入到ArrayList 会先转成 Object，在取出时，还需要转换成Dog
    2. Dog -> Dog ->Dog//放入时，和取出时，不需要类型转换，提高效率
    3. 不再提示编译警告

2. 泛型介绍

  1. 泛型又称参数化类型，是jdk5.0 出现的新特性，解决数据类型的安全性问题
  2. 在类声明或实例化时只要指定好需要的具体类型即可
  3. java 泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常，同时，代码更加简洁、健壮
  4. 泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的类型，或者是某个方法的返回值类型，或者是参数类型。
public class Generic03 {
    public static void main(String[] args) {
        //注意：特别强调：E具体的数据类型在定义Person对象的时候指定，即在编译期间，就确定E是什么类型
        Person<String> yzj = new Person<>("yzj");
        yzj.show();
        /*
        可以这样理解：上面的这个Person类
        class Person{
            String s;//E 表示 s 的数据类型，该数据类型在定义Person对象的时候指定，即在编译几件，就确定E是什么类型

            public Person(String s) {//E也可以是参数类型
                this.s = s;
            }
            public String f() {//返回类型也可以是 E
                return s;
            }
        }
         */
        Person<Integer> integerPerson = new Person<>(21);
        integerPerson.show();
        /*
        可以这样理解：上面的这个Person类
        class Person{
            Integer s;//E 表示 s 的数据类型，该数据类型在定义Person对象的时候指定，即在编译几件，就确定E是什么类型

            public Person(Integer s) {//E也可以是参数类型
                this.s = s;
            }
            public Integer f() {//返回类型也可以是 E
                return s;
            }
        }
         */
    }
}

//泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的类型，
// 或者是某个方法的返回值类型，或者是类型参数。
class Person<E> {
    E s;//E 表示 s 的数据类型，该数据类型在定义Person对象的时候指定，即在编译几件，就确定E是什么类型

    public Person(E s) {//E也可以是参数类型
        this.s = s;
    }
    public E f() {//返回类型也可以是 E
        return s;
    }
    public void show() {
        System.out.println(s.getClass());//显示s的运行类型
    }
}

3. 泛型的语法

1. 泛型的声明

interface 接口 <T> {} 和 class 类 <K, V> {}
//比如：List, ArrayList

说明：

  1. 其中，T,K,V不代表值， 而是表示类型
  2. 任意字母都可以。常用T表示，是Type的缩写
2. 泛型的实例化

要在类名后面指定类型参数的值（类型）。如：

  1. List<String> strList = new ArrayList<String>();
  2. iterator<Customer> iterator = customers.iterator():
3. 泛型使用举例
  1. 创建三个学生对象
  2. 放入到HashSet中学生对象，使用
  3. 放入到HashMap中，要求 Key 是 String name，Value 就是学生对象
  4. 使用两种方式遍历
import java.util.*;
@SuppressWarnings("all")
public class TestGeneric01 {
    public static void main(String[] args) {
        //使用泛型的方式给HashSet放入三个学生对象
        HashSet<Student> students = new HashSet<>();
        students.add(new Student("jack", 18));
        students.add(new Student("tom", 18));
        students.add(new Student("jack", 18));

        //遍历
        for (Student student : students) {
            System.out.println(student);
        }
        Iterator<Student> iterator = students.iterator();
        while (iterator.hasNext()) {
            Student next = iterator.next();
            System.out.println(next);
        }

        //使用泛型的方式给HashMap 放入3个学生对象
        HashMap<String, Student> hm = new HashMap<>();
        hm.put("tom",new Student("tom", 28));
        hm.put("smith",new Student("smith", 48));
        hm.put("hsp",new Student("hsp", 28));

        //迭代器遍历
        /*
            public Set<Map.Entry<K,V>> entrySet() {
                Set<Map.Entry<K,V>> es;
                return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
            }
         */
        Set<Map.Entry<String, Student>> entries = hm.entrySet();
        /*
         public final Iterator<Map.Entry<K,V>> iterator() {
                return new EntryIterator();
            }
         */
        System.out.println("===============================");
        Iterator<Map.Entry<String, Student>> iterator1 = entries.iterator();
        while (iterator1.hasNext()) {
            Map.Entry<String, Student> next = iterator1.next();
            System.out.println(next.getKey() + "-" + next.getValue());
        }

    }
}

/**
 * 1. 创建三个学生对象
 * 2. 放入到HashSet中学生对象，使用
 * 3. 放入到HashMap中，要求 Key 是 String name，Value 就是学生对象
 * 4. 使用两种方式遍历
 */
class Student {
    private String name;
    private int age;

    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 +
                '}';
    }
}
4. 泛型使用的注意事项和细节
  1. interface List<T> {} , public class HashSet<E>… 等等
    说明：T, E 只能是引用类型
    看看下面语句是否正确？
    List<Integer> list = new ArrayList<Integer>();
    List<int> list2 = new ArrayList<int>();
    第二个是错误的：它没有满足引用类型的条件
  2. 在给泛型指定具体类型后，可以传入该类型或者其子类类型
  3. 泛型的使用形式
    List<Integer> list1 = new ArrayList<Integer>();
    List<Integer> list2 = new ArrayList<>();
  4. 如果我们这样写 List list3 = new ArrayList(); 默认给它的泛型是[<E> E就是 Object]
import java.util.ArrayList;
import java.util.List;

/**
 * 05. 泛型细节
 **/
@SuppressWarnings("all")
public class GenericDetail {
    public static void main(String[] args) {
        //1. 给泛型指向数据类型，要求是引用类型，不是能是基本数据类型
        ArrayList<Integer> integers = new ArrayList<>();
//        ArrayList<int> ints = new ArrayList<int>();//错误的

        //2. 在给泛型指定具体类型后，可以传入该类型或者其子类类型
        //  因为 E 指定了 A 类型 ，构造器传入了 new(A)
        Pig<A> aPig = new Pig<A>(new A());
        aPig.show();
        Pig<A> aPig1 = new Pig<A>(new B());
        aPig1.show();

        //3. 泛型的使用形式
        ArrayList<Integer> list1 = new ArrayList<Integer>();
        List<Integer> list2 = new ArrayList<Integer>();
        //在实际开发中，我们往往简写
        //编译器会进行类型推断，推荐
        ArrayList<Object> list3 = new ArrayList<>();
        List<Integer> list4 = new ArrayList<>();
        ArrayList<Pig> pigs = new ArrayList<>();

        //4. 如果是这样写 泛型默认是 Object
        ArrayList list = new ArrayList();//等价 ArrayList<Object> list = new ArrayList<>();
        list.add("xx");
        /*
            public boolean add(Object e) {
                ensureCapacityInternal(size + 1);  // Increments modCount!!
                elementData[size++] = e;
                return true;
            }
         */
        Tiger tiger = new Tiger();
        /*
        等价于
        class Tiger {
            Object e;
            public Tiger() {

            }
            public Tiger(Object e) {
                this.e = e;
            }
        }
         */

    }
}
class A {}
class B extends A{}
class Tiger<E> {
    E e;
    public Tiger() {

    }
    public Tiger(E e) {
        this.e = e;
    }
}
class Pig<E> {
    E e;

    public Pig(E e) {
        this.e = e;
    }
    public void show() {
        System.out.println(getClass());
    }
}

03. 自定义泛型

1. 基本语法

class 类名 <T, R…> { //也可以是接口，…表示可以有多个泛型
成员
}

2. 注意细节

  1. 普通成员可以使用泛型（属性、方法）
  2. 使用泛型的数组，不能初始化
  3. 静态方法中不能使用类的泛型
  4. 泛型类的类型，是在创建对象时确定的（因为创建对象时，需要指定确定的类型）
  5. 如果在创建对象时，没有指定类型，默认为Object
package com.yzjedu.customgeneric_;

/**
 * 01. 自定义泛型
 **/
public class CustomGeneric01 {
    public static void main(String[] args) {

    }
}
//解读
//1. Tiger 后面泛型，所以我们把Tiger 就称为自定义泛型类
//2. T, R, M 泛型的标识符，一般是单个大写字母
//3. 泛型标识符可以有多个。
//4. 普通成员可以使用泛型（属性、方法）
//5. 使用泛型的数组，不能初始化
//6. 静态方法中不能使用类的泛型

class Tiger<T, R, M> {
    String name;
    R r;
    M m;
    T t;
    //    5.错误：因为数组在new 不能确定确定T的类型，就无法在内存开辟空间
//    T[] ts = new T[8];

    //6. 错误，一位静态是和类相关的，在类加载的时，对象还没有创建
    //所以，如果静态方法和静态属性使用了泛型，JVM无法完成初始化
//    public static void  m1(M m) {
//
//    }


    public Tiger(String name, R r, M m, T t) { //构造器使用泛型
        this.name = name;
        this.r = r;
        this.m = m;
        this.t = t;
    }

    public String getName() {
        return name;
    }

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

    public R getR() {
        return r;
    }

    public void setR(R r) { //方法使用到泛型
        this.r = r;
    }

    public M getM() {//返回类型可以使用泛型
        return m;
    }

    public void setM(M m) {
        this.m = m;
    }

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

04. 自定义泛型方法

1. 语法

修饰符 <T, R> 返回类型 方法名(参数列表 ){
}

2. 注意细节

  1. 泛型方法，可以定义在普通类中，也可以定在泛型类中
  2. 当方法被调用时，类型会确定
  3. public void eat (E e) {}, 修饰符后没有<T, T…> eat 方法不是泛型方法，而是使用了泛型
import java.util.ArrayList;


public class CustomMethodGeneric {
    public static void main(String[] args) {
        //2. 当方法被调用时，类型会确定
        Car car = new Car();
        car.fly("宝马", 100);//当调用方法时，传入参数，编译器就会确定类型
        car.fly("300", 100.1);//当调用方法时，传入参数，编译器就会确定类型
        //4. 测试
        //  1. T - String  R - ArrayList
        Fish<String, ArrayList> fish = new Fish<>();
        fish.hello(new ArrayList(), 11.3f);

    }
}
//1. 泛型方法，可以定义在普通类中，也可以定在泛型类中
class Car { //普通类
    public void run() {//普通方法

    }
    public <T, R> void fly(T t, R r) { //泛型方法
        //说明泛型方法
        //1. <T, R> 就是泛型
        //2. 是提供给fly使用的
        System.out.println(t.getClass());
        System.out.println(r.getClass());
    }
}
class Fish<T, R> { //泛型类
    public void run(){//普通方法

    }
    public<U,M> void eat(U u, M m) { //泛型方法

    }
    //4. 说明：
    //  1. 下面是hi方法不是泛型方法
    //  2. 是hi方法使用了类声明的泛型
     public void hi(T t) {

        }
        //4. 泛型方法，可以使用类声明的泛型，也可以使用自己声明的泛型
    public<K> void hello(R r, K k) {
        System.out.println(r.getClass() + " " + k. getClass());
    }
}

05. 泛型的继承和通配符

1. 泛型的继承和通配符说明

  1. 泛型不具备继承性
    List<Object> list = new ArrayList<String>();//对吗？
  2. <?>: 支持任意类型的泛型
  3. <? extends A>: 支持A类以及A类的子类, 规定了泛型的上限
  4. <? super>: 支持A类以及A类的父类, 不限于直接父类,规定了泛型的下限

2. 应用案例

import java.util.ArrayList;
import java.util.List;

/**
 * 03. Generic的通配符和继承
 **/
public class GenericExtends {
    public static void main(String[] args) {
        Object o = new String("xx");

        //1. 泛型没有继承性
//        List<Object> list = new ArrayList<String>(); 错误的

        //举例说明下面三个方法的使用
        ArrayList<Object> list1= new ArrayList<>();
        ArrayList<String> list2= new ArrayList<>();
        ArrayList<AA> list3= new ArrayList<>();
        ArrayList<BB> list4= new ArrayList<>();
        ArrayList<CC> list5= new ArrayList<>();
        //如果是 List<?> c, 可以接收任意的泛型类型
        printCollection1(list1);
        printCollection1(list2);
        printCollection1(list3);
        printCollection1(list4);
        printCollection1(list5);
        
        //List<? extends AA> c 表示上限，可以接受 AA或者AA子类
//        printCollection2(list1); ×
//        printCollection2(list2); ×
        printCollection2(list3);
        printCollection2(list4);
        printCollection2(list5);
        
        //List<? super> 子类类名 AA:支持 AA 类以及 AA 类的父类，不限于直接父类，
        printCollection3(list1);
//        printCollection3(list2); ×
        printCollection3(list3);
//        printCollection3(list4); ×
//        printCollection3(list5); ×
    }

    //2. 编写几个方法
    //说明：List<?> 表示任意的泛型类型可以接受
    public static void printCollection1(List<?> c) {
        for (Object object : c) {
            System.out.println(object);
        }
    }

    //3. ? extends AA 表示上限，可以接受 AA或者AA子类
    public static void printCollection2(List<? extends AA> c) {
        for (Object object : c) {
            System.out.println(object);
        }
    }
    //4. List<? super> 子类类名 AA:支持 AA 类以及 AA 类的父类，不限于直接父类，
    //规定了泛型的下限
    public static void printCollection3(List<? super AA> c) {
        for (Object object : c) {
            System.out.println(object);
        }
    }
}
class AA {

}

class BB extends AA {

}

class CC extends BB {

}

06. JUnit

1. 为什么需要Junit

  1. 一个类有很多功能代码需要测试，为了测试，就需要写入到main方法中
  2. 如果有多个功能代码测试，就需要来回注销, 切换很麻烦
  3. 如果可以直接运行一个方法, 就方便很多, 并且可以给出相关信息, 就好了 -> JUnit

2. 基本介绍

  1. JUnit是一个Java语言的单元测试框架
  2. 多数Java开发环境都已经集成了JUnit作为单元测试的工具

3. JUnit加入方式

  1. JUnit有很多种加入方式，这里我只讲解最常见的加入方式
    1. 假如你写了两个方法分别是m1和m2
    2. 你可以在方法前加上@Test
    3. 第一次加入@Test 需要alt＋ Enter快捷键 引入 JUnit5.4
    4. 等待下载完成即可
import org.junit.jupiter.api.Test;

public class JUnit_ {
    public static void main(String[] args) {
        //传统方式
        new JUnit_().m1();
    }

    @Test
    public void m1() {
        System.out.println("m1方法被调用");
    }
    @Test
    public void m2() {
        System.out.println("m2方法被调用");
    }
}
绝世小帅
关注
  • 29
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Educoder–Java面向对象-泛型程序设计【笔记+参考代码】
12-21
补充完成右侧泛型程序设计代码，定义泛型类，实现两个对象的比较，并输出最大者。输入的数据可能是整数，也可能是浮点数，也可能是字符串。 字符串比大小，按照字母顺序，如c>a 参考代码 package step1; public ...
565.563.JAVA基础教程_泛型与File-为什么要使用泛型(565).rar
11-09
Java编程语言是面向对象的、高性能的编程语言，被广泛应用于企业级应用开发。在Java中，泛型和File类是两个重要的概念，对于提升代码的类型安全性、可读性和复用性起着至关重要的作用。 **泛型（Generics）** 泛型...
java泛型给多个对象_3. Java面向对象之泛型－指定多个泛型
weixin_39785970的博客
03-01 246
3. Java面向对象之泛型－指定多个泛型package generic; class MutiGeneric { private K key; private T take; public K getKey() { return key; } public void setKey(K key) { this.key = key; } public T getTake() { re...
Java面向对象编程-泛型
qq_50743381的博客
05-06 607
泛型 1、泛型问题的引出 泛型从JDK1.5之后追加到Java语言里面的，其主要的是为了解决ClassCastException的问题，在进行对象的向下转型时永远都存在有安全隐患，而Java希望通过泛型慢慢解决掉此类问题 泛型问题的引出 现在假设说定义一个描述x与y坐标的处理类，并且在这个类之中允许开发者保存有三类数据 整型数据：x=10、y=20 浮点型数据：x=10.1、y=20.9 字符串型数据：x=东经120度、北纬30度 于是在设计Point类的时候就需要去考虑具体的x和y属性的类
1. Java面向对象之泛型－认识泛型
小平果的欢乐谷
07-28 932
package generic; class Point{ private  Object x; private  Object y; public Object getX() { return x; } public void setX(Object x) { this.x = x; } public Object getY() { return y; } pu
3. Java面向对象之泛型－指定多个泛型
小平果的欢乐谷
07-28 1320
3. Java面向对象之泛型－指定多个泛型 package generic; class MutiGeneric { private K key; private T take; public K getKey() { return key; } public void setKey(K key) { this.key = key; }
Java面向对象---泛型
小白知浅的博客
10-07 118
Java面向对象---泛型 概念 泛型可以解决数据类型的安全问题，主要原理是在类声明的时候通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。 格式 访问权限 class 类名称&lt;泛型，泛型。。。&gt;｛ 属性 方法 ｝ 示例代码 public class Gnericity&lt;T,...
2. Java面向对象之泛型－构造方法中使用
小平果的欢乐谷
07-28 3419
package generic; class Construtgeneric { private T value; public Construtgeneric(T value) { this.value = value; } public T getValue() { return value; } public void setValue(T
JAVA面向对象之泛型
Lyajpunov的博客
01-11 1539
契子、引入泛型 我们在学习JAVA中经常会写这样一些类用来联系，比如超级数组，我们先写一个这样的类 SuperArray.java package com; import java.util.Arrays; public class SuperArray { // 定义我们操作的数组,初始化长度为10 private int[] num = new int[10]; // 定义游标 private int current = -1; // 空参构造 pub
Java面向对象设计 - Java泛型约束
2301_78772942的博客
06-17 341
Java面向对象设计 - Java泛型约束
05.Java-Advanced
03-14
Java是一种广泛使用的面向对象的编程语言，以其跨平台、高性能和丰富的类库而闻名。"05.Java-Advanced"这个标题暗示我们将深入探讨Java的高级特性，这些特性使得Java不仅适用于初学者，也深受专业开发者的青睐。在这...
java-24-hours_source.zip_24-hours-ja_40
09-14
Java是一种广泛使用的面向对象的编程语言，由Sun Microsystems（现为Oracle公司）于1995年推出。它以其“一次编写，到处运行”的跨平台特性而闻名，这得益于Java虚拟机（JVM）的支持。书中的源码适用于JDK 1.30到...
Java面向对象程序设计+源代码+课后习题答案)
10-31
Java面向对象程序设计是计算机科学中的一个重要领域，它基于面向对象编程（OOP）的概念，是一种强大的编程范式。在Java中，OOP的核心概念包括类、对象、封装、继承、多态等。这本书"Java面向对象程序设计"由耿祥义和...
10.javaSE基础_JDBC编译程序(Driver+Statement+Connection+mysql数据库连接)
m0_61086522的博客
07-02 1208
JDBC是的缩写。它是Sun的Javasoft公司制定的Java数据库连接技术，是一套标准接口java.sql包中提供了JDBC API,通过它连接到各种数据库系统，编写访问数据库的程序。JDBC API不能直接访问数据库，它依赖于数据库厂商提供的JDBC Driver（JDBC驱动程序）
JVM原理（十一）：JVM虚拟机六种必需对类进行初始化的情况
zuodingquan666的博客
07-03 494
Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这个过程被称作虚拟机的类加载机制。Java天生可以动态扩展的语言特性就是依赖运行期间动态加载和动态链接这个特点实现的。
解决分布式环境下session共享问题
最新发布
shenxiaomo1688的博客
07-06 484
在分布式环境下，session会存在两个问题第一个问题:不同域名下，浏览器存储的jsessionid是没有存储的。比如登录时认证服务auth.gulimall.com存储了session，但是搜索服务search.gulimall.com是没有这个session的；
java 程序、进程 、线程，cpu，并行、并发、启动线程两种方式
gu2022_3_5_21_23的博客
07-02 300
Thread 方式 线程间不可以共享数据，除非变量加 static 变为 静态变量 （每次创建实例，会有一个新的副本）。条件二： 重写 Thread 父类方法 后创建实例调用 start 方法 （创建匿名子类的匿名对象）条件一： 将创建自实现 Runable 接口后的实例 作为参数传递给 Thread 的构造方法。2、将创建自实现 Runable 接口后的实例 作为参数传递给 Thread 的构造方法。最后调用的都是 Thread 的start 的方法。创建的线程对象，都是Thread类或其子类的实例。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值