面向对象2

最新推荐文章于 2024-07-09 16:46:46 发布
最新推荐文章于 2024-07-09 16:46:46 发布
阅读量50 收藏
点赞数
文章标签： java 开发语言 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45812603/article/details/131903472
版权

面向对象2

1.静态 static关键字

  • 使用范围：在Java类中， 可用static修饰属性、 方法、 代码块、 内部类
  • 被修饰后的成员具备以下特点：
    • 随着类的加载而加载
    • 优先于对象存在
    • 修饰的成员，被所有对象所共享
    • 访问权限允许时，可不创建对象，直接被类调用
  • 类方法，类中使用static修饰的方法
    • 没有对象的实例时，可以用**类名.方法名()**的形式访问由static修饰的类方法。
    • 在static方法内部只能访问类的static修饰的属性或方法， 不能访问类的非static的结构
    • 因为不需要实例就可以访问static方法，因此static方法内部不能有this。 (也不能有super ? YES!)
    • static修饰的方法不能被重写

案例：

Chinese类

package com.example.java.day6;/**
 * @User HASEE
 * @Author WeiXu
 * @Createtime 2023/7/24-24-10:14
 * @PACKAGE_NAME com.example.java.day6
 */

/**
 *@ClassName:Chinese
 *@author weixu
 *@date 2023/7/24 10:14
 */
public class Chinese {

    private String name;
    private int age;

    public static String nation = "大中国";

    public void f1() {
        System.out.println("f1");
    }

    public static void f2() {
        System.out.println("f2");
    }


    //自我介绍
    public static void show() {
        //在静态方法中，不能使用this,super
        //静态方法中，只能使用静态变量
        System.out.println("自我介绍" + nation);
        f2();
    }

    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;
    }
}

StaticTest类：

public class StaticTest {
    public static void main(String[] args) {
        Chinese malong = new Chinese();
        Chinese yaoming = new Chinese();
        malong.setName("马龙");
        yaoming.setName("姚明");
        malong.setAge(30);
        System.out.println(Chinese.nation);//大中国 类中原来的静态变量为大中国
        malong.nation = "中国";
        System.out.println(Chinese.nation);//中国 //
        yaoming.nation = "美国";
        System.out.println(Chinese.nation);//美国
        yaoming.setAge(40);
        System.out.println(malong.getName()+" "+malong.getAge()+" "+Chinese.nation);//马龙 30 美国
        //调用静态方法
        Chinese.show();
    }

}

2.单例模式

  • 设计模式：程序在某一个场景的，设计和开发套路，比如围棋和象棋套路
  • 单例模式：要求程序中某一个组件，在程序运行的整个生命周期中，只有一个实例
    • **构造函数私有，**外面的组件不能主动创建这个对象
    • **提供静态方法返回对象实例，**返回的是静态实例（静态的特性），所以只有一个实例

1.饿汉式单例模式

  • 好处：线程安全的
  • 坏处：加载时，时间比较长 (实例在类加载时就被创建。如果实例的初始化过程较为复杂，需要执行大量的初始化操作或者依赖其他资源，就会导致类加载的时间较长。)
public class EagerSingleton {
    private EagerSingleton()
    {
        System.out.println("饿汉式单例模式");
    }

    private static EagerSingleton instance = new EagerSingleton();//因为静态的特性只有一份存在方法区，所以这个对象一定只有一个
    public static EagerSingleton getInstance()
    {
        return instance;
    }

}

image.png

2.懒汉式

存在线程安全问题，没有静态初始化

public class LazySingleton {
    private LazySingleton()
    {
        System.out.println("懒汉式单例模式");
    }

    private static LazySingleton instance = null;
    public static   LazySingleton getInstance()
    {
        if (instance == null)
        {
            instance = new LazySingleton();
        }
        return instance;
    }
}

测试：

public class SingletonTest {
    //单例模式
    public static void main(String[] args) {
        //1.饿汉式 好处：线程安全的 坏处：加载时，时间比较长
        EagerSingleton s1 = EagerSingleton.getInstance();
        EagerSingleton s2 = EagerSingleton.getInstance();
        EagerSingleton s3 = EagerSingleton.getInstance();
        //2.懒汉式 存在线程安全问题，没有静态初始化
        LazySingleton s4 = LazySingleton.getInstance();
        LazySingleton s5 = LazySingleton.getInstance();

    }
}

懒汉式线程不安全的原因：

  1. 多线程竞争：在懒汉式单例模式中，当多个线程同时调用 getInstance() 方法，而此时实例尚未创建（instance 为 null），它们会同时通过了创建实例的条件判断，然后各自创建一个实例，导致多个实例存在。
  2. 未加同步控制：在最简单的懒汉式实现中，getInstance() 方法没有加上同步控制，这意味着多个线程可以同时进入该方法，从而同时创建多个实例。例如：
public class LazySingleton {
    private static LazySingleton instance;

    private LazySingleton() {
        // 私有构造函数，防止其他类直接实例化
    }

    public static LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton(); // 多个线程可能同时执行到这里，创建多个实例
        }
        return instance;
    }
}

解决方案：

为了解决懒汉式的线程安全问题，可以在 getInstance() 方法上加上同步关键字 synchronized，确保在同一时刻只能有一个线程进入该方法，从而避免了多线程并发创建多个实例的情况。例如：

public class LazySingleton {
    private static LazySingleton instance;

    private LazySingleton() {
        // 私有构造函数，防止其他类直接实例化
    }

    public static synchronized LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

3.代码块和初始化顺序

对象初始化顺序：

父类静态代码块->子类静态代码块->父类初始化代码块->父类构造函数->子类初始化代码块->子类构造函数

Parent类：

package com.example.java.day6.Initialize;/**
 * @User HASEE
 * @Author WeiXu
 * @Createtime 2023/7/24-24-14:11
 * @PACKAGE_NAME com.example.java.day6
 */

/**
 *@ClassName:Parent
 *@author weixu
 *@date 2023/7/24 14:11
 */
public class Parent {
    int age = 10;//初始化
    //初始化代码块
    {
        System.out.println("父类的初始化代码块1");
    }
    {
        System.out.println("父类的初始化代码块2");
    }
    //静态初始化代码块
    static
    {
        System.out.println("父类的静态初始化代码块1");
    }
    static
    {
        System.out.println("父类的静态初始化代码块2");
    }
    //构造函数初始化
    public Parent()
    {
        System.out.println("父类的构造函数初始化");
    }

}

Children类：

package com.example.java.day6.Initialize;/**
 * @User HASEE
 * @Author WeiXu
 * @Createtime 2023/7/24-24-14:11
 * @PACKAGE_NAME com.example.java.day6
 */

/**
 *@ClassName:Children
 *@author weixu
 *@date 2023/7/24 14:11
 */
public class Children extends Parent{
     int age = 20;
     //初始化代码块
    {
        System.out.println("子类的初始化代码块1");
    }
    {
        System.out.println("子类的初始化代码块2");
    }
    static
    {
        System.out.println("子类的静态初始化代码块1");
    }
    static
    {
        System.out.println("子类的静态初始化代码块2");
    }

    public Children()
    {
        System.out.println("子类的构造函数初始化");
    }
}

InitializeTest类：

package com.example.java.day6.Initialize;/**
 * @User HASEE
 * @Author WeiXu
 * @Createtime 2023/7/24-24-14:10
 * @PACKAGE_NAME com.example.java.day6
 */

/**
 *@ClassName:InitializeTest
 *@author weixu
 *@date 2023/7/24 14:10
 */
//代码初始化 以及初始化顺序 父类静态代码块->子类静态代码块->父类初始化代码块->父类构造函数->子类初始化代码块->子类构造函数
public class InitializeTest {
    public static void main(String[] args) {
        Children children = new Children();
    }
}

4.final修饰词

  • 修饰类，表示类不能被继承
  • 修饰方法：表示不能被重写
  • 修饰成员变量，表示变量不能被改变
//public  final class ATest //final修饰的类无法被继承
public class ATest {
    final int age = 10;//final修饰的变量，只能赋值一次 无法再改变
//    final void test()
//    {
//        System.out.println("A");
//    }
     void test()
    {
        System.out.println("A");
    }
}
class BTest extends ATest
{
   //无法重写父类被final修饰的方法


    @Override
    void test() {
        System.out.println("B");
    }

    void f1()
    {
        super.test();//final修饰的方法无法被重写，但是可以被调用
        this.test();
        //super.age = 10;//final修饰的变量，只能赋值一次 无法再改变
    }
}

5.抽象类

  • 用abstract关键字来修饰一个类， 这个类叫做抽象类。
  • 用abstract来修饰一个方法， 该方法叫做抽象方法。抽象方法：只有方法的声明，没有方法的实现。以分号结束：比如： public abstract void talk();
  • 含有抽象方法的类必须被声明为抽象类。
  • 抽象类不能被实例化。抽象类是用来被继承的，抽象类的子类必须重写父类的抽象方法，并提供方法体。若没有重写全部的抽象方法，仍为抽象类。

ATest类(抽象类)：

package com.example.java.day6.abstract_test;/**
 * @User HASEE
 * @Author WeiXu
 * @Createtime 2023/7/24-24-15:26
 * @PACKAGE_NAME com.example.java.day6.abstract_test
 */

/**
 *@ClassName:ATest
 *@author weixu
 *@date 2023/7/24 15:26
 */
public abstract class ATest {
    //抽象类中没有方法体的方法就是抽象方法
    public abstract void test();

    //与接口不同的是抽象类中可以有非抽象方法
    public void f1()
    {
        System.out.println("A");
    }
}

BTest类(ATest类的子类)：

package com.example.java.day6.abstract_test;/**
 * @User HASEE
 * @Author WeiXu
 * @Createtime 2023/7/24-24-15:26
 * @PACKAGE_NAME com.example.java.day6.abstract_test
 */

/**
 *@ClassName:BTest
 *@author weixu
 *@date 2023/7/24 15:26
 */
public class BTest extends ATest {

    //void BTest默认为public abstract void BTest();
     void BTest()
    {
        System.out.println("B");
    }

    //父类为抽象类，子类必须重写父类的抽象方法
    @Override
    public void test() {
        System.out.println("B");
    }
}

Test类(测试类)：

package com.example.java.day6.abstract_test;/**
 * @User HASEE
 * @Author WeiXu
 * @Createtime 2023/7/24-24-15:43
 * @PACKAGE_NAME com.example.java.day6.abstract_test
 */

/**
 *@ClassName:Test
 *@author weixu
 *@date 2023/7/24 15:43
 */
public class Test {
    public static void main(String[] args) {
        //new ATest(); //抽象类不能直接实例化
        new BTest();
    }
}

6.接口

概念：

  • 一方面， 有时必须从几个类中派生出一个子类， 继承它们所有的属性和方法。 但是， 由于Java不支持多重继承。 有了接口， 就可以得到多重继承的效果。
  • 另一方面， 有时必须从几个类中抽取出一些共同的行为特征，而它们之间又没有is-a的关系，仅仅是具有相同的行为特征而已。例如：鼠标、键盘、打印机、扫描仪、摄像头、充电器、 MP3机、手机、数码相机、移动硬盘等都支持USB连接。
  • 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要…则必须能…”的思想。 继承是一个"是不是"的关系，而接口实现则是 "能不能"的关系。
  • 接口的本质是契约，标准，规范，就像我们的法律一样。制定好后大家都要遵守。

Usb接口：

//接口中的方法都是抽象方法 不能有方法体
public interface Usb {
    void start();
    void stop();
}

Typc接口：

public interface Typc {
    void transfer();
}

Phone类(接口实现类)：

//1.实现类可以实现多个接口 2.实现类需要实现接口中的所有方法
public class Phone implements Usb,Typc{
    public static void main(String[] args) {
        System.out.println("手机");

    }

    @Override
    public void transfer() {
        System.out.println("手机可以传输数据");
    }

    @Override
    public void start() {
        System.out.println("手机开始工作");
    }

    @Override
    public void stop() {
        System.out.println("手机停止工作");
    }
}

小节：接口和抽象的区别

  • 抽象类可以有非抽象方法，接口只能有抽象方法
  • 接口中方法默认public abstract
  • 接口可以实现多继承，抽象类不可以

7. 内部类和匿名内部类

7.1 内部类

java中可以把一个java类放到另一java类的内部，这个类成为内部类

内部类的分类：

  • 成员变量位置，成员内部类
    • static成员内部类
    • 非静态的成员内部类
  • 方法中，局部内部类

语法:

  • 修饰成员变量的所有的修饰符都可以修饰成员内部类
  • 内部类可以使用继承

案例：

Person类：

package com.example.java.day6.inner_class_test;/**
 * @User HASEE
 * @Author WeiXu
 * @Createtime 2023/7/24-24-16:38
 * @PACKAGE_NAME com.example.java.day6.inner_class_test
 */

/**
 *@ClassName:Person
 *@author weixu
 *@date 2023/7/24 16:38
 */
public class Person {
   private String name = "张三";
   private int age = 20;

   //1.静态内部类
   //内部类，如果一个类只给当前外部类使用，别的组件不用，比如Dog和Cat类只是在Person中使用
   //所有的成员变量的修饰符，都可以修饰内部类
    public static class Dog
   {
      public void eat()
      {
          System.out.println("狗吃骨头");
      }
   }
   //2.内部类
    public class Cat
   {
         public void eat()
         {
              System.out.println("猫吃鱼");
         }
   }
   //3.成员方法内部类
    public void f1()
    {
        class Bird
        {
            public void eat()
            {
                System.out.println("鸟吃虫子");
            }
        }
    }

}

7.2 匿名内部类

  • 一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。
  • 匿名内部类的特点
    • 匿名内部类必须继承父类或实现接口
    • 匿名内部类只能有一个对象
    • 匿名内部类对象只能使用多态形式引用
  • 语法new 接口（类）{实现}；

案例：

Usb接口：

package com.example.java.day6.inner_class_test;

/**
 * @User HASEE
 * @Author WeiXu
 * @Createtime 2023/7/24-24-15:22
 * @PACKAGE_NAME com.example.java.day6.interface_test
 */
//接口中的方法都是抽象方法 不能有方法体
public interface Usb {
    //接口方法默认是public abstract
    void start();
    void stop();
}

Typc接口：

package com.example.java.day6.inner_class_test;

/**
 * @User HASEE
 * @Author WeiXu
 * @Createtime 2023/7/24-24-15:22
 * @PACKAGE_NAME com.example.java.day6.interface_test
 */
public interface Typc {
    //接口方法默认是public abstract
    void transfer();
}

Test1类：

package com.example.java.day6.inner_class_test;/**
 * @User HASEE
 * @Author WeiXu
 * @Createtime 2023/7/24-24-16:35
 * @PACKAGE_NAME com.example.java.day6.inner_class_test
 */

/**
 *@ClassName:Test1
 *@author weixu
 *@date 2023/7/24 16:35
 */
public class Test1
{
    public static void main(String[] args) {
         //创建静态成员内部类的方法
        Person.Dog dog = new Person.Dog();//静态内部类的创建方式 静态的是属于类本身的而不是对象的
        dog.eat();
        //创建非静态成员内部类的方法
        Person person = new Person();
        Person.Cat cat = person.new Cat();//非静态内部类的创建方式 非静态的是属于对象的而不是类本身的 因此需要先创建对象 再创建内部类
        cat.eat();

        /**
         * 1：多态性：编译类型是父类
         * 2：new 接口（类），后面跟一个实现
         * 3：有一个对象usb1，实现了Usb接口的一个没有名字的类的实例
         * Test$1->实现了Usb接口->用这个类产生一个对象usb1
         */
        //方式1：匿名内部类 格式：Usb usb1 = new Usb()[...] 
        Usb usb1 = new Usb() {
            @Override
            public void start() {
                System.out.println("手机启动了");
            }

            @Override
            public void stop() {
                System.out.println("手机关机了");
            }
        };
        f1(usb1);

        //方式2：匿名内部类直接作为参数 格式f2(new 接口[...])
          f2(new Typc() {
              @Override
              public void transfer() {
                  System.out.println("TypeC接口的传输功能");
              }
          });
    }

    public static void f1(Usb usb) {
        usb.start();
        usb.stop();
    }

    public static void f2(Typc typeC) {
        typeC.transfer();
    }


}
白给是个技术活！
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
面向对象程序设计概念
kangjialong_的博客
11-02 2318
一. 程序设计范型   面向对象程序设计（object-oriented programming，OOP）是一种新的程序设计的范型。程序设计范型是设计程序的规范、模型和风格，它是一类程序设计语言的基础。 面向对象设计范型的主要特征是：  程序=对象+消息   面向对象程序的基本元素是对象。面向对象程序的主要结构特点是：一、程序一般由类的定义和类的使用两部分组成；二、程序中的一切操作都是向对象发送消息来实现的，对象收到消息后，启动有关方法完成相应的操作。   需要说明的是，某一种程序设计语言不一定与一种程
面向对象面向对象面向对象
07-03
面向对象面向对象面向对象
面向对象基础
王梦杰_MengJie
05-13 1万+
面向对象和面向过程是两种不同的编程范式，它们在代码组织、设计思想和解决问题的方式上有很大的区别。1. 抽象层次不同：面向过程编程以过程或函数为中心，强调程序的执行顺序和步骤。代码主要是一系列的过程（函数）调用，以完成特定的任务。面向对象编程以对象为中心，强调事物之间的关系和交互。代码主要是由对象组成，每个对象包含数据和操作数据的方法。2. 数据处理方式不同：数据和函数（过程）是分开的，数据通过函数进行处理和操作。数据和操作数据的方法被封装在一起，通过对象进行处理和操作。
如何实现面向对象
理想主义的花最终会盛开在浪漫主义的土壤里，我的热情永远不会熄灭在现实的平凡之中，我们终将上岸，阳光万里。
05-05 6357
如何实现面向对象面向对象的定义面向对象的三大特征、面向对象的基础实现面向对象基本准则实例 面向对象的定义 对象是指具体的某一事物，在现实生活中能够看得见摸得着的事物。在面向对象程序设计中，对象指的是计算机系统中的某一个成分。 在面向对象程序设计中，对象包含两个含义，其中一个是数据，另一个是动作。对象是数据和动作的结构体。 面向对象是在对象这一层次。 面向对象的三大特征、面向对象的基础 封装、继承、多态 封装：在面向对象中，对数据和动作进行包装，其中的某些数据动作，可以是私有的，不能被外界访问，以此来实现对数
Java面向对象浅谈
编程界明世隐的博客
12-06 4903
作者简介 作者名：编程界明世隐 简介：CSDN博客专家，从事软件开发多年，精通Java、JavaScript，博主也是从零开始一步步把学习成长、深知学习和积累的重要性，喜欢跟广大ADC一起打野升级，欢迎您关注，期待与您一起学习、成长、起飞！ 热门专栏推荐 【1】Java小游戏（俄罗斯方块、飞机大战、植物大战僵尸等） 【2】JavaWeb项目实战（图书管理、在线考试、宿舍管理等） 【3】JavaScript精彩实例（飞机大战、贪吃蛇、验证码等） 【4】Java小白入门200例 【5】从零学Java、趣学J
什么是面向对象
G_hongbin的博客
07-01 1998
引用自面向对象_百度百科 面向对象(Object Oriented)是软件开发方法，一种编程范式。面向对象的概念和应用已超越了程序设计和软件开发，扩展到如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。面向对象是一种对现实世界理解和抽象的方法，是计算机编程技术发展到一定阶段后的产物。 面向对象是相对于面向过程来讲的，面向对象方法，把相关的数据和方法组织为一个整体来看待，从更高的层次来进行系统建模，更贴近事物的自然运行模式。 对象我们可以理解为一个实物，比
C 语言面向对象思想
lzs940320的博客
10-22 3443
注：本博客参考了很多大神的文章加上自己的理解，只做学习复习用 一. C语言面向对象设计引入 1.我们为什么要学习面向对象思想？？？ 在我们平时的开发中也经常会遇到一些简单的项目我们很快就完成了，并且测试着也没有任何问题，但是随着产品迭代，需求增加，项目维护起来越来越耗时，一个看似简单的需求，需要花费较多的时间去开发，出现项目延期。 项目超期的很大一部分原因都是因为代码“牵一发动全身”，当我们的项目需求在累加的过程中，功能相近的应用我们也习惯性的复制，粘贴。导致出现了很多的冗余代码，同时业务逻辑与执.
面向对象的概念介绍
阿赵的博客
08-24 2万+
继续讲程序基础。这一篇主要是介绍面向对象的各种概念性的东西，并不会说具体的代码怎样写，所以可以用一种轻松的心态去看。 一、面向过程和面向对象 面向对象是相对于面向过程的一种编程方式。 面向过程的编程方式由来已久，我刚开始学习Basic和Pascal的时候，都是面向过程的编程方式。这种方式非常的直观，需要写一个功能，直接就写几行实现方法。比如你需要操作一个人移动到某个点，直接就写代码修改一个人...
面向对象名词解释
AHincsdn的博客
11-10 3779
面向对象：将现实生活中的事物封装成对象，通过对象的实例化和调用，完成需求。关注点是对象的属性和方法，忽略事物执行的顺序或过程。面向对象的特点有：抽象、封装、继承、多态。 抽象：抽象就是将现实生活中的事物，忽略与当前目标无关的方面，抽取出当前有用的属性和方法，使用类来表示。 封装：①封装就是使用private隐藏类的内部属性，使用set方法（设置赋值条件）赋值，使用get方法在外部访问。②将需要多次...
Java面向对象详解
王梦杰_MengJie
03-07 1万+
1、初识面向对象： 面向过程vs面向对象 面向过程思想：步骤清晰简单，第一步做什么，第二步做什么……，面向过程适合处理一些较为简单的问题 面向对象思想：物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考，最后，才对某个分类下的细节进行面向过程的思索。面向对象适合处理复杂的问题，适合处理需要多人协作的问题。 对于描述复杂的事物，为了从宏观上把握，从整体上合理分析，我们需要使用面向对象的思路来分析整个系统，但是，具体到微观操作，仍然需要面向过程的思路去处理。
面向对象基本概念
热门推荐
Superme
02-06 18万+
面向对象就是：把数据及对数据的操作方法放在一起，作为一个相互依存的整体——对象。对同类对象抽象出其共性，形成类。类中的大多数数据，只能用本类的方法进行处理。类通过一个简单的外部接口与外界发生关系，对象与对象之间通过消息进行通信。程序流程由用户在使用中决定。对象即为人对各种具体物体抽象后的一个概念，人们每天都要接触各种各样的对象，如手机就是一个对象。 面向对象编程（OOP：object-orie...
面向对象的思维过程
03-02
本文是关于面向对象思维过程系列文章的第一部分，选择这个主题作为书籍或专栏的标题是一个重大的决定，做出这个选择并不简单，因为已经有很多面向对象主题的好书和文章了，包括面向对象分析、面向对象设计、面向对象...
C++ 面向对象示例
08-17
【C++ 语言】面向对象 ( 类定义 | 限制头文件引用次数 | 构造方法 | 析构方法 ) : https://hanshuliang.blog.csdn.net/article/details/99609557 【C++ 语言】面向对象 ( 成员函数 | 常量函数 | 友元函数 | 友元类 ...
面向对象.xmind
12-16
使用Xmind软件大概绘制了一下java面向对象的学习流程，欢迎交流指教！ 面向对象基础 进阶 高级 写的框架很细, 初学者可以做参考学习。 谢谢！
面向对象软件工程
05-12
《面向对象软件工程》 作者：Stephen.R.Schach 学校：(美)范德比尔特大学 书名原名：Objected-Oriented Software Engineering 目录： 第一部分　面向对象软件工程简介 　第一章　面向对象软件工程的范畴 　第二章　...
java Object 转 Integer
servepeople的博客
07-09 314
在 Java 中，可以通过多种方法将一个Object转换为Integer。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 1347
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
AI技术的转变：从辨别式到生成式
学IT，找陈寒
07-09 882
李彦宏在2024世界人工智能大会上的发言，提醒我们在AI技术发展的道路上，不要盲目追求技术本身或表面的用户数据，而应更多地关注技术的实际应用和产业价值。在大模型技术与个性化应用之间找到平衡，将是未来发展的关键。作为AI从业者和技术爱好者，我们应以务实的态度，探索AI技术在各个领域的实际应用，为产业发展和社会进步贡献力量。通过李彦宏的发言，我深刻认识到AI技术发展的方向和挑战，也更加坚定了自己在这一领域继续探索和创新的信心。未来，愿我们共同努力，推动AI技术更好地服务于社会和产业，为人类创造更美好的未来。
java中 使用数组实现需求小案例（二）
最新发布
qq_44304677的博客
07-09 246
java小案例，数组需求实现，使用Random函数实现用户输入随机数生成一个打乱的数组
Labview面向对象编程快速入门.pdf
05-11
"面向对象编程是LabVIEW中的一种高级编程范式，它允许开发者通过类和对象的概念来组织和设计代码，提高代码的重用性和模块化。LabVIEW面向对象编程的核心概念包括类、对象、数据和方法。 1. **类与对象**： 类是...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值