Java中的重载、可变参数、作用域、构造器

已于 2024-02-29 17:30:56 修改
阅读量249 收藏
点赞数 2
分类专栏： JavaSE 文章标签： java
于 2022-07-02 22:47:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45395059/article/details/125570988
版权

目录

前言

  • 本文分享了方法重载、可变参数、变量的作用域、构造器这些知识，是博主在学习了网课后，结合自己的理解总结整理处理的。
  • 本文是面向对象编程（基础）的第2部分，如果有些小伙伴对本文中的一些内容，如，内存分配机制的示意图…不是很理解的话，可以去第1部分的博文看看，那里写的很详细。

一、方法重载

  • java 中允许同一个类中，多个同名方法的存在，但要求这些同名方法的形参列表不一致。 比如：System.out.println()方法，可以传入各种数据类型的实参，并且传入实参个数没有限制，如果不使用方法重载，我们就需要创建多个方法才能实现这些功能。
  • 重载的好处：
  1. 减轻了起名的麻烦；
  2. 减轻了记名的麻烦；

1. 快速入门

  • 举例入门：

在MyCalculator 类中，实现用相同的方法名calculate，可以计算：

  1. 两个整数的和
  2. 一个整数，一个double的和
  3. 一个double ,一个Int和
  4. 三个int的和
  • 代码如下：

public class OverLoad01 { 

	//编写一个main方法
	public static void main(String[] args) {

		MyCalculator mc = new MyCalculator();
		System.out.println(mc.calculate(1, 2));
		System.out.println(mc.calculate(1.1, 2));
		System.out.println(mc.calculate(1, 2.1));
		System.out.println(mc.calculate(1, 2, 3));
	}
}

class MyCalculator  {

	//下面的四个 calculate方法构成了重载
	
	//两个整数的和
	public int calculate(int n1, int n2)  {
		System.out.println("calculate(int n1, int n2) 被调用");
		return n1 + n2;
	}

	//一个整数，一个double的和
	public double calculate(int n1, double n2) {
		return n1 + n2;
	}
	
	//一个double ,一个Int和 
	public double calculate(double n1, int n2) {
		System.out.println("calculate(double n1, int n2) 被调用..");
		return n1 + n2;
	}
	
	//三个int的和
	public int calculate(int n1, int n2,int n3) {
		return n1 + n2 + n2;
	}
}
  • 说明：若是没有使用方法重载，则要分别给这四个方法重新命名，而重载则可以减少命名的麻烦。

2. 注意事项和使用细节

  1. 方法名必须相同：构成重载的方法它们的方法名必须相同。
  2. 形参列表必须不同：构成重载的方法，它们的形参类型、个数、顺序，这三者中必须至少有一种和其他的不同；
  3. 参数名无影响：形参的命名可以相同也可以不同，不是决定方法重载的因素；
  4. 方法返回类型无影响：方法的返回类型可以相同也可以不同，不是决定方法重载的因素；
  • 举例如下：
    在这里插入图片描述

二、可变参数

  • 引入可变参数：在上面的方法重载中，我们举例了分别计算两个int 类型和三个int 类型变量和的方法 calculate ；这两个方法除了形参个数不同外其他都是相同的。那我们是否可以采用一种机制，将同一个类中多个同名同功能但参数个数不同的方法，封装成为一个方法呢？这时可变参数便出现了。
  • java 允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。 这个机制通过可变参数实现。

1. 基本语法

  • 访问修饰符 返回类型 方法名(数据类型… 形参名) { 方法体 }
  • 注意：数据类型后面是有（…）跟着的。

看一个案例： 创建一个类 HspMethod，创建方法 sum，【可以计算 2 个数的和，3 个数的和，…，n个数的和】。

  • 代码如下：

public class VarParameter01 { 
	//编写一个main方法
	public static void main(String[] args) {

		HspMethod m = new HspMethod();
		System.out.println(m.sum(1, 5, 100)); //106
		System.out.println(m.sum(1,19)); //20
	}
}

class HspMethod {
	//计算 2个数的和，3个数的和，...，n个数的和。
	
	/*
	可以使用方法重载，但是要重复创建很多个重构方法；
	public int sum(int n1, int n2) {
		//2个数的和
		return n1 + n2;
	}
	public int sum(int n1, int n2, int n3) {
		//3个数的和
	 	return n1 + n2 + n3;
	}
	public int sum(int n1, int n2, int n3, int n4) {
		//4个数的和
	 	return n1 + n2 + n3 + n4;
	}
	上面的三个方法名称相同，功能相同, 参数个数不同-> 使用可变参数优化
	*/
	
	// 可变参数：
	//1. int... 表示接受的是可变参数，类型是int ,即可以接收多个int(0-多) ；
	//2. 使用可变参数时，可以当做数组来使用 即 nums 可以当做数组；
	//3. 遍历 nums， 求和即可。
	public int sum(int... nums) {
		int res = 0;
		for(int i = 0; i < nums.length; i++) {
			res += nums[i];
		}
		return res;
	}
}

2. 注意事项和使用细节

  • 细节如下：
    在这里插入图片描述
  • 解释:
  1. 可变参数，其实int… == int[]，可变参数就是数组，传参机制为引用传递；
  2. 传参给可变参数时，实参传入一个对应数据类型的数组或者是多个对应数据类型的变量都可以；
  • 举例说明：

有三个重载方法，分别实现返回姓名和两门课成绩(总分)， 返回姓名和三门课成绩(总分)，返回姓名和五门课成绩（总分）。将它们封装成一个可变参数的方法。


public class VarParameterExercise { 
	public static void main(String[] args) {
		HspMethod hm = new HspMethod();
		System.out.println(hm.showScore("milan" , 90.1, 80.0 ));
		System.out.println(hm.showScore("terry" , 90.1, 80.0,10,30.5,70 ));
	}
}

class HspMethod  {
	//分析 1. 方法名 showScore；  2. 形参(String ,double... )； 3. 返回类型 String

	public String  showScore(String name ,double... scores) {

		double totalScore = 0;
		for(int i = 0; i < scores.length; i++) {
			totalScore += scores[i];
		}
		return name + " 有 " + scores.length + "门课的成绩总分为=" + totalScore;
	}
 }

三、变量作用域

1. 基本概念

  • 基本概念：
    在这里插入图片描述
  • 代码说明：

public class VarScope { 
	public static void main(String[] args) {
	}
}

class Cat {
	// 全局变量：也就是属性，作用域为整个类体 即Cat类，cry、eat 等方法可以使用属性；
	// 属性在定义时，可以直接赋值；
	int age = 10; //指定的值是 10

	//全局变量(属性)可以不赋值，直接使用，因为有默认值；
	double weight;  // 默认值是0.0

	public void hi() {
		//局部变量必须赋值后，才能使用，因为没有默认值；
		int num = 1;
		String address = "北京的猫";
		System.out.println("num=" + num);//局部变量
		System.out.println("weight=" + weight);//属性
	}
	
	public void cry() {
		//1. 局部变量一般是指在成员方法中定义的变量；
		//2. n 和  name 就是局部变量；
		//3. n 和 name的作用域在 cry方法中；
		int n = 10;
		String name = "jack";
		System.out.println("在cry中使用属性 age=" + age);
	}

	public void eat() {

		System.out.println("在eat中使用属性 age=" + age);
		//System.out.println("在eat中使用 cry的变量 name=" + name);//错误
	}
}

2. 注意事项和使用细节

  • 细节如下：
  1. 生命周期不同：
    属性生命周期较长，伴随着对象的创建而创建，伴随着对象的销毁而销毁。 局部变量，生命周期较短，伴随着它的代码块的执行而创建， 伴随着代码块的结束而销毁。即在一次方法调用过程中;
  2. 作用域范围不同：
    全局变量/属性：可以被本类使用，或其他类使用（通过对象调用);
    局部变量：只能在本类中对应的方法中使用；
  3. 修饰符不同：
    属性可以加修饰符(public protected private…)；局部变量不能加修饰符；
  4. 命名规则：
    属性和局部变量可以重名，访问同名的属性和局部变量时遵循就近原则；在同一个作用域中，比如在同一个成员方法中，两个局部变量不能重名。
  • 代码说明：

public class VarScopeDetail { 
	public static void main(String[] args) {
		Person p1 = new Person();
		/* 细节1：
		属性生命周期较长，伴随着对象的创建而创建，伴随着对象的销毁而销毁。
		局部变量生命周期较短，伴随着它的代码块的执行而创建，
		伴随着代码块的结束而销毁。即在一次方法调用过程中
		*/
		// p1.say(); 当执行say方法时，say方法的局部变量比如name,会创建；
		// 当say执行完毕后，name局部变量就销毁,但是p1的属性(全局变量)仍可以使用；
		
		// 细节2：属性：可以被本类使用，或其他类使用（通过对象调用)；
		T t1 = new T();
		t1.test(); // 第1种跨类访问对象属性的方式
		t1.test2(p1);//第2种跨类访问对象属性的方式
	}
}

class T {
	// 细节2：属性：可以被本类使用，或其他类使用（通过对象调用)；
	public void test() {
		// 创建一个Person 类的对象p1，可以使用p1调用Person类的属性
		Person p1 = new Person();
		System.out.println(p1.name);// 输出 jack
	}
		
	// 传入一个Person类对象的实参给方法test2 ，
	// 当调用test2 方法时，便可以访问Person 类的属性；	
	public void test2(Person p) {
		System.out.println(p.name);// 输出 jack
	}
}

class Person {
	// 细节3: 属性可以加修饰符(public protected private..)；
	// 局部变量不能加修饰符；
	public int age = 20;
	String name = "jack";

	public void say() {
		// 细节4： 属性和局部变量可以重名，访问时遵循就近原则；
		String name = "king";
		System.out.println("say() name=" + name);// 输出的是最近的name的值
	}

	public void hi() {
		// 细节4：在同一个作用域中，两个局部变量不能重名；
		String address = "北京";
		// String address = "上海";// 错误,重复命名
		String name = "hsp";// 可以
	}
}

四、构造器/构造方法

  • 我们来看一个需求：前面我们在创建人类的对象时，是先把一个对象创建好后，再给他的年龄和姓名属性赋值；
  • 如果现在要求，在创建人类的对象时，就直接指定这个对象的年龄和姓名，该怎么做? 这时就可以使用构造器。

1. 基本概念

  • 构造方法又叫构造器(constructor)，是类的一种特殊的方法，它的主要作用是完成对新创建对象的初始化。它有几个特点：
  1. 方法名和类名相同;
  2. 没有返回值;
  3. 在创建对象时，系统会自动的调用该类的构造器完成对象的初始化。
  • 基本语法：[修饰符] 方法名(形参列表) { 方法体; }
  • 说明：

1)构造器的修饰符可以默认， 也可以是 public ，protected ，private ；
2)构造器一定没有返回值 ；
3)方法名 和 类名字必须一样 ；
4)参数列表 和 成员方法使用一样的规则；
5)构造器的调用, 由系统自动完成，使用者不能主动调用构造器。

现在我们用构造方法来完成刚才提出的问题：在创建人类的对象时，就直接指定这个对象的年龄和姓名。

  • 代码如下：

public class Constructor01 { 
	public static void main(String[] args) {
		//当我们new 一个对象时，直接通过构造器指定名字和年龄
		Person p1 = new Person("smith", 80);
		System.out.println("p1的信息如下");
		System.out.println("p1对象name=" + p1.name);//smith
		System.out.println("p1对象age=" + p1.age);//80
	}
}

//在创建人类的对象时，就直接指定这个对象的年龄和姓名
//
class Person {
	String name;
	int age;
	//构造器
	//1. 构造器没有返回值, 也不能写void
	//2. 构造器的名称和类Person一样
	//3. (String pName, int pAge) 是构造器形参列表，规则和成员方法一样
	public Person(String pName, int pAge) {
		System.out.println("构造器被调用~~ 完成对象的属性初始化");
		name = pName;
		age = pAge;
	}
}

2. 注意事项和使用细节

  • 如下图所示：

在这里插入图片描述
在这里插入图片描述

  • 代码说明：

public class ConstructorDetail { 
	public static void main(String[] args) {
		Person p1 = new Person("king", 40);//第1个构造器
		Person p2 = new Person("tom");//第2个构造器
		//Person p2 = new Person(); 不能使用默认的无参构造器，因为被覆盖了

		Dog dog1 = new Dog();// 可以使用默认的无参构造器，因为显式地重新定义了

	}
}

class Dog {
	//如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造器(也叫默认构造器)
	/*
		默认构造器
		Dog() {
			
		}
	*/
	//一旦定义了自己的构造器,默认的构造器就覆盖了，就不能再使用默认的无参构造器，
	//除非显式的定义一下,即:  Dog(){}  写 (这点很重要)

	public Dog(String dName) {
		//...
	}

	//显式的定义无参构造器，才能使用；
	Dog() {}
}

class Person {
	String name;
	int age;//默认0

	//第1个构造器
	public Person(String pName, int pAge) {
		name = pName;
		age = pAge;
	}

	//第2个构造器, 只指定人名，不需要指定年龄
	public Person(String pName) {
		name = pName;
	}
}

五、对象创建的流程分析（重要！）

  • 举例分析：
    在这里插入图片描述
  • 解释：
  1. new Person(“小倩”, 20); 首先在方法区中加载了Person类的信息，只会加载一次；
  2. 其次在堆内存中开辟了一个内存空间（地址），这个内存空间是真正的对象；
  3. 接着进行对象的初始化，分为3步：
    （1）默认初始化，此时对象的各个属性的值都是默认值，上例中 age = 0，name = null；
    （2）显式初始化，此时给对象的各个属性赋值，赋的值为类中声明属性时的初始值，上例中 age = 90，name = null；
    （3）构造器初始化，此时调用构造器，给对象的各属性赋值，赋的值为创建对象时传入的参数，上例中 age = 20，name = “小倩”。
  4. 完成对象的初始化后，最后将对象的堆空间的地址，返回给栈空间中的对象名 p，此时 p 就可以引用该对象（堆内存空间）了。
  • 流程示意图如下：（有些潦草）

在这里插入图片描述

六、this 关键字

1. 基本概念

  • 什么是this ：Java虚拟机会给每个对象分配this，用来代表当前对象。

假设我们创建了一个 Dog 类，并在里面定义构造器和一些方法，看下图案例，分析this 的内存机制。
在这里插入图片描述

  • 内存分析示意图：
    在这里插入图片描述
  • 解释：
  • this 关键字，本质是对象在其堆内存空间中隐式地创建了一个引用类型变量 this，然后将自身的内存地址赋值给了 this；简而言之，this 就是该对象的内存空间内的对象名。
  • 举例：有一个孩子，他的父母给他取名为小明，而这个孩子在和别人交流时，会自称“我”；这个孩子就是一个人类对象，小明就是对象名，而“我” 就相当于 this。

2. 注意事项和使用细节

  • 细节如下：
  1. this 关键字只能用来访问本类的属性、方法、构造器；
  2. this 用于区分本类的属性和局部变量；
  3. 访问本类成员方法的语法：this.方法名(参数列表)；
  4. 访问本类构造器语法：this(参数列表)；注意该语句只能在构造器中使用(即只能在构造器中访问另外一个构造器，而且必须放在第一条语句)，不能在普通方法中访问构造器；作用是在一个构造器中调用另一个构造器去初始化对象。
  5. this 不能在类定义的外部使用，只能在类定义的方法中使用。

总结

本文是小白博主在学习B站韩顺平老师的Java网课时整理的学习笔记，在这里感谢韩顺平老师的网课，如有有兴趣的小伙伴也可以去看看。

林二月er
关注
专栏目录
Java 类与对象 -- Java 语言的类与对象、构造器、static、final、包和 JAR
栗筝i的博客
06-11 3664
本篇文章我们将深入了解 Java 语言中的类与对象，探讨构造器、`static`、`final`、包和 JAR 文件。这些概念是面向对象编程的核心，对于理解和掌握 Java 至关重要。
【Java基础知识 1】Java入门级概述
热门推荐
学Java，找哪吒
09-25 15万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
Java面向对象编程---基础篇
技术专家
11-04 633
面向对象介绍 ⚫ 并不是一个技术，而是一种编程指导思想。 ⚫ 把现实世界的具体事物全部看成一个一个的对象来解决实际问题。 为什么要用面向对象编程 ⚫ 生活中我们解决问题就是按照对象化的方式进行的。如果程序也能够按照生活的中的方式来解决问题，那么程序就更符合人类的思维习惯，代码看起来会更易理解、更简单、更易维护。
Java可变参数方法重载时要注意的几个问题
心梦帆影Java技术博客
04-01 289
JDK1.5引进了方法的可变参数，受到许多开发人员的青睐。有了这种机制，我们可以写出类似于JavaScript的arguments那样的带任意多个参数的方法。Java的可变参数，可用于普通方法上，也可以用于构造方法上，大大增大了我们所写方法的适用范围。 然而，使用可变参数时，要注意几个问题：   1) 可变参数方法与数组参数方法重载时   public class MethodParam...
Java基础--继承、构造器、重载重写
最新发布
a13641376265的博客
08-23 867
在扫描b，发现b的父类为a，在扫描a（a无父类），将a编译进入方法区，在将b编译调入。重写（Override）是指子类定义了一个与其父类中具有相同名称、参数列表和返回类型的方法，并且子类方法的实现覆盖了父类方法的实现。2、一个类可以被多个类当父亲（一个父类可以有多个子类），但是一个子类只能有一个父类（父亲唯一），（java仅支持单继承）继承的本质就是代码的复用，子类可以使用父类的代码，而子类是不能调用父类的代码。2、在类中有一个默认不显示的无参数的构造器，一旦你在类中写了一个构造器，无参构造器就会被覆盖。
Java面向对象
StartOn2020的博客
04-28 163
面向对象编程 核心思想是OOP 1.初识面向对象 面向对象思想 面向过程思想（线性） 步骤清晰简单。第一步…第二步… 适合处理一些较简单的问题 面向对象思想 分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索 适合处理复杂的问题，适合处理需要多人协作的问题 对于描述复杂的事物，为了从宏观上把握、从整体合理...
Java基础03 构造器与方法重载
weixin_33920401的博客
03-26 113
作者：Vamei 出处：http://www.cnblogs.com/vamei 欢迎转载，也请保留这段声明。谢谢！   在方法与数据成员中，我们提到，Java中的对象在创建的时候会初始化(initialization)。初始化时，对象的数据成员被赋予初始值。我们可以显式初始化。如果我们没有给数据成员赋予初始值，数据成员会根据其类型采用默认初始值。 显式初始化要求我们在写程序时就确定初始值，...
Java面向对象编程基础详解（Java必备知识）
怪咖@的博客
03-03 1288
Java是面向对象的编程语言，类与对象是面向对象编程的重要概念，实质上可以将类看作是对象的载体，它定义了对象所具有的属性和行为。 目录 面向对象概述 类与对象 static关键字 类的主方法 ...
可变参数、作用域、构造器
努力笨小孩的博客
11-04 266
一、可变参数：有多个方法，他们的本质操作是一样的，只是传参个数不定，这时候可以用可变参数，比如：一个方法是求两个整数的和，另一个方法是求三个整数的和 （1）“类型...”，如"int... nums"表示接收的是可变参数，类型是int，即可以传入0个或多个int型实参 （2）实参可以是数组（这里的数组是可变形参类型的数组） （3）可变参数的本质就是数组 （4）可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后 （5）一个形参列表中只能出现一个可变参数 public clas
Java学习----构造器和继承
hanxuya的博客
07-21 306
继承就是在已经存在的类的基础上进行扩展，从而产生新的类，支持了层次结构分类的概念。已经存在的类称为父类、超类或基类，而新产生的类称为子类或派生类。多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。多个类可以称为子类，单独这个类称为父类或者超类。通过extends关键字让类与类之间产生继承关系继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。}...
Python函数重载与可变参数：设计灵活的函数接口
在编程中，函数是组织代码的基本结构，而函数重载和可变参数是函数设计中重要的概念。函数重载是指在相同的作用域内，允许存在一个以上的同名函数，只要它们的参数列表不同。这一特性在静态类型语言如Java、C++中...
Java构造器的重载
SAITWATERLaKE的博客
11-09 615
package com.pyk; //构造器的重载 //定义一个”人“类 public class Person { //属性 String name; int age; double heigth; //空构造器(一般保证空构造器的存在，空构造器一般不会进行属性的赋值操作) public Person() { } //重载构造器，一般会重载构造器，在重载的构造器中进行属性的赋值操作 public Person(String name,int age,double heigth) .
详解Java面向对象编程
小诸葛的博客
11-18 857
面向对象（OOP）指的是一种基于对象的编程方法论，而不仅仅是方法和函数编程。对象包含数据和方法（也叫行为）。 在面向对象编程（OOP）概念中，我们会学到四种主要的法则——抽象、封装、继承、多态。这四条准则也就是众所周知的面向对象编程范式的四大支柱。 抽象是对实体本质细节的揭露、同时忽略无关紧要的细节、从而降低开发人员开发的复杂度的过程； 封装是将数据和操作和实体对象绑定在一起的过程； 继承用于根据一个已有的类型派生出一个新类型，同时在它们之间建立了一个父子的关系； 多态使得实体在不同的上下文中可以
Java面向对象编程详解
dddddrrrzz的博客
11-13 1521
目录一、包1.1静态导入1.2将类放到包中1.3包的访问权限控制二、继承2.1 super关键字super与this的区别2.2 protected 关键字Java 中对于字段和方法共有四种访问权限2.3 final 关键字三、组合四、多态4.1向上转型4.2 动态绑定重载和重写的区别4.3 向下转型4.4 理解多态五、抽象类六、接口实现多个接口三个常用的接口`Comparable``Comparator``Cloneable` 一、包 包(package) 是组织类的一种方式，使用包的主要目的是保证类的
Java基础篇——面向对象编程
尘的学习记录
08-11 1294
面向对象并不是一个技术，而是一种编程指导思想。它把现实世界的具体事物全部看成一个一个对象来解决问题。我们为什么要使面向对象编程呢？生活中我们解决问题就是按照对象化的方式进行的。如果程序也能按照生活中的方式来解决问题，那么程序就更符合人类的思维习惯，代码看起来会更易理解、更简单。获取已有对象并使用// 1、得到一个随机数对象，用于得到随机数// 生成 1-10之间的随机数// 2、创建一个扫描器对象，用于接收用户输入的数据System.out.println("请您输入您的年龄：");...
Java
u014256034的专栏
03-21 299
Java是基于面向对象概念的语言，允许在更高抽象层次上解决现实问题j。面向对象的方法是以概念化现实世界中的对象方式解决问题，能够更容易跨应用程序重用。对象例如椅子，电风扇，狗，计算机等。 　　在Java中，一个类是一个蓝图或一个模板或一个原型，定义的是相同类型对象的共同行为。一个实例是一个特定类的实现，类的所有实例都具有相似在类定义中描述的属性。例如，你可以定义一个类叫做房子，房间号码作为其属性
java Vamei快速教程03 构造器和方法重载
10-27 85
作者：Vamei 出处：http://www.cnblogs.com/vamei 欢迎转载，也请保留这段声明。谢谢！ 在方法与数据成员中，我们提到，Java中的对象在创建的时候会初始化(initialization)。初始化时，对象的数据成员被赋予初始值。我们可以显式初始化。如果我们没有给数据成员赋予初始值，数据成员会根据其类型采用默认初始值。 显式初始化要求我们在写程序时就确...
JAVA 面向对象编程(基础)
weixin_54778787的博客
03-12 152
JAVA 面向对象的基础概念，包含类与对象，成员方法，方法重载，可变参数，作用域，构造方法，对象创建流程，this关键字的介绍
Java面向对象编程（基础）
weixin_52795571的博客
03-08 507
Java面向对象编程（OOP） 1.初识面向对象 1.1 面向过程 步骤清晰简单，第一步做什么，第二步做什么… 面对过程适合处理一下简单问题 1.2 面向对象思维 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些类，然后对这些类进行单独思考，最后，才对某个分类下的细节进行面向过程思考 面向对象适合处理复杂的问题，适合处理需要多人协作的问题！ 1.3 什么是面向对象 本质：以类的方式组织代码，以对象的组织（封装）数据 抽象 三大特性：封装，继承，多态 对于描述复杂的事物，为了从宏观上把握，
Java中的InetAddress类与网络通信
成员变量和局部变量有各自的生命周期和作用域，方法是类的行为体现，可以有重载（即相同名称但参数列表不同的方法）。构造方法用于初始化新创建的对象，而静态关键字（STATIC）定义的成员变量和方法属于类本身，而...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

林二月er

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值