【java-04】深入浅出多态、内部类、常用API

news2024/11/16 15:46:31

主要内容

1 多态

1.1 面向对象三大特征 ?

  • 封装 , 继承 , 多态

1.2 什么是多态 ?

  • 一个对象在不同时刻体现出来的不同形态

  • 举例 : 一只猫对象

    • 我们可以说猫就是猫 : Cat cat = new Cat();
    • 我们也可以说猫是动物 : Animal cat = new Cat();
    • 这里对象在不同时刻,体现出来的不同形态 , 我们就可以理解为多态

1.3 多态的前提

  • 有继承/实现关系
  • 有方法重写
  • 父类的引用指向子类的对象
package com.bn.polymorphism_demo;
/*
    多态的三个前提条件
        1 需要有继承/实现关系
        2 需要有方法重写
        3 父类的引用指向子类的对象
 */
public class AnimalTest {
    public static void main(String[] args) {
        // 3 父类的引用指向子类的对象
        // 多态形式对象
        Animal a = new Cat();
    }
}

class Animal{
    public void eat(){
        System.out.println("吃东西");
    }
}

class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼....");
    }
}

1.4 多态的成员访问特点

  • 构造方法 : 和继承一样 , 子类通过super()访问父类的构造方法
  • 成员变量 : 编译看左边(父类) , 执行看左边(父类)
  • 成员方法 : 编译看左边(父类) , 执行看右边(子类)
package com.bn.polymorphism_demo;

/*
    多态的成员访问特点 :
        1 构造方法 : 和继承一样 , 都是通过super()访问父类的构造方法
        2 成员变量 : 编译看左边(父类) , 执行看左边(父类)
        3 成员方法 : 编译看左边(父类) , 执行看右边(子类) , 注意 , 如果执行时
            1) 子类没有回动态去找父类中的方法
            2) 子类的特有方法无法进行调用(多态的缺点)
 */
public class MemberTest {
    public static void main(String[] args) {
        // 父类的引用指向子类的对象
        Fu f = new Zi();

        // 多态对象调用成员变量
        System.out.println(f.num);

        // 多态对新乡调用调用成员方法
        f.show();

        // 多态对象不能调用子类特有的方法
        // f.show2();
    }
}

class Fu {
    int num = 100;

    public void show() {
        System.out.println("父类的show方法");
    }
}

class Zi extends Fu {
    int num = 10;

    public void show() {
        System.out.println("子类的show方法");
    }

    public void show2(){
        System.out.println("子类特有的方法");
    }
}

1.5 多态的优缺点

  • 优点 : 提高代码的扩展性
  • 缺点 : 不能调用子类特有的功能
package com.bn.polymorphism_test;

public abstract class Animal {
    private String breed;
    private String color;

    public Animal() {
    }

    public Animal(String breed, String color) {
        this.breed = breed;
        this.color = color;
    }

    public String getBreed() {
        return breed;
    }

    public void setBreed(String breed) {
        this.breed = breed;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public abstract void eat();
}


package com.itheima.polymorphism_test;

public class Cat extends Animal {
    public Cat() {
    }

    public Cat(String breed, String color) {
        super(breed, color);
    }

    @Override
    public void eat() {
        System.out.println("猫吃鱼...");
    }

    public void catchMouse() {
        System.out.println("抓老鼠...");
    }
}


package com.itheima.polymorphism_test;

public class Dog extends Animal {
    public Dog() {
    }

    public Dog(String breed, String color) {
        super(breed, color);
    }

    @Override
    public void eat() {
        System.out.println("狗吃骨头!");
    }

    public void lookDoor(){
        System.out.println("狗看门...");
    }
}


package com.itheima.polymorphism_test;

public class Pig extends Animal {
    public Pig() {
    }

    public Pig(String breed, String color) {
        super(breed, color);
    }

    @Override
    public void eat() {
        System.out.println("猪拱白菜...");
    }

    public void sleep() {
        System.out.println("一直再睡...");
    }
}


package com.bn.polymorphism_test;

/*
    如果方法的参数是一个类的话 , 那么调用此方法需要传入此类的对象 , 或者子类对象

    多态的好处 :
        提高代码的扩展性 , 灵活性
    多态的缺点:
        不能调用子类的特有功能
 */
public class AnimalTest {
    public static void main(String[] args) {
        useAnimal(new Cat());

        System.out.println("---------");

        useAnimal(new Dog());

        System.out.println("---------");

        useAnimal(new Pig());
    }

    public static void useAnimal(Animal a){// Animal a = new Dog()
        a.eat();
        // 多态不能访问子类特有的功能
        // 如果解决 ?

        // 向下转型
        if(a instanceof Cat) {
            Cat cat = (Cat) a;
            cat.catchMouse();
        }
        if(a instanceof Dog) {
            Dog dog = (Dog) a;
            dog.lookDoor();
        }

        if(a instanceof Pig) {
            ((Pig) a).sleep();
        }
    }

//    // 定义一个使用猫类的方法
//    public static void useAnimal(Cat c) {// Cat c = new Cat();
//        c.eat();
//        c.catchMouse();
//    }
//
//    // 定义一个使用狗类的方法
//    public static void useAnimal(Dog d) {// Dog d = new Dog();
//        d.eat();
//        d.lookDoor();
//    }
//
//    // 定义一个使用猪类的方法
//    public static void useAnimal(Pig pig) {
//        pig.eat();
//        pig.sleep();
//    }
}

1.6 多态的转型

  • 向上转型 : 把子类类型数据转成父类类型数据 Animal a = new Cat();
  • 向下转型 : 把父类类型数据转成子类类型数据 Cat cat = (Cat)a;

1.7 多态的转型注意

  • 如果被转的对象 , 对应的实际类型和目标类型不是同一种数据类型 , 那么转换时会出现ClassCastException异常

  • 异常代码如下
public static void main(String[] args) {
    Animal a = new Cat();
    useAnimal(a);
}
public static void useAnimal(Animal a) {
    Dog d = (Dog) a;
    d.eat();
}

1.8 解决转型安全隐患

  • 使用关键字 instanceof
  • 作用 : 判断一个对象是否属于一种引用数据类型
  • 格式 : 对象名 instanceof 引用数据类型
    • 通俗的理解：判断关键字左边的变量，是否是右边的类型，返回boolean类型结果

2 内部类

2.1 内部类的分类

  • 什么是内部类 ?

    • 一个A类 中 定义一个B类 , 那么B类就属于A类的内部类 , A类就属于B类的外部类

      [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7VuEm1oe-1683555713951)(D:\传智播客\上海-JavaSE进阶面授\day03【多态，内部类 , 常用API 1】\笔记\img\image-20210402191054318.png)]

  • 什么时候使用内部类 ?
    • 多个事物之间有包含关系, 可以使用内部类
  • 内部类分类 ?
    • 成员内部类
    • 局部内部类
    • 匿名内部类

2.2 成员内部类

  • 定义的位置 : 类中方法外

  • 创建成员内部类对象格式 : 外部类名.内部类名 对象名 = new 外部类名().new 内部类名(参数);

    package com.bn.innerclass_demo.member_innerclass;

// 外部类
public class Person {
    // 成员内部类
    public class Heart {
        // 频率变量
        private int rate;
        // 跳动方法
        public void beats() {
            System.out.println("咚咚咚!");
        }
    }
}

class Test {
    public static void main(String[] args) {
        // 创建内部类对象
        Person.Heart heart = new Person().new Heart();
        // 调用内部类中的方法
        heart.beats();
    }
}
  • 成员内部类访问外部类的成员
    • 在内部类中有代表外部类对象的格式 : 外部类名的.this , 私有的也可以访问
    • 外部类要想访问内部类成员 , 需要创建内部类对象
    package com.bn.innerclass_demo.member_innerclass;

public class Person {
    private String name = "张三";
    private int num = 10;
    
    // 成员内部类
    public class Heart {
        int num = 100;
        // 频率
        private int rate;
        // 跳动
        public void beats() {
            System.out.println("咚咚咚!");
        }
        // 调用外部类的成员
        public void show(){
            int num = 1000;
            System.out.println(Person.this.name);
            System.out.println(num);// 1000 就近原则
            System.out.println(this.num);// 100
            System.out.println(Person.this.num);// 10

        }
    }
}

class Test {
    public static void main(String[] args) {
        Person.Heart heart = new Person().new Heart();
        heart.beats();
        heart.show();
    }
}

2.3 匿名内部类

  • 匿名内部类 : 没有名字的类 , 一次性产品
  • 使用场景 : 直接调用方法 , 作为方法的传参 , 返回值类型
  • 好处 : 简化代码 , 快速实现接口或者抽象的抽象方法
  • 格式 :
    • new 类名/接口名(){ 重写抽象方法 } 注意 : 此处创建的是子类对象!!!
  • 使用方式 :
    • 直接调用方法
    • 作为方法的参数传递
    • 作为方法的返回值类型
//接口
interface Flyable {
    void fly();
}

// 直接调用方法
Flyable f1 = new Flyable() {
    @Override
    public void fly() {
        System.out.println("不知道什么在飞.....");
    }
};
f1.fly();

// 作为方法的参数传递
showFlyable(
    new Flyable() {
        @Override
        public void fly() {
            System.out.println("不知道什么在飞3333");
        }
    }
);

public static void showFlyable(Flyable flyable) {
	flyable.fly();
}

// 作为方法的返回值类型
public static Flyable getFlyable() {
	return new Flyable() {
        @Override
        public void fly() {
            System.out.println("3333333333333");
        }
    };
}

package com.bn.innerclass_demo.anonymous_innerclass;

/*
    1 如果方法的参数是一个类的话 , 调用此方法需要传入此类的对象或者此类的子类对象
    2 如果方法的返回值类型是一个类的话 , 需要返回此类的对象 , 或者此类的子类对象

     3 如果方法的参数是一个接口的话 , 调用此方法需要传入此接口的实现类对象
     4 如果方法的返回值类型是一个接口的话 , 需要返回此接口的实现类对象


     匿名内部类 : 代表的就是子类对象!!!
        new 类名/接口名(){
            重写抽象类或者接口中的抽象方法
        };

     使用方向 :
        1 调用方法
        2 作为方法参数传递
        3 作为方法的返回值
 */
public interface Swim {
    public abstract void swimming();
}

class Test {
    public static void main(String[] args) {
//        // 子类对象!!!
        //  1 调用方法
//       new Swim() {
//            @Override
//            public void swimming() {
//                System.out.println("匿名内部类 , 重写了接口中的抽象方法...");
//            }
//        }.swimming();


//        //   2 作为方法参数传递
//        useSwim(new Swim() {
//            @Override
//            public void swimming() {
//                System.out.println("匿名内部类 , 重写了接口中的抽象方法...");
//            }
//        });

//        // 3 作为方法的返回值
//        Swim s = getSwim();
//        s.swimming();
    }


    public static Swim getSwim() {
        return new Swim() {
            @Override
            public void swimming() {
                System.out.println("匿名内部类 , 重写了接口中的抽象方法...");
            }
        };
    }


    /*
        Swim swim = new Swim() {
            @Override
            public void swimming() {
                System.out.println("匿名内部类 , 重写了接口中的抽象方法...");
            }
        };
     */
    public static void useSwim(Swim swim) {
        swim.swimming();
    }
}

3 API

3.1 Object类

  • 概述 : 类Object是类层次结构的根，每个类都把Object作为超类。 所有对象（包括数组）都实现了这个类的方法
  • 方法 : public String toString()
    • 如果一个类没有重写toString方法 , 那么打印此类的对象 , 打印的是此对象的地址值
    • 如果一个类重写了toString方法 , 那么打印此类的对象 , 打印的是此对象的属性值
    • 好处 : 把对象转成字符串 , 快速查看一个对象的属性值
    • 执行时机 : 打印对象时会默认调用toString方法
  • 方法 : public boolean equals()
    • 如果一个类没有重写equals方法 , 那么比较此类的对象 . 比较的是地址值
    • 如果一个类重写了equals方法 . 那么比较此类的对象 , 比较的是属性值是否相等
    • 好处 : 可以比较对象的内容

3.2 Objects类

  • Objects是JDK1.7新增的一个对象工具类，里面都是静态方法可以用来操作对象。比如对象的比较，计算对象的hash值，判断对手是否为空…比如里面的equals方法，可以避免空指针异常
public static boolean equals(Object a, Object b):判断两个对象是否相等
    
public static boolean equals(Object a, Object b) {
    return (a == b) || (a != null && a.equals(b));
}
a.equals(b) :如果a是null值，肯定会空指针
Objects.equals(a,b);：如果a是null，不会导致空指针异常

3.2 Date类

package com.bn.api_demo.date_demo;

import java.util.Date;

/*
    Date类 : 代表的是一个瞬间 , 精确到毫秒

    构造方法 :
        public Date() : 代表的是当前系统时间
        public Date(long date) : Date对象 = 1970/1/1 0:0:0 + long类型的毫秒值

    成员方法 :
        public void setTime(long date) : Date对象 = 1970/1/1 0:0:0 + long类型的毫秒值
        public long getTime() : 返回的是毫秒值 = Date代表的时间 - 1970/1/1 0:0:0
 */
public class DateDemo {
    public static void main(String[] args) {
        //  public Date() : 代表的是当前系统时间
//        Date d = new Date();
//        System.out.println(d);

        //  public Date(long date) : Date对象 = 1970/1/1 0:0:0 + long类型的毫秒值
//        Date d2 = new Date(1000L * 60 * 60 * 24); // 1970/1/1 0:0:0 + 一天的毫秒值
//        System.out.println(d2);

        Date d = new Date();
        // public void setTime(long date) : Date对象 = 1970/1/1 0:0:0 + long类型的毫秒值
        // d.setTime(1000L * 60 * 60 * 24);
        System.out.println(d);

        // public long getTime() : 返回的是毫秒值 = Date代表的时间 - 1970/1/1 0:0:0
        // System.out.println(d.getTime());

    }
}

3.3 DateFormat类

  • 概述 : 主要用于操作日期格式的一个类

  • 作用 :

    • 格式化 : Date --> String
    • 解析 : String --> Date

  • 构造方法 :

    • SimpleDateFormat(String pattern) 给定日期模板创建日期格式化对象

  • 成员方法 :

    • public String format ( Date d )：格式化，将日期对象格式化为字符串
    • public Date parse ( String s )：解析，将字符串解析为日期对象
package com.bn.api_demo.dateformat_demo;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/*
    SimpleDateFormat类 :
        "2021年04月03日 16:48:10"  ---> Date
        Date(Sat Apr 03 16:41:38 CST 2021) --> "2021年04月03日 16:48:10"

        作用 :
            格式化 : Date --> String
            解析   : String --> Date

        构造方法 :
            public SimpleDateFormat(String pattern) : pattern : 字符串类型的日期模板

        成员方法 ;
            public final String format(Date date) : 接收一个Date对象返回指定模式的字符串
            public Date parse(String source) : 接收一个字符串  , 返回一个Date对象



        1 获取当前的日期对象，使用格式：yyyy-MM-dd HH:mm:ss 来表示，例如：2020-10-31 17:00:00【格式化】

        2 将字符串的 2020年10月31日  17:00:00，转换为日期Date对象。【解析】

 */
public class SimpleDateFormatDemo {
    public static void main(String[] args) throws ParseException {
        // 解析   : String --> Date
        String strDate = "2020年10月31日 17:00:00";
        // 注意 : 解析时 , SimpleDateFormat的参数(日期模板) , 必须和要解析字符串的模式匹配
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        //  public Date parse(String source) : 接收一个字符串  , 返回一个Date对象
        Date date = sdf.parse(strDate);
        System.out.println(date); // Sat Oct 31 17:00:00 CST 2020
    }

    private static void method() {
        // 格式化 : Date --> String
        // 获取当前系统时间
        Date date = new Date();
        // System.out.println(date);// Sat Apr 03 16:53:35 CST 2021

        // public SimpleDateFormat(String pattern) : pattern : 字符串类型的日期模板
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd ");

        // public final String format(Date date) : 接收一个Date对象返回指定模式的字符串
        String strDate = sdf.format(date);

        System.out.println(strDate);
    }
}
战狼	吴京	120.0	0.0	20.0	120	19-12-12 下午12:12

3.4 Calendar类

  • 概述 :
    • java.util.Calendar类表示日历，内含有各种时间信息，以及获取，计算时间的方法。
    • Calendar本身是一个抽象类，可以通过Calendar提供的静态方法getInstance日历子类对象
  • Calendar常用方法 :
    方法名说明
    public static Calendar getInstance()获取一个它的子类GregorianCalendar对象。
    public int get(int field)获取指定日历字段的时间值。
    public void set(int field,int value)设置指定字段的时间值
    public void add(int field,int amount)为某个字段增加/减少指定的值

  • get,set,add方法参数中都有一个整数类型的参数field，field用来区分当前要获取或者操作的日期时间数据的。field数据的值使用Calender中定义的整数常量来表示

    • Calendar.YEAR : 年
    • Calendar.MONTH ：月
    • Calendar.DAY_OF_MONTH：月中的周
    • Calendar.HOUR：小时
    • Calendar.MINUTE：分钟，
    • Calendar.SECOND：秒
    • Calendar.DAY_OF_WEEK：星期
  • 星期对应的关系

    ​ 字段时间值 : 1 2 3 … 7
    ​ 真正的时间 : SUNDAY MONDAY TUESDAY … SATURDAY

  • 月份对应的关系

    ​ 字段时间值 : 0 1 … 11
    ​ 正真的时间 : JANUARY FEBRUARY … DECEMBER

package com.bn.api_demo.calendar_demo;
/*

    月份对应的关系
    字段时间值     :       0           1           ....        11
    正真的时间     :     JANUARY     FEBRUARY      ....      DECEMBER


 */
import java.util.Calendar;
/*
    成员方法 :
        public int get(int field)	获取指定日历字段的时间值。
        public void set(int field,int value)	设置指定字段的时间值
        public void add(int field,int amount)	为某个字段增加/减少指定的值
 */
public class CalendarDemo {
    public static void main(String[] args) {
        // 获取Calendar对象 , rightNow对象
        Calendar rightNow = Calendar.getInstance();

        // public void set(int field , int value)	设置指定字段的时间值
        // rightNow.set(Calendar.YEAR , 2024);
        // rightNow.set(Calendar.MONTH , 5);
        // rightNow.set(Calendar.DAY_OF_MONTH, 10);

        // public void add(int field,int amount)	为某个字段增加/减少指定的值
        // rightNow.add(Calendar.DAY_OF_MONTH , -3);

        //  public int get(int field)	 : 获取指定日历字段的时间值。
        int year = rightNow.get(Calendar.YEAR);
        int month = rightNow.get(Calendar.MONTH);
        int day = rightNow.get(Calendar.DAY_OF_MONTH);


        System.out.println(year); // 2021
        System.out.println(month);// 3
        System.out.println(day);  // 3
    }
}

package com.bn.api_demo.calendar_demo;

import java.util.Calendar;

/*
    1 写代码使用get方法，将年，月，日，时，分，秒，周获取出来
    特别注意获取月份，和星期有以下特点：
    直接获取的月份数据是从0开始的， 0表示1月，.....11表示12月
    周的获取，从周日开始计算，1就是周日，2就是周一 ......7就是周六


星期对应的关系
     字段时间值  :   1           2            3          ...        7
     真正的时间  : SUNDAY        MONDAY      TUESDAY     ...        SATURDAY

月份对应的关系
    字段时间值     :       0           1           ....        11
    正真的时间     :     JANUARY     FEBRUARY      ....      DECEMBER

 */
public class Test1 {
    public static void main(String[] args) {
        // 拿到当前时间
        Calendar now = Calendar.getInstance();

        System.out.println(now.get(Calendar.YEAR));
        System.out.println(now.get(Calendar.MONTH));
        System.out.println(now.get(Calendar.DAY_OF_MONTH));
        System.out.println(now.get(Calendar.HOUR));
        System.out.println(now.get(Calendar.MINUTE));
        System.out.println(now.get(Calendar.SECOND));

        int week = now.get(Calendar.DAY_OF_WEEK);// 7
        System.out.println(getWeek(week));// 字段值
    }

    public static String getWeek(int field){
        String[] str = { "" , "SUNDAY" , "MONDAY" , "TUESDAY" , "WEDNESDAY" , "THURSDAY" , "FRIDAY" , "SATURDAY"};
        return str[field];
    }
}

package com.itheima.api_demo.calendar_demo;

import java.util.Calendar;

/*
    2 写代码实现，获取2022年10月1日是星期几？
    参考思路：
    直接获取日历对象，得到的是当前系统的日历时间信息。
    获取日历对象后，要重新设置日期
    再获取星期数据

 */
public class Test2 {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.YEAR, 2022);
        cal.set(Calendar.MONTH, 9);
        cal.set(Calendar.DAY_OF_MONTH, 1);

        int week = cal.get(Calendar.DAY_OF_WEEK);
        System.out.println(getWeek(week));// 字段值
    }

    public static String getWeek(int field){
        String[] str = { "" , "SUNDAY" , "MONDAY" , "TUESDAY" , "WEDNESDAY" , "THURSDAY" , "FRIDAY" , "SATURDAY"};
        return str[field];
    }
}


package com.bn.api_demo.calendar_demo;

import java.util.Calendar;

/*
    3 计算10000天之后的年月日

    参考思路：
    先获取当前日历对象
    再调用add方法，指定DATE或者DAY_OF_MONTH，添加10000天
    再获取日历的年，月，日

 */
public class Test3 {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.DAY_OF_MONTH, 10000);


        System.out.println(cal.get(Calendar.YEAR));
        System.out.println(cal.get(Calendar.MONTH));
        System.out.println(cal.get(Calendar.DAY_OF_MONTH));
    }
}

3.5 Math类

  • 概述 : Math包含执行基本数字运算的方法，如基本指数，对数，平方根和三角函数。所提供的都是静态方法，可以直接调用

  • 常用方法 :

    public static int abs(int a)获取参数a的绝对值：
    public static double ceil(double a)向上取整
    public static double floor(double a)向下取整
    public static double pow(double a, double b)获取a的b次幂
    public static long round(double a)四舍五入取整

3.6 System类

  • System类包含几个有用的类字段和方法。 它不能被实例化

  • 常用方法 :

    方法名说明
    public static void exit(int status)终止当前运行的 Java 虚拟机，非零表示异常终止
    public static long currentTimeMillis()返回当前时间(以毫秒为单位)

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/503781.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

知识推理——CNN模型总结

知识推理——CNN模型总结

记录一下我看过的利用CNN实现知识推理的论文。 最后修改时间：2023.05.08 目录 1.ConvE 1.1.解决的问题 1.2.优势 1.3.贡献与创新点 1.4.方法 1.4.1 为什么用二维卷积，而不是一维卷积？ 1.4.2.ConvE具体实现 1.ConvE 论文&#xff1a…
阅读更多...
聊聊我在阿里第一年375晋升的心得

聊聊我在阿里第一年375晋升的心得

前言 思来想去，觉得这个事情除了领导赏识大佬抬爱之外，还是挺不容易的，主观认为有一定的参考价值，然后也是复盘一下，继续完善自己。 绩效 首先晋升的条件就是要有个好绩效，那么我们就先基于绩效这个维度…
阅读更多...
基于`IRIS`列存储，我们能做什么

基于`IRIS`列存储，我们能做什么

文章目录 基于IRIS列存储，我们能做什么简介使用场景如何使用列存储什么情况下使用列储存统计数据数量count计算字段平均值avg计算字段和sum 列存储与行存储区别总结 基于IRIS列存储，我们能做什么 简介 列存储是一种数据存储方式，与传统的行…
阅读更多...
Win11-RTX4060安装Pytorch-GPU干货避坑指南

Win11-RTX4060安装Pytorch-GPU干货避坑指南

文章目录 1、版本要和pytorch官网对应，CUDA11.8及其对应版本的cudnn2、CUDA Toolkit安装出现自动重启3、Python版本4、配置永久国内镜像源5、要在激活的虚拟环境里安装pytorch6、进入python后检查是否gpu配置成功7、在虚拟环境中启动jupyter notebook8、conda中inst…
阅读更多...
【Docker】5、Dockerfile 自定义镜像（镜像结构、Dockerfile 语法、把 Java 项目弄成镜像）

【Docker】5、Dockerfile 自定义镜像（镜像结构、Dockerfile 语法、把 Java 项目弄成镜像）

目录 零、学习内容一、镜像结构二、Dockerfile四、基于 java:8-alpine 构建自己的 Java 项目镜像 零、学习内容 镜像结构Dockerfile 语法构建 Java 项目 ① 之前使用的镜像都是 DockerHub 官方提供的 ② 开发者需要将自己的微服务制作为镜像 一、镜像结构 镜像是由应用程序及其…
阅读更多...
【新星计划-2023】什么是ARP？详解它的“解析过程”与“ARP表”。

【新星计划-2023】什么是ARP？详解它的“解析过程”与“ARP表”。

一、什么是ARP ARP（地址解析协议）英文全称“Address Resolution Protocol”，是根据IP地址获取物理地址的一个TCP/IP协议。主机发送信息时将包含目标IP地址的ARP请求广播到局域网络上的所有主机，并接收返回消息，以此确…
阅读更多...
ConcurrentHashMap实现原理

ConcurrentHashMap实现原理

1. 哈希表 1.1 介绍 哈希表是一种key-value存储数据的结构，根据key即可查到对应的value。 如果所有的键是整数，我们可用简单的无序数组来表示，键作为数组索引，值即为对应的值 1.2 链式哈希表 链式哈希表本质由一组链表构成。每…
阅读更多...
用MacBook实操:docker本地部署mysql+php+nginx坏境

用MacBook实操:docker本地部署mysql+php+nginx坏境

大家好，我拿出我的macbook,带着大家实操用docker部署mysqlphpnginx环境。 之前的小白实操搭建Nginx1.2.0PHP7.0MySQL5.7Thinkphp5项目，看这篇就够了，欢迎阅读。 之前的是服务器上配置环境，现在在mac本地搭建全栈开发环境。 目录…
阅读更多...
LiveData详解（实战+源码+粘性事件解决方案）

LiveData详解（实战+源码+粘性事件解决方案）

1. 简介 LiveData 是一种可观察的数据存储器类。与常规的可观察类不同，LiveData 具有生命周期感知能力，意指它遵循其他应用组件（如 activity、fragment 或 service）的生命周期。这种感知能力可确保 LiveData 仅更新处于活跃生命周…
阅读更多...
mysql查询之子查询

mysql查询之子查询

0. 概念 SQL语句中嵌套SELECT语句，称为嵌套查询，又叫子查询。 查询可以基于一个表或多个表。子查询可以添加到SELECT、UPDATE和DELETE中，而且可以进行多层嵌套。子查询常用操作符有 ANY(SOME)，ALL、IN、EXISTS。也可以使用比较运…
阅读更多...
Codeforces Round 872 (Div. 2) A-C

Codeforces Round 872 (Div. 2) A-C

Start&#xff1a;May/08/2023 20:05UTC8 Length&#xff1a;02:00 这次总该上分了吧 A LuoTianyi and the Palindrome String 1 s, 256 MB x8531 都一样是-1&#xff0c;普通回文是size()-1 #include<bits/stdc.h> using namespace std; #define int long long #def…
阅读更多...
架构-软件工程模块-1

架构-软件工程模块-1

概述 这一模块选择题的分值比较多&#xff0c;案例题和论文也有能用上的地方。主要知识点会特殊标注或说明。 软件开发生命周期 软件工程三要素&#xff1a;方法、工具、过程。不会直接考&#xff0c;但可帮助记忆理解。 传统软件生命周期方法学分为&#xff1a;&#xff08;选…
阅读更多...
使用sharding-scaling和sharding-proxy做分库分表数据迁移

使用sharding-scaling和sharding-proxy做分库分表数据迁移

背景&#xff1a; 现在有一个有一张表被分成了两张表&#xff0c;t_score1 ,t_score2&#xff0c;但后期数据量激增&#xff0c;两张表不能满足业务需求&#xff0c;扩张为2个库每个库2张表&#xff0c;即数据库 ds_0下有t_score1 ,t_score2 &#xff0c;数据库ds1下有t_score1…
阅读更多...
浏览器插件的使用

浏览器插件的使用

善于使用浏览器插件&#xff0c;能起到高效上网的作用。 Microsoft Edge 是全球广受欢迎的浏览器&#xff0c;浏览器本身具有快速、简单和轻量级的特点。一流的性能系统和访问速度极大提升您的浏览体验。 对于浏览器的用户来说&#xff0c;安装一些实用的插件&#xff0c;能让…
阅读更多...
Navicat设置Oracle数据库主键自增1的方法步骤

Navicat设置Oracle数据库主键自增1的方法步骤

一、 创建如下表 Oracle数据库不同于Mysql、Sql Server数据库&#xff0c;Oracle数据库主键自增不能在建表时直接设置&#xff0c;而是需要通过序列和触发器进行设置&#xff01; 二、创建序列 1 2 3 4 5 6create sequence SEQ_DEVICEDATAINFO start with 1 …
阅读更多...
iOS可视化动态绘制连通图

iOS可视化动态绘制连通图

上篇博客《iOS可视化动态绘制八种排序过程》可视化了一下一些排序的过程&#xff0c;本篇博客就来聊聊图的东西。在之前的博客中详细的讲过图的相关内容&#xff0c;比如《图的物理存储结构与深搜、广搜》。当然之前写的程序是比较抽象的。上篇博客我们以可视化的方式看了一下各…
阅读更多...
数据库（Sql server语言）（一）

数据库（Sql server语言）（一）

例题&#xff1a;&#xff08;不介绍创建和插入&#xff09; star表 ●查询每个组合的名称及其成员个数 select g.name,count(*) 成员个数 from star s,stargroup g where s.gid g.gid group by g.name 如果不写where s.gidg,gid会出现成员个数重复 ●查询身高最高的团…
阅读更多...
UG NX二次开发（C#）-建模-反向片体(SheetBody)的法向矢量

UG NX二次开发（C#）-建模-反向片体(SheetBody)的法向矢量

文章目录 1、前言2、在UG NX中构建一个片体3、在UG NX中查看片体的法向矢量4、采用UFun函数来实现法向反向5、代码实现6、测试效果1、前言 在UG NX中，一张曲面获取其所属的片体(SheetBody)对象，其在构建时有默认的法向矢量，有时处于功能的需求，比如加工时工件的材料去除方…
阅读更多...
探秘信息检索：原理、实现与应用

探秘信息检索：原理、实现与应用

❤️觉得内容不错的话&#xff0c;欢迎点赞收藏加关注&#x1f60a;&#x1f60a;&#x1f60a;&#xff0c;后续会继续输入更多优质内容❤️ &#x1f449;有问题欢迎大家加关注私戳或者评论&#xff08;包括但不限于NLP算法相关&#xff0c;linux学习相关&#xff0c;读研读博…
阅读更多...
（一）如何使用Spring Boot和MyBatis框架实现即时通信系统中的用户注册功能

（一）如何使用Spring Boot和MyBatis框架实现即时通信系统中的用户注册功能

文章目录 一、引言二、Spring Boot和MyBatis框架介绍三、注册1. 前端界面实现2. 后端数据持久化操作3. 代码示例 四、实现效果四、个人经验分享五、结语 一、引言 本文将介绍基于Spring Boot和MyBatis框架开发的注册功能实现&#xff0c;该功能是基于Linux的即时通信系统的一个…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023