扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 后端开发 > Python >java基础的详细了解第九天
  • 845

0
分享到

java基础的详细了解第九天

2024-04-02 19:04:59 845人浏览 独家记忆

Python 官方文档：入门教程 => 点击学习

摘要

目录1、匿名内部类2、Object类简介 2.1 取得对象信息toString()2.2 对象的比较equals()2.3 Object接口引用数据类型3、包装类3.1 装箱与拆箱3

1、匿名内部类

内部类：在一个类的内部定义了另外的类，称为内部类，匿名内部类指的是没有名字的内部类。为了清楚内部类的主要作用，下面首先观察一个代码。


interface IMessage{
	public void print();
}
class MessageImpl implements IMessage{//定义接口实现类
	public void print(){
		System.out.println("Hello World");
	}
}
class Demo{
	public static void get(IMessage msg){//接受接口对象
		msg.print();
	}
}
public class TestDemo1{
	public static void main(String args[]){
		IMessage msg = new MessageImpl();//子类为接口实例化
		Demo.get(msg);//传递msg对象
	}
}

如果说现在MessageImpl这个子类只使用一次，有必要按照以上的方式进行定义吗？

这个时候MessageImpl就没有什么意义了，但是可以利用匿名内部类的概念来解决此问题。匿名内部类是在抽象累和接口的基础之上发展起来的。


interface IMessage{
	public void print();
}
class Demo{
	public static void get(IMessage msg){//接受接口对象
		msg.print();
	}
}
public class TestDemo1{
	public static void main(String args[]){
		IMessage msg = new IMessage(){//匿名内部类
			public void print(){
				System.out.println("hello,world!");
			}
		};
		Demo.get(msg);//传递msg对象
	}
}

结论：基本上搞匿名内部类都应该在接口或抽象类形式上完成。

在抽象类中使用匿名内部类


abstract class Message{
	public void print(){
		System.out.print(this.getInfo());
	}
	public abstract String getInfo();
}
class Demo{
	public static void get(Message msg){//接受接口对象
		msg.print();
	}
}
public class TestDemo1{
	public static void main(String args[]){
		Demo.get(new Message(){
			public String getInfo(){
				return "www.baidu.com";
			}
		});//传递msg对象
	}
}

强调：一个普通类进行不要再去有子类进行继承，能够继承的只是抽象类和接口，所以在普通类上继续使用

匿名内部类的形式来定义子类，但是在正常的开发逻辑上是错误的。

2、Object类简介

在Java的定义之中，除了Object类之外，所有的类实际上都存在继承关系，即：如果现在定义了一个类，没有默认继承任何一个父类的话，则默认讲继承Object类，以下两种类最终定义效果是完全一样的。

Object类的无参构造是专门子类提供服务的。

方法名称 类型 描述
public String toString() 普通 取得对象信息
public boolean equals(Object obj) 普通 对象的比较
public int hashCode() 普通 返回对象的哈希码值

2.1 取得对象信息toString()

toString()的核心目的在于取得对象信息。相当于替换了getInfo()方法的功能。


class Person{
	private String name;
	private int age;
	public Person(String name, int age){
		this.name = name;
		this.age = age;
	}
	public String toString(){
		return "name = " + this.name + ",age = " + this.age ;
	}
}
public class TestDemo2{
	public static void main(String args[]){
		Person p = new Person("zsr",18);
		System.out.print(p.toString());
	}
}

2.2 对象的比较equals()

实际上对于equals()方法应该并不陌生，这个方法在String类中见过，String是Object类的子类，所以String类的equals()方法就是覆写了Object类中的equals()方法，在Object类之中，默认的equals()方法实现比较的是两个对象的内存地址数值，但是并不符合与真正的对象比较需要。对象比较之前也写过，但是之前那是自己定义的一个新的方法名称，今天可以给出标准的方法名称：equals()。


class Person{
	private String name;
	private int age;
	public Person(String name, int age){
		this.name = name;
		this.age = age;
	}
	public boolean equals(Object anObject){
		if(anObject == null){
			return false;
		}
		if(this == anObject){
			return true;
		}
		//判断anObject的实例是不是Person
		if( !(anObject instanceof Person)){
			return false;
		}
		//必须将Object类型变为Person类型后才可以调用name和age属性
		Person per = (Person) anObject;
		return this.name.equals(per.name) && this.age == per.age;
	}
	public String toString(){//覆写Object类方法
		return "name = " + this.name + ",age = " + this.age ;
	}
}
public class TestDemo3{
	public static void main(String args[]){
		Person per1 = new Person("zsr",18);
		Person per2 = new Person("zsr",18);
		//true
		System.out.println(per1.equals(per2));
		//false
		System.out.println(per1.equals("Hello,world!"));
	}
}

但是需要有一个注意，很多人在写对象的比较会使用如下的形式：

  • public boolean equals(Person anObject)

因为父类中的equals()方法用的是Object，所以以上的方法严格来讲已经不叫覆写，叫重载。

2.3 Object接口引用数据类型

在之前的分析来讲Object可以接收任意的对象，从结构上来讲Object是所有类的父类，但是Object概念并不仅仅局限于此，他已接收所有的引用数据类型，包括：接口、数组。

使用Object类接收数组，数组和Object没有任何明确的关系。


public class TestDemo4{
	public static void main(String args[]){
		Object obj = new int []{1,3,4};
		int data [] = (int [])obj;//向下转型
		for(int i = 0 ;i < data.length ; i++){
			System.out.println(data[i]);
		}
	}
}

接收接口对象，从接口的定义而言，它是不能去继承一个父类的，但是由于接口依然属于引用类型，所以即使没有继承类，也可以使用Object接收。


interface Message{}
class MessageImpl implements Message{//定义接口子类
	public String toString(){
		return "Hello World";
	}
}
public class TestDemo5{
	public static void main(String args[]){
		Message msg = new MessageImpl();//向上转型
		Object obj = msg;//向上转型
		Message temp = (Message) obj;//向下转型
		System.out.println(temp);//toString()
	}
}

从代码上讲，以上只能算是一个固定的操作概念，不过从实际来讲，因为有了Obejct类的出现，所有的操作就可以达到统一，那么之前的链表程序，就应该变得很方便了。所有的数据都使用Object接收，所有的对象比较（删除、查找）都可以使用equals()。

3、包装类

在Java的设计之中，一直倡导一个原则：一切皆对象，这个原则本省有一个漏洞，基本数据类型不是对象，所以这个原则就出现了问题，那么如果说现在这个问题由我们来解决，该如何解决呢？


class MyInt{
	private int num;//基本类
	public MyInt(int num){
		this.num=num;
	}
	public int intValue(){
		return this.num;
	}
}
public class TestDemo6{
	public static void main(String args[]){
		Object obj = new MyInt(10);//子类自动变为Object父类对象
		MyInt temp = (MyInt) obj;//向下转型
		int result = temp.intValue();
		System.out.println(result*result);
	}
}

以上的操作是将基本类型变为了一个对象的形式进行操作了，但是这里面有一个问题：基本数值型数据是可以进行数学运算的，可是以上变为了类的形式，那么肯定无法直接计算了。以上的问题既然我们都想到方法解决，那么Java也一定早已解决，为此它专门提供了八种包装类：

byte(Byte),short(Short),int(Integer),long(Long),float(Float),double(Double),boolean(Boolean),char(Character);

而这八种包装类有分为两大阵营：

​ 数值型（Number子类）：Byte,Short,Integer(int),Float,Double,Long;

​ 对象型（Object子类）：Boolean,Character(char)。

可是对于Number的子类，就必须观察出Number类之中定义的方法：byteVlue()、intVlue()、doubleVlue()、shortVlue()、longVlue()、floatVlue()，就是从包装的类之中取得所包装的数值。

3.1 装箱与拆箱

在基本数据类型和包装类之间的转化之中分为两个重要概念：

​ 装箱操作：将基本数据类型变为包装类，称为装箱，包装类的构造方法。

​ 拆箱操作：将包装类变为基本数据类型，称为拆箱，Number类中的xxValue()方法。

以int和Integer为例


public class TestDemo{
	public static void main(String args[]){
		Integer var = new Integer(10);//装箱
		int result = var.intValue();//拆箱
		System.out.println(result*result);
	}
}

以double和Double为例


public class TestDemo{
	public static void main(String args[]){
		Double var = new Double(10.0);//装箱
		double result = var.doubleValue();//拆箱
		System.out.println(result*result);
	}
}

以上的操作实在jdk1.5之前所进行的必须的操作，但是到了JDK1.5之后，Java提供了自动装箱和自动拆箱的机制，并且包装类的对象可以自动的进行数学计算了。

自动装箱与拆箱


public class TestDemo{
	public static void main(String args[]){
		Integer var = 10;//自动装箱
		int result = var;//自动拆箱
        //可以直接利用包装类进行对象操作
		System.out.println(++var*result);//自动进行数学运算
	}
}

但是到此为止还有一个小问题，实际上这一问题之前已经见过。


public class TestDemo{
	public static void main(String args[]){
		Integer x = new Integer(10);//新空间
		Integer y = 10;//入池
		Integer z = 10;
		System.out.println(x==y);//false
		System.out.println(x==z);//false
		System.out.println(y==z);//ture
		System.out.println(x.equals(y));//ture
	}
}

使用包装类的时候还需要考虑equals()和==的区别。

使用int还是Integer?

  • 在接收数据的时候，使用的一定都是int，而保存数据的时候一般使用Integer
  • 以后编写的简单java类统一不要再去使用基本数据类型，全部换位包装类

3.2 字符串与基本数据类型的转换

包装类之中所提供的最大优点在于可以讲字符串变为制定的基本数据类型，下面列出几个操作：

​ Integer类：public static int parseInt(String s);

​ Double类：public static double parseDouble(String s);

​ Boolean类：public static boolean parseboolean(String s;

但是character这个包装类之中，并没有提供一个类似的parseCharacter()，因为字符串String类之中提供了一个charAt()方法，可以取得制定索引的字符，而且一个字符的长度就是一位。

将字符串变为int


public class TestDemo{
	public static void main(String args[]){
		String str = "16";
		int result = Integer.parseInt(str);//String ——>int
		System.out.println(result*result);
	}
}

但是需要提醒的是，在执行这种转化的操作过程之中，字符串字符串中的全部内容必须由数字所组成，如果有一位内容不是数字，则在转化的过程之中讲出现如下的错误提示：NumbnerFORMatException。

将字符串变为double


public class TestDemo{
	public static void main(String args[]){
		String str = "16.";
		double result = Double.parsedouble(str);//String ——>int
		System.out.println(result*result);
	}
}

将字符串变为boolean型数据


public class TestDemo{
	public static void main(String args[]){
		String str = "true";
		boolean result = Boolean.parseboolean(str);//String ——>int
		System.out.println(result);
	}
}

提示：在使用Boolean型包装类的时候，如果字符串之中的内容不是true或者是false，统一都按照false处理。

以上的操作是通过字符串变为一些基本类型的数据，但是反过来讲，基本数据类型如何变为字符串呢？

方式一：任何基本数据类型遇到了String之后都会变为String型数据；


public class TestDemo{
	public static void main(String args[]){
		int num = 100;
		String str = num+"";//int——>String //会产生垃圾
		System.out.println(str.length());
	}
}
//会有垃圾产生

方式二：利用String方法，public static String valueOf(数据类型 b)


public class BaoZhuangLei{
	public static void main(String args[]){
		int num = 100;
		String str =String.valueOf(num);//int——>String
		System.out.println(str.length());
	}
}

3.3 包的定义

在Java程序之中的包，主要的目的是可以将不同功能的文件进行分割，在之前的代码开发之中，所有的程序都保存在了同一个目录之中，这样一来所带来的问题：如果出现了同名的文件，那么会发生覆盖问题，因为在同一个目录之中不允许有重名的文件，而在不同的目录下可以有重名文件，所谓的包实际上指的就是文件夹。


package cn.mldn.demo;//定义包
public class Hello{
	public static void main(String args[]){
		System.out.println("Hello World");
	}
}

一旦定义完成之后，那么这个类的名字就成了“cn.mldn.demo.Hello”，即这既是完整的类名称，而在进行程序编译的时候也需要将*.class文件保存在包之中，于是为了方便开发，那么也就提供了一个打包的编译操作。

打包编译：javac -d . 类.java

-d:表示生成目录，根据package定义生成

-“.”:再当前目录下生成*.class

类.java:编译源程序代码

这个时候类的名字必须带上包的名称，所以执行类的时候：java cn.mldn.demo.Hello，也就是说完整类的名称就是“包.类”，而在所有的开发之中，没有包的类是绝对不存在的，只要是程序一定要有包。

3.4 包的导入

既然使用包可以将一个大型的程序拆分成不同的功能目录保存，那么这些不同的包之间也一定会存在包的导入问题，而导入包在程序之中使用import完成，下面通过一个程序进行演示。


//定义一个Message
package cn.mldn.util;//打包
class Massage{
	public String print(){
		return "Hello World";
	}
}


//定义另外一个类使用Message类
package cn.mldn.text;//打包
import cn.mldn.util.Message;//导入包
public class Text{
	public static void main(String args[]){
		Massage msg = new cn.mldn.util.Massage();
		System.out.println(msg.print());
	}
}

这个时候上面的两个类应该是按照顺序编译：

​ 应该首先编译Message.java程序：javac –d . Message.java;

​ 再次编译Test.java程序：javac –d . Test.java，但是这个时候出现了一下的错误提示：


Text.java:5: 错误: Massage在cn.mldn.util中不是公共的; 无法从外部程序包中对其进行
访问
                Massage msg = new cn.mldn.util.Massage();
                ^

提示：关于public class 和class定义类的区别

​ Public class：文件名和类名称保持一致，在一个*.java文件之中只能存在一个public class定义，如果一个类要想被外部包所访问必须定义为public；

​ Class：文件名称可以和类名称不一致，在一个*.java之中可以同事存在多个class定义，并且编译完成之后会形成多个*.class文件，使用class定义的类只能够在一个包中访问，不同包之间无法访问。


package cn.mldn.util;//打包
public class Massage{
	public String print(){
		return "Hello World";
	}
}

但是同时也发现了一个问题，现在这些类在编译的时候要有顺序，实在很麻烦，为此在java之中专门提供了一个可以进行自动连编的操作，编译的时候使用*.java：javac –d . .java，将一个目录之中所有的.java文件进行编译。

​ 但是以上的代码还有一个小问题：程序在进行导入的时候使用了“包.类”的完整名称完成的，但是如果在一个程序之中要同时导入一个包的多个类的时候，那么分开去编写实在很麻烦，为此可以使用通配符“*”完成导入。


package cn.mldn.text;//打包
import cn.mldn.util.*;//导入包
public class Text{
	public static void main(String args[]){
		Massage msg = new cn.mldn.util.Massage();
		System.out.println(msg.print());
	}
}

但是需要注意的是，在java之中使用“”或者是的单独导入，其从实际的操作性能上是没有任何区别的，因为即使使用了也表示导入所需要的类，不需要的不导入。

​ 可是在导入包的时候也会遇到一种比较麻烦的问题：会导入不同包的同名类，例如：对于Message类，现在在两个包中都有：cn.mldn.util cn.mldn.info


package cn.mldn.text;//打包
import cn.mldn.util.*;//导入包
import cn.mldn.info.*;//导入包
public class Text{
	public static void main(String args[]){
		Message msg = new cn.mldn.util.Message();
		System.out.println(msg.print());
	}
}

由于某种需要，同时导入两个包，这个时候要使用Message类的时候必须加上类的全名。


package cn.mldn.text;//打包
import cn.mldn.util.*;//导入包
import cn.mldn.info.*;//导入包
public class Text{
	public static void main(String args[]){
		cn.mldn.util.Message msg = new cn.mldn.util.Message();
		System.out.println(msg.print());
	}
}

4、访问控制权限

之前学习到的private就属于一种访问控制权限，而这种访问控制权限只是封装的一部分，再java里面提供有四种访问控制权限：private、default、protected、public，而这四种访问控制权限定义如下：

范围 private default protected public
同一包中的同一类 √ √ √ √
同一包中不同类 √ √ √
不同包中的子类 √ √
不同包中的非子类 √

实际上public永远都可以访问，但是对于封装而言主要使用三个权限：private、default、protected。

观察protected访问权限

Info.java


package cn.sxau.demo.a;
public class Info {
//protected权限
	protected String str = "www.baidu.com";
}

SubInfo.java


package cn.sxau.demo.a;
import cn.sxau.demo.a.Info;
public class SubInfo extends Info{
	public void print(){
		System.out.println(super.str);
	}
}

TestInfo.java


package cn.sxau.testab;
import cn.sxau.demo.a.SubInfo;
public class TestInfo{
	public static void main(String args[]){
		new SubInfo().print();
	}
}

image-20210807211643215

可以发现SubInfo继承的子类Info不在同一个包内，但是在同一个子类中，并且可以调用其子类。

错误代码


package cn.sxau.testab;
import cn.sxau.demo.a.Info;
public class TestInfo{
	public static void main(String args[]){
		System.out.println(new Info().str);
	}
}

原因是str是protected权限，所以在不同类非子类的类中是无法访问。

对于权限的选择

  • 对于封装的描述大部分情况下都使用的是private,很少的情况下使用protected，这两个都叫封装
  • 属性都是以private，方法都使用public。

封装性就是指private、protected、default三个权限的使用。

5、jar命令

Jar是一种java给出的压缩格式文件，即：可以将*.class文件以*.jar压缩包的方式给用户，这样方便程序的维护，如果要使用jar的话，可以直接利用JDK给出的jar命令完成。

image-20210807214226657

c：创建一个新的归档文件

f：指定jar的文件名称，由用户制定一个*.jar的文件名。

v：生成标准的压缩信息

Message.java


package cn.sxau.util;//打包
public class Message{
	public String print(){
		return "hello world";
	}
}

将Message.java程序进行编译：javac –d . Message.java，生成包.类；将“包.类”压缩成my.jar文件：jar –cvf my.jar cn，出现了一个my.jar包；

此时my.jar就包含了所需要的程序使用类

现在my.jar和MyTest.java处于同一目录之中。但是发现找不到my.jar之中定义的内容，这是因为在java之中每一个*.jar文件都属于一个独立的CLASSPATH路径，如果要想使用，必须配置CLASSPATH。

在测试之前需要在cmd配置SET CLASSPATH=.;F:\java\javabase\day09\my.jar


//定义一个测试类 调用my.jar
package cn.sxau.test;
public class MyTest{
	public static void main(String args[]){
		cn.sxau.util.Message msg = new cn.sxau.util.Message();
		System.out.println(msg.print());
	}
}

总结

本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注编程网的更多内容！

您可能感兴趣的文档:

--结束END--

本文标题: java基础的详细了解第九天

本文链接: https://lsjlt.com/news/132220.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

猜你喜欢
  • java基础的详细了解第九天
    目录1、匿名内部类2、Object类简介 2.1 取得对象信息toString()2.2 对象的比较equals()2.3 Object接口引用数据类型3、包装类3.1 装箱与拆箱3...
    99+
    2024-04-02
  • java基础的详细了解第一天
    目录1、Java主要特点2、计算机的高级汇编语言类型：3、JVM（Java Visual Machine)4、编写第一个Java程序并运行5、CLASSPATH指的是类加载路径6、程...
    99+
    2024-04-02
  • java基础的详细了解第二天
    目录1、方法的基本定义2、方法重载3、方法的递归调用4、面向对象的前身是面向过程5、类与对象内存分析引用传递总结1、方法的基本定义 限制条件：本次所讲解的方法指的是在主类中定义，并且...
    99+
    2024-04-02
  • java基础的详细了解第三天
    目录1、private实现封装处理2、构造方法与匿名对象3、简单java类4、数组总结1、private实现封装处理 如果像想要知道封装，首先必须清楚如果没有封装会怎么样？ 没有封装...
    99+
    2024-04-02
  • java基础的详细了解第四天
    目录1、数组数组的引用传递数组的静态初始化数组与方法的调用Java对数组的支持数组的数据分析数组排序数组的转置数组的二分查找法对象数组总结1、数组 数组的引用传递 public ...
    99+
    2024-04-02
  • java基础的详细了解第五天
    目录1、String类1.1两种对象实例化方式1.2字符串比较1.3字符串常量是String的匿名对象1.4String两种实例化方式区别1、分析直接赋值方式2、构造方法赋值1.5字...
    99+
    2024-04-02
  • java基础的详细了解第六天
    目录1、this关键字1.1 “this.属性”表示本类属性1.2“this”表示调用本类方法1.3“this”表示当前对象1.4引用传递进阶分析1.5对象比较1.6引用传递实际应用...
    99+
    2024-04-02
  • java基础的详细了解第七天
    目录1、static关键字1.1 使用static关键字定义属性1.2 使用static定义方法1.3 分析主方法1.4 关键字的使用2、代码块2.1 普通代码块2.2 构造块2.3...
    99+
    2024-04-02
  • java基础的详细了解第八天
    目录1、多态性1.1 向上转型1.2 向下转型2、抽象类2.1 抽象类的基本概念抽象方法为什么不能实例化对象？关于抽象类的若干中疑问？3、接口3.1 接口的基本概念3.2 接口的使用...
    99+
    2024-04-02
  • Java面试题冲刺第一天--基础篇1
    目录面试题1：Java 中操作字符串都有哪些类？它们之间有什么区别？ 正经回答：深入追问：追问1：这三者在效率上怎么说？追问2：那StringBuffer和StringBuffer线...
    99+
    2024-04-02
  • Java面试题冲刺第五天--基础篇2
    目录面试题1：说一下抽象类和接口有哪些区别？正经回答：深入追问：追问1：说一说你对抽象类的理解吧，他到底是干啥用的追问2：用抽象类实现一个接口，和普通类实现接口会有什么不同么？追问3...
    99+
    2024-04-02
  • java基础第23天_数据库连接池\反射
    1.属性赋值-------------1.Man{50+ }Man man = new Man();man.setXxx1(...);man.setXxx2(...);...50Man copy = new...
    99+
    2024-04-02
  • Java面试题冲刺第十七天--基础篇3
    目录面试题1：JDK1.8的新特性有哪些？接口的默认和静态方法：Lambda 表达式：方法与构造函数引用：函数式接口：Annotation 注解：支持多重注解：新的日期时间 API：...
    99+
    2024-04-02
  • 【Java基础】- HttpURLConnection详解
    【Java基础】- HttpURLConnection详解 文章目录 【Java基础】- HttpURLConnection详解一、HttpURLConnection简述二、HttpURLCo...
    99+
    2023-09-09
    java servlet 开发语言 HttpURL
  • android基础总结篇之九：Intent应用详解
    今天我们来讲一下Android中Intent的原理和应用。 前面我们总结了几个Android中重要组件，相信大家对于这些组件已经有了清晰的认识，我们就来看一下几个常见的操作：...
    99+
    2022-06-06
    intent Android
  • Java中的类（基础详解）
    文章目录 可以有多个类，但只能有一个public类类 = 字段+方法类的构造函数我们没写构造函数的时候如果我们自己写了构造函数构造函数中 this 的使用 类的修饰符 / 控制符第一...
    99+
    2023-09-01
    java jvm c++
  • 【Java 基础篇】Java Collection详解
    文章目录 导言一、Collection 简介二、List 接口三、Set 接口四、Map 接口总结 导言 Java的Collection框架是一组用于存储和操作对象的接口和类。它提供了...
    99+
    2023-09-14
    java 开发语言 jvm
  • 【Java 基础篇】Java Map 详解
    文章目录 导言一、Map 概述二、HashMap三、TreeMap四、LinkedHashMap总结 导言 在Java的集合框架中，Map接口用于存储键值对，提供了一种基于键进行查找和操作的数据结构。Map接口的实现类提供了...
    99+
    2023-08-30
    java 开发语言 数据结构
  • 【Java 基础篇】Java List 详解
    文章目录 导言一、List 概述二、ArrayList三、LinkedList四、Vector总结 导言 在Java的集合框架中，List接口是一个有序、可重复的集合，它扩展了Coll...
    99+
    2023-09-11
    java list 数据结构
  • 【Java 基础篇】Java Set 详解
    文章目录 导言一、Set 概述二、HashSet三、TreeSet四、LinkedHashSet总结 导言 在Java的集合框架中，Set接口是一个无序、不可重复的集合，它扩展了Col...
    99+
    2023-10-18
    java 开发语言 数据结构
软考高级职称资格查询
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作