P547集合家庭作业1-泛型-Junit

最新推荐文章于 2024-07-13 13:55:40 发布
最新推荐文章于 2024-07-13 13:55:40 发布
阅读量387 收藏
点赞数
分类专栏： 韩顺平java基础学习 文章标签： java intellij-idea 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kuimeiyuzu/article/details/122745134
版权

P547集合家庭作业1

public class Collection {
    public static void main(String[] args) {
        News news1 = new News("1234567890123450000000000000");
        News news2 = new News("2234567890123450000000000000");
        ArrayList aList = new ArrayList();
        aList.add(news1);
        aList.add(news2);
        List list1 = new ArrayList();
        for (int i = aList.size()-1; i >=0 ; i--) {
            News newss=(News) aList.get(i);
            System.out.println(processTitle(newss.getTitle()));
        }
    }
    public static String processTitle(String title){
        if(title==null){
            return "";
        }
        if(title.length()>15){
            return title.substring(0,15)+"......";
        }else {
            return title;
        }
    }
}
class News{
    private String title;
    private String tell;
​
    public News(String title) {
        this.title = title;
    }
​
    @Override
    public String toString() {
        return "News{" +
                "title='" + title + '\'' +
                '}';
    }
​
    public String getTitle() {
        return title;
    }
​
    public void setTitle(String title) {
        this.title = title;
    }
​
    public String getTell() {
        return tell;
    }
​
    public void setTell(String tell) {
        this.tell = tell;
    }
}
public class Collections2 {
    public static void main(String[] args) {
        Car car1 = new Car("BM", 40000);
        Car car2 = new Car("BL", 50000);
        ArrayList at1 = new ArrayList();
        ArrayList at2 = new ArrayList();
        at1.add(car1);
        at1.add(car2);
        at2.addAll(at1);
        System.out.println(at1.remove(1));//Car{name='BL', price=50000.0}
        System.out.println(at1.contains("BM"));//false
        System.out.println(at1.size());//输出1
        System.out.println(at1.isEmpty());//输出false
        System.out.println(at1.containsAll(at1));//true
        System.out.println(at1.removeAll(at1));//true
        System.out.println(at1);
        System.out.println(at2);
        //迭代
        Iterator iterator = at2.iterator();
        while (iterator.hasNext()) {
            Object next =  iterator.next();
            System.out.println(next);
        }
        for (Object o :at2) {
            Car car=(Car) o;
            System.out.println(car);
        }
    }
}
class Car{
    private String name;
    private double price;
​
    public Car(String name, double price) {
        this.name = name;
        this.price = price;
    }
​
    @Override
    public String toString() {
        return "Car{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public double getPrice() {
        return price;
    }
​
    public void setPrice(double price) {
        this.price = price;
    }
}

P549作业3

public class Collections3 {
    public static void main(String[] args) {
        Map m = new HashMap();
       m.put("jack",650);
       m.put("tom",1200);
       m.put("simith",2900);
       m.put("jack",2600);
        //另一种方法
       //m.put(key,(Interger)m.get(key)+100);
        for (Object entry :m.entrySet()) {
            Map.Entry s= (Map.Entry) entry;
            s.setValue((int)s.getValue()+100);
            //强转
            System.out.println(s.getValue());
            System.out.println(s.getKey());
            System.out.println(s);
        }
    }
}

set.remove(p1)//不一定删除成功，因为根据1001,CC此时索引变化不是1001，AA的索引位置

set.add(10001,CC)可加，而ste(10001,AA)会加在原本set(1000,ccc)后面

最后输出4对象

P553泛型的引入

​

P554java泛型入门

public static void main(String[] args) {
//1. 当我们ArrayList<Dog> 表示存放到ArrayList 集合中的元素是Dog 类型(细节后面说...)
//2. 如果编译器发现添加的类型，不满足要求，就会报错
//3. 在遍历的时候，可以直接取出Dog 类型而不是Object
//4. public class ArrayList<E> {} E 称为泛型,那么Dog->E
        ArrayList<Dog> arrayList = new ArrayList<Dog>();
        arrayList.add(new Dog("11",1));
        arrayList.add(new Dog("12",2));
        arrayList.add(new Dog("13",3));
        //arrayList.add(new Cat("zcm",8));会报错
        for (Dog dog :arrayList) {
            System.out.println(dog.getName()+dog.getAge());
        }
    }

P555

public class Generic01 {
    public static void main(String[] args) {
        Person<String> person = new Person<String>("yue");
        Person<Integer> Person2 = new Person<Integer>(100);
        //注意，特别强调： E 具体的数据类型在定义Person 对象的时候指定,
        // 即在编译期间，就确定E 是什么类型
        person.show();//输出class java.lang.String
        Person2.show();//输出class java.lang.Integer
    }
}
//泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的类型，
// 或者是某个方法的返回值的类型，或者是参数类型
class Person<E>{
    //E 表示s 的数据类型, 该数据类型在定义Person 对象的时候指定,即在编译期间，就确定E 是什么类型
    E s;
​
    public Person(E s) {
        this.s = s;
    }
    public E f(){
        return s;
    }
    public void show(){
        System.out.println(s.getClass());
        //显示s的运行类型
    }
}

P556泛型的应用实例

public class GenericExercise02 {
    public static void main(String[] args) {
        HashSet <Student> sset = new HashSet<Student>();
        sset.add(new Student("y1",1));
        sset.add(new Student("y2",2));
        sset.add(new Student("y3",3));
        System.out.println(sset);
        for (Student o :sset) {
            System.out.println(o);
        }
        /*
        Iterator<Student> iterator = sset.iterator();
​
        while (iterator.hasNext()) {
            Student next =  iterator.next();
            System.out.println(next);
​
        }
         */
        HashMap<String, Student> sp = new HashMap<>();
        sp.put("y1",new Student("y1",1));
        sp.put("y2",new Student("y2",1));
        sp.put("y3",new Student("y3",1));
        System.out.println(sp);
        //sp-key同 ，value同只有一个，key不同，value不同替换
        for (String o :sp.keySet()) {
            System.out.println(sp.get(o));
        }
        //迭代器
        Set<Map.Entry<String, Student>> entries = sp.entrySet();
        //源码
        //public Set<Map.Entry<K,V>> entrySet() {
        //        Set<Map.Entry<K,V>> es;
        //        return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
        //    }
        Iterator<Map.Entry<String, Student>> iterator = entries.iterator();
        /*
        public final Iterator<Map.Entry<K,V>> iterator() {
        return new EntryIterator();
        }
        */
        while (iterator.hasNext()) {
            Map.Entry<String, Student> next =  iterator.next();
            System.out.println(next.getValue());
            
        }
    }
}
class Student{
    public String name;
    public int age;
​
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
​
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

P557泛型使用细节1

public class GenericDetial {
    public static void main(String[] args) {
        //1.给泛型指向数据类型是，要求是引用类型，不能是基本数据类型
        List<Integer> list = new ArrayList<Integer>(); //OK
//List<int> list2 = new ArrayList<int>();//错误
//2. 说明
//因为E 指定了A 类型, 构造器传入了new A()
//在给泛型指定具体类型后，可以传入该类型或者其子类类型
        Pig<A> aPig = new Pig<A>(new A());
        aPig.f();
        Pig<A> aPig2 = new Pig<A>(new B());
        aPig2.f();
//3. 泛型的使用形式
        ArrayList<Integer> list1 = new ArrayList<Integer>();
        List<Integer> list2 = new ArrayList<Integer>();
//在实际开发中，我们往往简写
//编译器会进行类型推断, 老师推荐使用下面写法
        ArrayList<Integer> list3 = new ArrayList<>();
        List<Integer> list4 = new ArrayList<>();
        ArrayList<Pig> pigs = new ArrayList<>();
//4. 如果是这样写泛型默认是Object
        ArrayList arrayList = new ArrayList();
        //等价ArrayList<Object> arrayList = new ArrayList<Object>();
         /*
            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 Tiger<E> {//类
    E e;
    public Tiger() {}
    public Tiger(E e) {
        this.e = e;
    }
}
class A {}
class B extends A {}
class Pig<E> {//
    E e;
    public Pig(E e) {
        this.e = e;
    }
    public void f() {
        System.out.println(e.getClass()); //运行类型
    }
}

P559泛型练习

public class GenericDetial {
    public static void main(String[] args) {
        ArrayList<Em> at = new ArrayList<>();
        Em y1 = new Em("y1", 11, new MyDate(1, 1, 1));
        Em y2 = new Em("y2", 11, new MyDate(2, 3, 4));
        Em y11 = new Em("y1", 11, new MyDate(1, 1, 2));
        at.add(y1);
        at.add(y2);
        at.add(y11);
        System.out.println(at);
        //排序
        at.sort(new Comparator<Em>() {
            @Override
            public int compare(Em o1, Em o2) {
                if (!(o1 instanceof Em && o2 instanceof Em)){
                    System.out.println("类型不正确");
                    return 0;
                }
                if (o1.getName() != o2.getName()){
                    return o1.getName().compareTo(o2.getName());
                }else {
                    if (o1.getBitrhdy().getYear() != o2.getBitrhdy().getYear()){
                         return o1.getBitrhdy().getYear() - o2.getBitrhdy().getYear();
                    }else {
                        if (o1.getBitrhdy().getMonth() != o2.getBitrhdy().getMonth()) {
                            return o1.getBitrhdy().getMonth() - o2.getBitrhdy().getMonth();
                        }else {
                            if (o1.getBitrhdy().getDay() != o2.getBitrhdy().getDay()){
                                return o1.getBitrhdy().getDay() - o2.getBitrhdy().getDay();
                            }else {
                                return 0;
                            }
                        }
                    }
​
                }
​
            }
        });
        //以下是老师的方法。比我的好用
        at.sort(new Comparator<Em>() {
            @Override
            public int compare(Em o1, Em o2) {
                int i=o1.getName().compareTo(o2.getName());
                if(i !=0){
                    return i;
                }
                int yearMinus=o1.getBitrhdy().getYear()-o2.getBitrhdy().getYear();
                if(yearMinus !=0){
                    return yearMinus;
                }
                int monthMinus=o1.getBitrhdy().getMonth() - o2.getBitrhdy().getMonth();
                if( monthMinus !=0){
                    return  monthMinus;
                }
                int dayMinus=o1.getBitrhdy().getDay() - o2.getBitrhdy().getDay();
                if (dayMinus !=0){
                    return dayMinus;
                }
                return 0;
            }
        });
        System.out.println(at);
    }
}
class Em{
    private String name;
    private  double sal;
    private MyDate bitrhdy;
​
    public Em(String name, double sal, MyDate bitrhdy) {
        this.name = name;
        this.sal = sal;
        this.bitrhdy = bitrhdy;
    }
​
    @Override
    public String toString() {
        return "Em{" +
                "name='" + name + '\'' +
                ", sal=" + sal +
                ", bitrhdy=" + bitrhdy +
                '}';
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public double getSal() {
        return sal;
    }
​
    public void setSal(double sal) {
        this.sal = sal;
    }
​
    public MyDate getBitrhdy() {
        return bitrhdy;
    }
​
    public void setBitrhdy(MyDate bitrhdy) {
        this.bitrhdy = bitrhdy;
    }
}
class MyDate{
    private int year;
    private int month;
    private int day;
​
    public MyDate(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }
​
    @Override
    public String toString() {
        return "MyDate{" +
                "year=" + year +
                ", month=" + month +
                ", day=" + day +
                '}';
    }
​
    public int getYear() {
        return year;
    }
​
    public void setYear(int year) {
        this.year = year;
    }
​
    public int getMonth() {
        return month;
    }
​
    public void setMonth(int month) {
        this.month = month;
    }
​
    public int getDay() {
        return day;
    }
​
    public void setDay(int day) {
        this.day = day;
    }
}

P560自定义泛型

public class CustomGeneric {
    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. T[] ts=new T[9];//不允许
    //Type parameter 'T' cannot be instantiated directly
    因为数组在new 不能确定T 的类型，就无法在内存开空间
    T[]ts;//可以
    /*
    6.public static void f1(M m){//不可以
//因为静态是和类相关的，在类加载时，对象还没有创建
//所以，如果静态方法和静态属性使用了泛型，JVM 就无法完成初始化
    }
     */
​
    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;
    }
}

p561自定义泛型接口

public class GenericInterface {
    public static void main(String[] args) {
    }
}
/**
 * 泛型接口使用的说明
 * 1. 接口中，静态成员也不能使用泛型
 * 2. 泛型接口的类型, 在继承接口或者实现接口时确定
 * 3. 没有指定类型，默认为Object
 */
class CC implements IUsb<Object,Object>{//这样规范，不写也可以通过
    @Override
    public Object get(Object o) {
        return null;
    }
    @Override
    public void hi(Object o) {
    }
    @Override
    public void run(Object r1, Object r2, Object u1, Object u2) {
    }
}
​
//实现接口,
// 实现接口时，直接指定泛型接口的类型
给U 指定Integer 给R 指定了Float
所以，当我们实现IUsb 方法时，会使用Integer 替换U, 使用Float 替换R
class BB implements IUsb<Integer,Float>{
    @Override
    public Float get(Integer integer) {
        return null;
    }
    @Override
    public void hi(Float aFloat) {
    }
    @Override
    public void run(Float r1, Float r2, Integer u1, Integer u2) {
    }
}
​
​
//2.在继承接口指定泛型接口的类型
interface IA extends IUsb<String, Double> { }
class AA implements IA{
    //此时AA必须实现IA、IU的抽象方法
    //当我们去实现IA 接口时，因为IA 在继承IUsu 接口时，指定了U 为String R 为Double
//，在实现IUsu 接口的方法时，使用String 替换U, 是Double 替换R
    @Override
    public Double get(String s) {
        return null;
    }
    @Override
    public void hi(Double aDouble) {
    }
    @Override
    public void run(Double r1, Double r2, String u1, String u2) {
    }
}
interface IUsb<U, R> {
    int n = 10;
//1.U name; 不能这样使用//接口中的属性都是静态的
    //普通方法中，可以使用接口泛型
    R get(U u);
    void hi(R r);
    void run(R r1, R r2, U u1, U u2);
    //在jdk8 中，可以在接口中，使用默认方法, 也是可以使用泛型
    default R method(U u) {
        return null;
    }
}

P562自定义泛型方法

public class GenericMehod {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.fly("BWM",3);当调用方法时，传入参数，编译器，就会确定类型
        cat.fly(111.1,111.1);
        //测试
        Fish<String, ArrayList> sh = new Fish<>();
        sh.hello(new ArrayList(),1.1f);
        //class java.util.ArrayList
        //class java.lang.Float
    }
}
class Cat{
    public void run(){
    }
    public<T,R> void fly(T t,R r){//泛型方法说明泛型方法
//1. <T,R> 就是泛型//2. 是提供给fly 使用的
        System.out.println(t.getClass());
    }
}
class Fish<T ,R>{//泛型类。
    public void Run(){
​
    }
    public <M,U> void eat(M m,U U){//泛型方法
    }
    public void hi(T t){//不是泛型方法，而是使用了类声明的方法
    }
    //注意：泛型方法，可以使用类声明的泛型，也可以使用自己声明泛型
    public <K> void hello(R r,K k){
        System.out.println(r.getClass());
        System.out.println(k.getClass());
    }
}

P563

Integer,Dog

P564泛型继承和通配符

public class GenericExtend {
    public static void main(String[] args) {
        Object o=new String();//ok
        //泛型没有继承性//List<Object> list = new ArrayList<String>();//no
        //举例说明下面三个方法的使用
        List<Object> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();
        List<AA1> list3 = new ArrayList<>();
        List<BB1> list4 = new ArrayList<>();
        List<CC1> list5 = new ArrayList<>();
        //如果是List<?> c ，可以接受任意的泛型类型
        printCollection1(list1);
        printCollection1(list5);
        //List<? extends AA> c： 表示上限，可以接受AA 或者AA 子类
        // printCollection2(list1);//×
        // printCollection2(list2);//×
        printCollection2(list3);//√
        printCollection2(list4);//√
        printCollection2(list5);//√
        //List<? super AA> c: 支持AA 类以及AA 类的父类，不限于直接父类
        printCollection3(list1);//√
       //printCollection3(list2);//×
        printCollection3(list3);//√
       //printCollection3(list4);//×
       //printCollection3(list5);//×
    }
    // ? extends AA 表示上限，可以接受AA 或者AA 子类
    public static void printCollection2(List<? extends AA1> c) {
        for (Object object : c) {
            System.out.println(object);
        }
    }
    //说明: List<?> 表示任意的泛型类型都可以接受
    public static void printCollection1(List<?> c) {
        for (Object object : c) { // 通配符，取出时，就是Object
            System.out.println(object);
        }
    }
    // ? super 子类类名AA:支持AA 类以及AA 类的父类，不限于直接父类，
//规定了泛型的下限
    public static void printCollection3(List<? super AA1> c) {
        for (Object object : c) {
            System.out.println(object);
        }
    }
}
class AA1 {
​
}
class BB1 extends AA1 {
}
class CC1 extends BB1 {
}

P565泛型作业

package junit;
​
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方法调用");
    }
}

使用maven

使用@Test

package Generic;
import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
​
public class GeneticHomwok01 {
    public static void main(String[] args) {
    }
    @Test
    public void test(){
        DAO<User> dog = new DAO<>();
        dog.save("s2",new User(2,22,"s22"));
        dog.save("s1",new User(1,11,"s11"));
        dog.save("s3",new User(3,33,"s33"));
        List<User> list = dog.list();
        System.out.println(list);
        //输出[User{id=3, age=33, name='s33'}, User{id=1, age=11, name='s11'},
        // User{id=2, age=22, name='s22'}]
        dog.update("s3",new User(3,58,"ml"));
        list = dog.list();
        System.out.println(list);
        //输出[User{id=3, age=58, name='ml'}, User{id=1, age=11, name='s11'},
        // User{id=2, age=22, name='s22'}]
        dog.delete("s3");
        list = dog.list();
        System.out.println(list);
        //输出[User{id=1, age=11, name='s11'}, User{id=2, age=22, name='s22'}]
        System.out.println(dog.get("s1"));
        //输出User{id=1, age=11, name='s11'}
    }
}
class DAO<T>{
     private Map<String,T> map=new HashMap<>();
​
    public Map<String, T> getMap() {
        return map;
    }
​
    public void save(String id, T entity){
         map.put(id,entity);
     }
     public T get(String id){
         return map.get(id);
     }
     public void update(String id,T entity){
         map.put(id,entity);
     }
     //遍历map[k-v]将map的所有values(entry)分装到arraylist返回即可
     public List<T> list(){
         List <T>arrayList = new ArrayList();
        // arrayList.add(map.values());
         for (T o : map.values()) {
             arrayList.add(o);
         }
         return arrayList;
     }
     public void delete(String id){
         map.remove(id);
     }
​
    @Override
    public String toString() {
        return "DAO{" +
                "map=" + map +
                '}';
    }
}
class User{
    private int id;
    private int age;
    private String name;
​
    public User(int id, int age, String name) {
        this.id = id;
        this.age = age;
        this.name = name;
    }
​
    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

「已注销」
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Kotlin-泛型
行云间
12-11 1万+
概述一般类和函数，只能使用具体的类型：要么是基本类型，要么是自定义的类。如果要编写可以应用于多种类型的代码，这种刻板的约束对代码的限制很大。而OOP的多态采用了一种泛化的机制，在SE 5种，Java引用了泛型。泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时
java泛型详解
热门推荐
菜鸟的蜕变
04-29 5万+
1、什么是java泛型？ 泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。 2、为什么需要泛型？ Java语言引入泛型的好处是安全简单。可以将运行时错误提前到编译时错误。 在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现
Java工程师成神之路java基础知识之泛型
r_b_y的博客
04-29 254
原文作者：Hollis 什么是泛型 Java泛型（ generics） 是JDK 5中引⼊的⼀个新特性， 允许在定义类和接⼜的时候使⽤类型参数（ type parameter） 。 声明的类型参数在使⽤时⽤具体的类型来替换。 泛型最主要的应⽤是在JDK 5中的新集合类框架中。 泛型最⼤的好处是可以提⾼代码的复⽤性。 以List接⼜为例，我们可以将String、 Integer等类型放⼊List中， 如不⽤泛型， 存放String类型要写⼀个List接口， 存放Integer要写另外⼀个List接口， 泛型可
java泛型数组：Type parameter ‘T‘ cannot be instantiated directly
eyes++的博客
02-14 1万+
今天因为需要封装一些类，使用了泛型创建数组，方法如下： T[] container = new T[capacity]; 然后编译器报错： 报错Type parameter 'T' cannot be instantiated directly，即类型参数“T”不能直接实例化。 原因就是Java的泛型是通过类型擦除(type erasure)来实现的。什么是类型擦除呢，简单来说Java在编译期间，所有的泛型信息都会被擦除掉。如在代码中定义的List和List等类型，在编译后都会变成List。JVM看到的
Java泛型(韩顺平)
m0_63642902的博客
06-18 234
使用传统方法的问题分析 泛型的理解和好处 泛型的好处 代码演示 泛型使用的注意事项和细节 代码演示 泛型课堂练习题 代码演示Employee类 MyDate类 GenericExercise02 代码演示 '代码演示 自定义泛型方法 泛型的继承和通配符 本章作业 User类 Dao类 Homework01 JUnit 为什么需要 JUnit...
A002-185-2537-翁格婉（个人期末作业）
qq_33680482的博客
01-02 2436
Excel查找结合项目主题说明1.作业查词说明1.1第一次查词1.1.1Requirements baseline（需求基线）1.1.2Enterprise Architect（企业架构师）1.1.3Unified Modeling Language（ 统一建模语言）1.1.3Unified Modeling Language（ 统一建模语言）1.1.5Asynchronous Processes（异步进程）1.1.6association class（关联类）1.1.7behavioral model a
第 15 章 泛型
weixin_59496235的博客
09-28 225
无
文章收录1
ithome
08-02 1万+
3.Hive Metastore 代码简析 4.受限的玻尔兹曼机 5.以公司实际应用讲解OpenStack到底是什么 6.Ubuntu12.04安装hadoop 7.vpsmate安装完再重启服务器，vpsmate不无再次打开的解决方法 8.如何使用JDBC快速处理大数据 9.关于集群技术的几个新工具的介绍 10.CHD4 impa...
java之面向对象2笔记
weixin_45653478的博客
06-10 609
接口的定义，它与定义类方式相似，但是使用interface关键字。它也会被编译成.class文件，但一定要明确它并不是类，而是另外一种引用数据类型。引用数据类型：数组，类，枚举，接口，注解。接口本身不能创建对象，只能创建接口的实现类对象，接口类型的变量可以与实现类对象构成多态引用。声明接口用interface，接口的成员声明有限制：（1）公共的静态常量（2）公共的抽象方法（3）公共的默认方法（JDK8.0 及以上）（4）公共的静态方法（JDK8.0 及以上）
Java-FU-家庭作业-Teplov-PI19-4
02-28
【Java-FU-家庭作业-Teplov-PI19-4：深入理解Java编程基础】 在这个特定的Java-FU（Java Functional Utilities）家庭作业项目中，Teplov-PI19-4，我们聚焦于Java编程语言的核心概念和实践。Java是一种广泛使用的...
DrLutforsProject:家庭作业
05-10
【DrLutforsProject:家庭作业】项目是一个基于Java编程语言的实践练习，旨在帮助学习者深入理解Java的核心概念和编程技巧。在这个项目中，"推拉"可能指的是使用Git进行版本控制，推（Push）指的是将本地更改上传到...
COMPSC_1033_HomeWork:COMPSC_1033或计算机科学的家庭作业1
05-04
标题 "COMPSC_1033_HomeWork:COMPSC_1033或计算机科学的家庭作业1" 暗示这是一个与计算机科学课程相关的作业，可能是编程项目，特别是考虑到标签是 "Java"，我们可以推测这是一份用Java语言编写的作业。作业可能涉及...
TextyProgrammingTest:编程家庭作业研讨会
05-08
【标题】"TextyProgrammingTest:编程家庭作业研讨会"是一个以Java编程为主题的项目，旨在帮助学生和编程爱好者解决他们在家庭作业中遇到的问题。这个项目提供了一个互动的平台，让用户能够学习、实践和讨论与Java...
JavaOOP:SoftUni Java OOP家庭作业
03-19
在"SoftUni Java OOP家庭作业"中，我们可以期待深入学习这些关键概念以及如何在实际项目中应用它们。 **封装**是OOP的基本原则之一，它意味着将数据和操作这些数据的方法捆绑在一个单元——类中，以保护数据不被...
Elsaticsearch java基本操作
最新发布
qq_62383709的博客
07-13 440
索引 基本操作 package com.orchids.elasticsearch.web.controller; import cn.hutool.core.collection.CollUtil; import cn.hutool.json.JSONUtil; import com.orchids.elasticsearch.web.po.User; import io.swagger.annotations.Api; import io.swagger.annotations.ApiOperatio
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 476
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 465
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
java Object 转 Integer
servepeople的博客
07-09 1474
在 Java 中，可以通过多种方法将一个Object转换为Integer。
jmu-java-05集合(泛型)-10-generalstack
06-28
jmu-java-05集合(泛型)-10-generalstack是关于Java泛型中的通用栈的学习内容。通用栈是一种可以存储任意类型数据的栈结构，通过泛型的方式实现。在学习中，我们可以了解到通用栈的实现原理、使用方法以及注意事项等...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值