JAVA编程思想——读书笔记 类再生

最新推荐文章于 2022-05-10 19:23:10 发布
最新推荐文章于 2022-05-10 19:23:10 发布
阅读量92 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xsxsprxd/article/details/119460896
版权

文章目录

类再生

  1. 组合（Composition）：在新类创建现有类的的对象
  2. 继承（Inheritance）：创建一个新类，将其做为现有类的一个“类型”。我可原样采用现有类的形式，并在其中加入代码，同时不会对现有类产生影响。

1. 组合的语法

对象句柄的初始化

确保所有字段在使用之前得到初始化

  1. 在对象定义时。意味着在调用构造器之前肯定能得到初始化。
  2. 在那个类的构造器中。
  3. 紧靠在要求实际使用的对象之前。这样可减少不必要的开销（如果对象并不需要创建的话）

示例：

package c6;
//：Bath.java
class Soap {
	private String s;
	Soap(){	//Constructed
		System.out.println("Soap()");
		s= new String("Constructed");
	}
	public String toString() { return s;}
}

public class Bath {
	private String
	//Initializing at point of definition(在定义变量（对象）的时候初始化)
	s1=new String("Happy"),
	s2="Happy",
	s3,s4;
	Soap castille;
	int i;
	float toy;
	public Bath() {
		System.out.println("Inside Bath()");
		//在构造方法内初始化
		s3=new String("JOY");
		i=47;
		toy=3.14f;
		castille=new Soap();
	}
	void print() {
		//Delayed initialization(对象使用之前初始化):
		if(s4==null)
			s4=new String("JOY");
		System.out.println("s1 = " + s1);
		System.out.println("s2 = " + s2);
		System.out.println("s3 = " + s3);
		System.out.println("s4 = " + s4);
		System.out.println("i = " + i);
		System.out.println("toy = " + toy);
		System.out.println("castille = " + castille);
	}

	public static void main(String[] args) {
		Bath b=new Bath();
		b.print();
	}

}

2. 继承的语法

“这个新类和那个旧类差不多” “子类是父类的一种类型”
class 子类 extends 父类 {...}
举个栗子：

//:Detergent.java
//Inheritance syntax & properties
class Cleanser{

	private String s=new String("Cleanser");
	public void append(String a) {s +=a;}
	public void dilute() {append(" dilute");}
	public void apply() {append(" apply");}
	public void scrub() {append(" scrub");}
	public void print() {System.out.println(s);}
	public static void main(String[] args) {
		Cleanser x= new Cleanser();
		x.dilute(); x.apply(); x.scrub();
		x.print();
		
	}
}
public class Detergent extends Cleanser {
	//Change s method:
	@Override
	public void scrub() {  //重写scrub方法
		append(" Detergent.scrud()");
		super.scrub(); //Call base-class version(调用父类原本的scrub方法)
	}
	//Add methods to the interface
	public void foam() {append(" foam"); }
	//Test the new class:
	public static void main(String[] args) {
		Detergent x=new Detergent();
		x.dilute(); x.apply(); x.scrub(); x.foam();
		x.print();
		System.out.println("Test base class:");
		Cleanser.main(args); //调用父类主方法
		
	}
}

3. 初始化父类

编译器强制我们在子类的构造器中首先设置对父类构造器的调用 具体如下：

默认构造器

父类会在子类调用它之前得到正确的初始化，即使子类没有构造器编译器也会其合成一个默认构造器

//:Cartoon.java
//Constructor calls during inheritance
class Art{
	Art(){
		System.out.println("Art constructor");
	}
}
class Drawing extends Art{
	Drawing(){
	    super();  //默认省略
		System.out.println("Drawing constructor");
	}
}
public class Cartoon extends Drawing {
	public Cartoon() {
		System.out.println("Cartoon constructor");
	}
	public static void main(String[] args) {
		Cartoon x=new Cartoon();
	}
}

输出:
Art constructor
Drawing constructor
Cartoon constructor

有参构造器

有参数的构造器，必须明确的编写对父类构造方法的调用代码,可用super关键字实现。

//:Chess.java
//Inheritance,constructors and argument

class Game{
	Game(int i){
		System.out.println("Game constructor"+i);
	}
}

class BoardGame extends Game {
	BoardGame(int i){
	super(i);	
	System.out.println("BoardGame constructor"+i);
}
}
public class Chess extends BoardGame {
	Chess(){
		super(2);
		System.out.println("Chess constructor");
	}
	public static void main(String[] args) {
		Chess x=new Chess();
	}

}

4.合成和继承的结合

编译器强制我对父类初始化，并要求在构造器的开头。但它并不会监控我们是否做了正确的初始化，所一必须特别留意。

//:PlaceSetting.java
//Combining composition & inheritance
class Plate {
	Plate(int  i){
		System.out.println("Plate constructor");
	}
}

class DinnerPlate extends Plate{
	DinnerPlate(int i) {
		super(i);
		System.out.println("DinnerPlate constructor");
	}
}


class  Utensil{
	Utensil(int i){
		System.out.println("Utensil constructor");
	}
}

class Spoon extends Utensil {
	Spoon(int i){
		super(i);
		System.out.println("Spoon constructor");
	}
}

class Fork extends Utensil{
	Fork(int i){
		super(i);
		System.out.println("Fork constructor");
	}
}

class Knife extends Utensil{
	Knife(int i){
		super(i);
		System.out.println("Knife constructor");
	}
}

//A cultural way of doing something
class Custom{
	Custom(int i){
		System.out.println("Custom constructor");
	}
}
public class PlaceSetting extends Custom{
	Spoon sp;
	Fork frk;
	Knife kn;
	DinnerPlate pl;
	PlaceSetting(int i){
		super(i+1);
		sp = new Spoon(i+2);
		frk= new Fork(i+3);
		kn=new Knife(i+4);
		pl=new DinnerPlate(i+5);
		System.out.println("PlaceSetting constructor");
		}
	public static void main(String[] args) {
		PlaceSetting x=new PlaceSetting(9);
	}
}

输出：

Custom constructor
Utensil constructor
Spoon constructor
Utensil constructor
Fork constructor
Utensil constructor
Knife constructor
Plate constructor
DinnerPlate constructor
PlaceSetting constructor

5.选择组合还是继承

谨慎使用继承

  1. 只有继承在所有方法中最有效时，才能考虑使用它。
  2. 子类是否要向上转型回到父类，若必须向上转型就使用继承。
  3. 时常问自己我真的需要向上转型吗

“属于”关系永继承来表达 “包含”关系有组合来表达
例：

//:Car.java
//Composition with public objects

class Engine{
	public void start() {}
	public void rev() {}
	public void stop() {}
}

class Wheel{
	public void inflate(int psi) {}
}

class Window{
	public void rollup() {}
	public void rolldown() {}
}

class Door{
	public Window window=new Window();
	public void open() {}
	public void close() {}
}

public class Car {
	public Engine engine=new Engine();
	public Wheel[] wheel=new Wheel[4];
	public Door left=new Door(),
			rigth=new Door();
	Car(){
		for(int i=0;i<4;i++)
			wheel[i]=new Wheel();
	}
	public static void main(String[] args) {
		Car car=new Car();
		car.left.window.rolldown();
		car.wheel[0].inflate(72);
	}
	
}

6.向上转型

继承并没有给新类提供方法，而是对子类和父类之间关系的表达；“子类属于父类的一种类型”

  • 向上转型： 通过子类对象（小范围）实例化父类对象（大范围），属于自动转换。
  • 向下转型： 通过父类对象(大范围)实例化子类对象(小范围),这种属于强制转换

例：一个父类Instrument（乐器），其中有一个子类 Wind（管乐器），继承意味父类中的所有方法都可以在子类中使用，若Instrument类有个paly()方法，则子类Wind类中也会有这个方法，这样我们可以 肯定的认为wind对象也是Instrument的一种类型 。

//:Wind.java
//Inheritance & upcasting
import java.util.*;
class Instrument{
	public void paly() {}
	static void tune(Instrument i) {
		//.....
		i.paly();
	}
}
//Wind objects are instrument 
//because they have the same interface:
 class Wind extends Instrument {
	 public static void main(String[] args) {
		Wind flute=new Wind();  //flute：长笛
		//由于Wind类继承自Instrument类，所以Wind对象也是一个Instrument对象
		Instrument.tune(flute); //upcasting
	}
} ///:~

这里我们把一个Win句柄转换为Instrument的行为叫做：向上转型

7.什么是向上转型

graph BT
Wind子类-->Instrument父类

通常类继承图的画法是根部位于最顶端，在逐渐向下扩展。
由于是造型的方向是从子类到父类，箭头由下到上所以叫向上转型，即upcasting

8.final关键字

  1. 被final修饰的类不可以被继承
  2. 被final修饰的方法不可以被重写
  3. **被final修饰的变量不可变

由于应用的场景不一样，final关键的含义也会有一些差异

final修饰Data

final的3种初始化方式：
  1. 定义变量是直接初始
  2. 声明变量后在构造方法中初始化（在每个构造器中都要进行初始化）
  3. 声明变量后在构造代码块中初始化
常量：
  1. 编译期常量，它永远不会改变
  2. 在运行期初始化的一个值，我们不希望它发生变化
final修饰对象：
  1. final会把对象句柄变成“常量”，声明时必须将句柄初始化一个具体的对象
  2. 该句柄不能在指向另一个对象，而对象本身是可以修改的
/:FinalData.java
//The effect of final on fields
class Value{
	int i=1;
}
public class FinalData {
	//can be compile-time constants(可做为编译时的常量):
	final int i1=9;
	static final int I2=99;
	//Typical public constant:
	public static final int I3=39;
	//Cannot be compile-time constants:
	final int i4=(int)(Math.random()*20);
	static final int i5=(int)(Math.random()*20);
	
	Value v1=new Value();
	final Value v2=new Value();
	static final Value v3=new Value(); //
	
	//Arrays:
	final int[] a= {1,2,3,4,5,6};
	
	public void print(String id) {
		System.out.println(
				id + ": " + "i4 = " + i4 + 
				 ", i5 = " + i5);
	}
	public static void main(String[] args) {
		FinalData fd1 = new FinalData();
//!		fd1.i1++;  //Error：无法更改值
		fd1.v2.i++;
//!		fd1.v2=new Value();
		fd1.v1 = new Value(); // oK--not final
		for (int i = 0; i < fd1.a.length; i++)
			fd1.a[i]++; // Object isn't constant
		// ! fd1.v2 = new Value(); // Error: Can't
		// ! fd1.v3 = new Value(); // change handle
		// ! fd1.a = new int[3];
		
		fd1.print("fd1");
		System.out.println("Creating new FinalData");
		FinalData fd2=new FinalData();
		fd1.print("fd1");
		 fd2.print("fd2");
	}
}
空白final(未在声明时初始化)

尽管被声明成 final，但却未得到一个初始值。无论在哪种情况下，空白 final 都必须在实际使用前得到正确的初始化。

空白final具有很大的灵活性
比如：想要一个final变量对每一个对象都不同，并且依然持有保持“不变”的特性。

//:BlankFinal.java
//"Blank" final data members 

class Poppet{}

public class BlankFinal {
	final int i=0;	//Initialized final 
	final int j;	//Blank final 
	final Poppet p;	//Blank final handle
	//Blank finals MUST be initialized
	//in the constructor
	BlankFinal(){
		j=1; //initialized blank final
		p=new Poppet();	//initialized blank handle
		System.out.println(j);
	}
	BlankFinal(int x){
		j=x;	//initialized blank final
		p=new Poppet();	
		System.out.println(j);
	}
	public static void main(String args[]) {
		BlankFinal df=new BlankFinal();
	}
}
final修饰参数
  1. 这意味这在一个方法的内部，我们不能改变参数句柄所指向的东西;
  2. 只能读取final修饰的参数；
//: FinalArguments.java
// Using "final" with method arguments
class Gizmo{
	public void spin() {}
}
public class FinalArguments {
	void with(final Gizmo g) {
//!		g=new Gizmo();  //Illegal--g is final
		g.spin();
	}
	void wihtout(Gizmo g) {
		g=new Gizmo();	//OK--g not final 
		g.spin();
	}
	void f(final int i) {
//		i++;
	}
//	You can only read from a final primitive
	int g(final int i) {
		return i+1;
	}
	public static void main(String[] args) {
		FinalArguments bf=new FinalArguments();
		bf.wihtout(null);
		bf.with(null);
	}
}
final修饰方法
  1. final修饰的方法不能子类被改写或覆盖
  2. final修饰的方法可以提升性能。不过通常，只有在方法的代码量非常少，或者想明确禁止方法被覆盖的时候，才应考虑将一个方法设为final。
  3. private方法都默认是final，也可为private方法添加final，但不会有额外的效果
final修饰类

final类不允许被继承。
当我们不想类做出任何改变，或出于安全方面的理由，不希望类被继承时可用final关键字
注意：

  • final类下的所有方法的是final的，与单个方法声明为final是相同的。
  • 可以为final下的方法添加final关键字，但那样做是没意义的
//Jurssic.java
//Making an entire class final
class SmallBrain {}

final class Dinosaur{
	int i=7;
	int j=1;
	SmallBrain x =new SmallBrain();
	void f() {}
}
//!class Further extends Dinosaur{} //Error:Cannot extend final class 'Dinosaur'
public class Jurassic {
 public static void main(String[] args) {
	Dinosaur n=new Dinosaur();
	n.f();
	n.i++;
	n.j++;
 }
}

9.初始化和类载入

通常，我们可认为除非那个类的一个对象构造完毕，
否则代码不会真的载入。由于 static 方法存在一些细微的歧义，所以也能认为“类代码在首次使用的时候载入”。
首次使用的地方也是static初始化发生的地方。装载的时候，所有static 对象和 static 代码块都会按照本
来的顺序初始化（亦即它们在类定义代码里写入的顺序）。当然，static 数据只会初始化一次。

继承初始化

我们有必要对整个初始化过程有所认识，其中包括继承，对这个过程中发生的事情有一个整体性的概念。请
观察下述代码：

//Beetle.java
//The full process of initialization
class Insect {
    static int x1 = prt("Static Insect.x1 initialized");
    int i = 9;
    int j;

    Insect() {
        prt("i=" + i + ",j=" + j);
        j = 39;
    }

    static int prt(String a) {
        System.out.println(a);
        return 47;
    }
}

public class Beetle extends Insect {
    int k = prt("Beetle.k initialized");

    Beetle() {
        prt("k=" + k);
        prt("j=" + j);
    }
    static int x2=prt("Static Beetle.x2 initialized");

      static int prt(String a) {
          System.out.println(a);
          return 63;
     }

    public static void main(String[] args) {
        prt("Beetle constructor");
        Beetle beetle=new Beetle();

    }
}

out:
Static Insect.x1 initialized
Static Beetle.x2 initialized
Beetle constructor
i=9,j=0
Beetle.k initialized
k=63
j=39
  1. 首先装载外部类（父类） ps如果java程序需要时
  2. 初始化父类Static 再是子类 static 依次类推
  3. 此时必要的类已装载完成，所以可以创建对象
  4. 这个对象中的所有基本数据类型都会设为默认值，而将对象句柄设为null
  5. 随后会调用父类构造方法（一般是自动调用的，也可以用super来自行指定构造函数）
  6. 父类构造方法完成以后，实例变量会按原来的顺序得以初始化
  7. 最后执行构造方法剩余的主体部分
来吟白雪篇
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java编程思想读书笔记.pdf
11-27
Java编程思想读书笔记.pdf
JAVA---类再生
不积跬步无以至千里，不积小流无以成江海
01-01 1050
复用代码是Java众多引人注目的功能之一。但要想成为极具革命性的语言，仅仅能够复制代码并对之加以改变是不够的，它还必须能够做更多的事情。 两种代码重用机制：组合和继承 1.组合语法  组合：将对象引用置于新类中  类中域为基本变量时能够自动被初始化为零。但是对象引用会被初始化为null  初始化引用，可以在代码中下列位置进行：   1.在定义对象的地方。这意味着它们总是能够在构造器之前
《Java编程思想》读书笔记一
程序员波特
05-10 784
  在美剧《硅谷》中有这样一个经典镜头，主人公 Richard 与同为开发工程师的女友闹分手，理由是两人对缩进方式有着截然不同的编程习惯，互相鄙视对方的代码风格。Richard 认为＂ one tab saves four spaces ”，缩进使用 Tab 键操作更快，更节省存 储空间，而女友坚持使用空格缩进，连续四次敲击空格的声音，把 Richard 折磨到几近崩溃，认为这是种精神折磨。 Richard 觉得难以相处，吵完架下楼梯时，不小心摔倒了 还淡定地说，"I just tried to go do
操作符——《Java编程思想》学习笔记
不想取名字
11-19 426
操作符1.优先级2.赋值方法调用中的别名问题3.算数运算符一元加,减操作符4.自动递增递减5.关系运算符测试对象的等阶性6.逻辑操作符短路7.直接常量指数计数法8.按位操作符9.移位运算符10.三元操作符 和 字符串操作符11.类型转换操作符 1.优先级 当表达式中存在多个操作符时,操作符的优先级就决定了各部分的计算顺序 优先级 操作符 说明 1 () 小括号 2 [] 中...
3.java成长之路——重读java编程思想03
zsxzmxg的博客
01-11 2761
不自觉的又加快了自己的阅读素的，老毛病了，总是一副不求甚解的样子。只不过连作者都说了这两章的素的可以快点，我也就不难为自己了 :D :P 第三章主要介绍了java的操作符。只不过上来提了个import static，不过本人相信很少人会这样用的。那咱就来聊聊操作符，首先当然是运算符了，无非是加减乘除和取模，除了String可以使用+外，加减乘除只能操作基本类型，当然包装类型的先有了一个拆箱的操作喽...
Java编程思想(第4版)读书笔记by CZF
06-14
Java编程思想(第4版)读书笔记by CZFJava编程思想(第4版)读书笔记by CZFJava编程思想(第4版)读书笔记by CZF
《Java编程思想》读书笔记1
08-03
第 1 章 对象导论1. 将类的一个对象置于某个新的类中，称为“创建一个成员对象”。2. 使用现有的类合成新的类，称为“组合”（composition），如果组
Java编程思想-笔记.docx
06-21
《java编程思想》学习笔记
《Java编程思想》第十章 内部类
01-20
本系列是我本人阅读java编程思想这本书的读书笔记，主要阅读第五章到第十七章以及第二十一章的内容，今天的笔记是第十章 java中有一种类叫内部类，这一章我们就来了解一下什么是内部类以及内部类的一些特性。 1.创建...
什么是yolov10，简单举例.md
最新发布
05-25
YOLOv10是一种目标检测算法，是YOLO系列算法的第10个版本。YOLO（You Only Look Once）是一种快速的实时目标检测算法，能够在一张图像中同时检测出多个目标。
shufflenet模型-图像分类算法对动态表情分类识别-不含数据集图片-含逐行注释和说明文档.zip
05-25
shufflenet模型_图像分类算法对动态表情分类识别-不含数据集图片-含逐行注释和说明文档 本代码是基于python pytorch环境安装的。 下载本代码后，有个环境安装的requirement.txt文本 如果有环境安装不会的，可自行网上搜索如何安装python和pytorch,这些环境安装都是有很多教程的，简单的 环境需要自行安装,推荐安装anaconda然后再里面推荐安装python3.7或3.8的版本，pytorch推荐安装1.7.1或1.8.1版本 首先是代码的整体介绍 总共是3个py文件，十分的简便 且代码里面的每一行都是含有中文注释的,小白也能看懂代码 然后是关于数据集的介绍。 本代码是不含数据集图片的，下载本代码后需要自行搜集图片放到对应的文件夹下即可 在数据集文件夹下是我们的各个类别,这个类别不是固定的，可自行创建文件夹增加分类数据集 需要我们往每个文件夹下搜集来图片放到对应文件夹下，每个对应的文件夹里面也有一张提示图，提示图片放的位置 然后我们需要将搜集来的图片，直接放到对应的文件夹下，就可以对代码进行训练了。 运行01生成txt.py,
该项目存放基于Cesium的三维GIS平台开发中各种实践程序、截图、总结等，其中程序目录结构
05-25
"GIS" 通常指的是 地理信息系统（Geographic Information System）。它是一种特定的空间信息系统，用于捕获、存储、管理、分析、查询和显示与地理空间相关的数据。GIS 是一种多学科交叉的产物，涉及地理学、地图学、遥感技术、计算机科学等多个领域。 GIS 的主要特点和功能包括： 空间数据管理：GIS 能够存储和管理地理空间数据，这些数据可以是点、线、面等矢量数据，也可以是栅格数据（如卫星图像或航空照片）。 空间分析：GIS 提供了一系列的空间分析工具，用于查询、量测、叠加分析、缓冲区分析、网络分析等。 可视化：GIS 能够将地理空间数据以地图、图表等形式展示出来，帮助用户更直观地理解和分析数据。 数据输入与输出：GIS 支持多种数据格式的输入和输出，包括数字线划图（DLG）、数字高程模型（DEM）、数字栅格图（DRG）等。 决策支持：GIS 可以为城市规划、环境监测、灾害管理、交通规划等领域提供决策支持。 随着技术的发展，GIS 已经广泛应用于各个领域，成为现代社会不可或缺的一部分。同时，GIS 也在不断地发展和完善，以适应更多领域的需求。
mobilenet模型-基于图像分类算法对猕猴桃品质识别-不含数据集图片-含逐行注释和说明文档.zip
05-25
mobilenet模型_基于图像分类算法对猕猴桃品质识别-不含数据集图片-含逐行注释和说明文档 本代码是基于python pytorch环境安装的。 下载本代码后，有个环境安装的requirement.txt文本 如果有环境安装不会的，可自行网上搜索如何安装python和pytorch,这些环境安装都是有很多教程的，简单的 环境需要自行安装,推荐安装anaconda然后再里面推荐安装python3.7或3.8的版本，pytorch推荐安装1.7.1或1.8.1版本 首先是代码的整体介绍 总共是3个py文件，十分的简便 且代码里面的每一行都是含有中文注释的,小白也能看懂代码 然后是关于数据集的介绍。 本代码是不含数据集图片的，下载本代码后需要自行搜集图片放到对应的文件夹下即可 在数据集文件夹下是我们的各个类别,这个类别不是固定的，可自行创建文件夹增加分类数据集 需要我们往每个文件夹下搜集来图片放到对应文件夹下，每个对应的文件夹里面也有一张提示图，提示图片放的位置 然后我们需要将搜集来的图片，直接放到对应的文件夹下，就可以对代码进行训练了。 运行01生成txt.py,
基于Postgres的Dockerfile，包含Postgis GIS扩展、Citus 集群扩展，可用于构建docker镜像
05-25
"GIS" 通常指的是 地理信息系统（Geographic Information System）。它是一种特定的空间信息系统，用于捕获、存储、管理、分析、查询和显示与地理空间相关的数据。GIS 是一种多学科交叉的产物，涉及地理学、地图学、遥感技术、计算机科学等多个领域。 GIS 的主要特点和功能包括： 空间数据管理：GIS 能够存储和管理地理空间数据，这些数据可以是点、线、面等矢量数据，也可以是栅格数据（如卫星图像或航空照片）。 空间分析：GIS 提供了一系列的空间分析工具，用于查询、量测、叠加分析、缓冲区分析、网络分析等。 可视化：GIS 能够将地理空间数据以地图、图表等形式展示出来，帮助用户更直观地理解和分析数据。 数据输入与输出：GIS 支持多种数据格式的输入和输出，包括数字线划图（DLG）、数字高程模型（DEM）、数字栅格图（DRG）等。 决策支持：GIS 可以为城市规划、环境监测、灾害管理、交通规划等领域提供决策支持。 随着技术的发展，GIS 已经广泛应用于各个领域，成为现代社会不可或缺的一部分。同时，GIS 也在不断地发展和完善，以适应更多领域的需求。
Go微服务教程项目使用领域驱动设计和洋葱架构.zip
05-25
Go微服务教程项目使用领域驱动设计和洋葱架构
Go编程语言.zip
05-25
Go编程语言
ipython-4.0.0b1.tar.gz
05-25
Python库是一组预先编写的代码模块，旨在帮助开发者实现特定的编程任务，无需从零开始编写代码。这些库可以包括各种功能，如数学运算、文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
Practice Go是Go编程挑战的集合.zip
05-25
Practice Go是Go编程挑战的集合
Java编程思想笔记
10-20
Java编程思想是一本经典的Java编程入门书籍，它详细介绍了Java编程语言的基础知识和高级特性，包括面向对象编程、异常处理、泛型、集合框架、多线程、网络编程等方面的内容。这本书的作者Bruce Eckel是一位Java编程...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值