1.2.2方法和封装

最新推荐文章于 2023-07-01 00:26:00 发布
最新推荐文章于 2023-07-01 00:26:00 发布
阅读量80 收藏
点赞数
分类专栏： java笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cyuluo69582/article/details/112760298
版权

方法和封装

构造方法

构造方法的基本概念

class类名{
类名(形参列表) {构造方法体;
}
}
class Person {
Person() { ~Person类中的构造方法
}
}
构造方法名与类名完全相同并且没有返回值类型，连void都不许有。

默认构造方法

当一个类中没有定义任何构造方法时，编译器会自动添加一个无参空构造构造方法，叫做默认/缺省构造方法，如：Person(){}
若类中出现了构造方法，则编译器不再提供任何形式的构造方法。

构造方法的作用

使用new关键字创建对象时会自动调用构造方法实现成员变量初始化工作。

/*
    编程实现Person类的定义
 */
public class Person {
	
	String name; // 用于描述姓名的成员变量
	int age;     // 用于描述年龄的成员变量
	
	// 自定义构造方法
	// String s = "张飞";
	// int i = 30;
	// String s = "关羽";
	// int i = 35;
	// 就近原则  懒人原则  
	Person(String name, int age) {
		//System.out.println("我就是自定义的构造方法！");
		//name = "张飞";
		//age = 30;
		this.name = name;
		this.age = age;
	}
	// 自定义无参构造方法
	Person() {
	}
	
	// 自定义成员方法实现所有特征的打印  隐含着this关键字,this关键字代表当前正在调用的对象
	// Person this = p1;   this.name = p1.name = 张飞
	// Person this = p2;   this.name = p2.name = 关羽
	void show() {
		// 每当打印成员变量的数值时，让年龄增长一岁
		//this.grow();
		//grow();
		//System.out.println("我是" + this.name + "，今年" + this.age + "岁了！");
		System.out.println("我是" + name + "，今年" + age + "岁了！");
	}
	// 自定义成员方法实现年龄增长一岁的行为
	void grow() {
		age++;
	}
	// 自定义成员方法实现年龄增长参数指定数值的行为
	void grow(int age) {
		this.age += age;
	}
	// 自定义成员方法实现Person类型对象的获取并返回的行为
	//String getName(){}
	Person getPerson() {
		// 返回当前调用对象本身  Person tp = new Person();  return tp;
		return this;
	} 
	
	public static void main(String[] args) {
		
		// 1.声明一个Person类型的引用指向Person类型的对象
		// 当类中没有提供构造方法时，则下面调用默认构造方法，若类中提供构造方法后，则下面调用类中提供的版本
		Person p1 = new Person("张飞", 30);
		// 并打印特征
		p1.show();  // null 0  张飞  30
		
		Person p2 = new Person("关羽", 35);
		p2.show();  // 关羽 35
		
		Person p3 = new Person();
		p3.show(); // null 0
		
		System.out.println("----------------------------------------------------");
		// 2.实现重载方法的调用和测试
		p1.grow();
		p1.show(); // 张飞 31
		p1.grow(3);
		p1.show(); // 张飞 34
		
		System.out.println("----------------------------------------------------");
		// 3.调用成员方法获取对象
		Person p4 = p1.getPerson();
		System.out.println("p1 = " + p1);
		System.out.println("p4 = " + p4);
		
	}
}

案例题目（Point类构造）

编程实现Point类的定义并向Point类添加构造方法Point()默认创建原点对象Point(int i,int j)根据参数创建点对象

/*
    编程实现Point类的定义
 */
public class Point {
	
	int x; // 用于描述横坐标的成员变量
	int y; // 用于描述纵坐标的成员变量
	
	// 自定义无参构造方法
	Point() {}
    // 自定义有参构造方法
    Point(int x, int y) {
		this.x = x;
		this.y = y;
	}	
	
	// 自定义成员方法实现特征的打印
	void show() {
		System.out.println("横坐标是：" + x + "，纵坐标是：" + y);
	}
	// 自定义成员方法实现纵坐标减1的行为
	void up() {
		y--;
	}
	// 自定义成员方法实现纵坐标减去参数指定数值的行为
	void up(int y) {
		this.y -= y;
	}
	
	public static void main(String[] args) {
		
		// 1.使用无参方式构造对象并打印特征
		Point p1 = new Point();
		p1.show(); // 0 0
		
		// 2.使用有参方式构造对象并打印特征
		Point p2 = new Point(3, 5);
		p2.show(); // 3 5
		
		System.out.println("------------------------------------");
		// 3.调用重载的成员方法
		p2.up();
		p2.show(); // 3 4
		p2.up(2);
		p2.show(); // 3 2
	}
}

方法重载（重点）

方法重载的概念

若方法名称相同，参数列表不同，这样的方法之间构成重载关系(Overload)。

重载的体现形式

方法重载的主要形式体现在：参数的个数不同、参数的类型不同、参数的顺序不同，与返回值类型和形参变量名无关，但建议返回值类型最好相同。
判断方法能否构成重载的核心：调用方法时能否加以区分。

/*
    编程实现方法重载主要形式的测试
*/
public class OverloadTest {
	
	//自定义成员方法
	void show() {
		System.out.println("show()");
	}
	void show(int i) { //ok  体现在方法参数的个数不同
		System.out.println("show(int)");
	}
	void show(int i,double d) { //OK  体现在方法参数的个数不同
		System.out.println("show(int,double)");
	}
	void show(int i,int j) { //ok   体现在犯法参数的类型不同
		System.out.println("show(int,int)");
	}
	void show(double d,int i) { //ok   体现在方法参数的顺序不同
		System.out.println("show(double.int)");
	}
	// void show(double a,int b) { //error  与参数变量名无关
		// System.out.println("show(double,int)");
	// }
	
	// int show(double a,int b) { //error  与返回值类型无关
		// System.out.println("show(double,int)");
	// }
	
	
	
	public static void main(String[] args) {
		
		//1.声明OverloadTest；类型的引用指向该类型的对象
		OverloadTest ot = new OverloadTest();
		//2.嗲用showfangfa
		ot.show();
		ot.show(66);
		ot.show(66,3.14);
		ot.show(66,118);
		ot.show(3.14,118);
		//ot.show(3.14,66);
	}
}

练习题目

编程实现为Point类添加重载的成员方法：
up()–实现纵坐标减1的功能。
up(intdy)–实现纵坐标减去参数指定数值的功能。
测试重载方法的调用规则

重载的实际意义

方法重载的实际意义在于调用者只需要记住一个方法名就可以调用各种不同的版本，来实现各种不同的功能。
如：java.io.PrintStream类中的println方法。

this关键字（原理）

this的基本概念

若在构造方法中出现了this关键字，则代表当前正在构造的对象。
若在成员方法中出现了this关键字，则代表当前正在调用的对象。
this关键字本质上就是当前类类型的引用变量。
成员方法中直接访问成员变量是因为有隐藏的this.

/*
    编程实现this关键字的使用
 */
public class ThisTest {
	
	// 自定义构造方法
	ThisTest() {
		// this代表当前正在构造的对象
		System.out.println("构造方法中：this = " + this);
	}
	// 自定义成员方法
	void show() {
		// this代表当前正在调用的对象
		System.out.println("成员方法中：this = " + this);
	}
	
	public static void main(String[] args) {
		
		// 1.声明ThisTest类型的引用指向该类型的对象
		ThisTest tt = new ThisTest();
		// 2.调用show方法
		tt.show();
		System.out.println("main方法中：tt = " + tt);
		
		
		
	}
}

工作原理

在构造方法中和成员方法中访问成员变量时，编译器会加上this.的前缀，而this.相当于汉语中"我的"，当不同的对象调用同一个方法时，由于调用方法的对象不同导致this关键字不同，从而this.方式访问的结果也就随之不同。

使用方式

  • 当局部变量名与成员变量名相同时，在方法体中会优先使用局部变量(就近原则)，若希望使用成员变量，则需要在成员变量的前面加上this.的前缀，明确要求该变量是成员变量（重中之重）。
  • this关键字除了可以通过this.的方式调用成员变量和成员方法外，还可以作为方法的返回值（重点）。
  • 在构造方法的第一行可以使用this()的方式来调用本类中的其它构造方法（了解）。
    返回当前调用对象本身
Person getPerson() {
    return this;
}

注意事项
引用类型变量用于存放对象的地址，可以给引用类型赋值为null，表示不指向任何对象。
当某个引用类型变量为null时无法对对象实施访问（因为它没有指向任何对象）。此时，如果通过引用访问成员变量或调用方法，会产生NullPointerException异常。

/*
    编程实现Boy类的定义
 */
public class Boy {
	
	String name; // 用于描述姓名的成员变量
	
	// 自定义构造方法
	Boy() {
		// 调用本类中的有参构造方法
		//this("无名");
		System.out.println("无参构造方法！");
	}
	Boy(String name) {
		// 调用本类中的无参构造方法
		this();
		System.out.println("=========有参构造方法！");
		this.name = name;
	}
	// 自定义成员方法实现特征的打印
	void show() {
		System.out.println("我的名字是：" + name);
	}
	
	public static void main(String[] args) {
		
		// 1.使用无参方式构造对象并打印特征
		Boy b1 = new Boy();
		b1.show(); // null
		
		System.out.println("-----------------------------------");
		// 2.使用有参方式构造对象并打印特征
		Boy b2 = new Boy("张飞");
		b2.show(); // 张飞
		
		System.out.println("-----------------------------------");
		// 3.引用变量的数值可以为空
		//Boy b3 = null;
		//b3.show(); // 编译ok，运行会发生NullPointerException空指针异常   算术异常、数组下标越界异常
		Boy b3 = b2;
		b3.show(); // 张飞
	}
}

方法递归调用

案例题目（n的阶乘）
编程实现参数n的阶乘并返回，所谓阶乘就是从1累乘到n的结果。

/*
    编程实现累乘积的计算并打印
 */
public class JieChengTest {
	
	// 自定义成员方法实现将参数n的阶乘计算出来并返回
	// 1! = 1;     2! = 1*2;   3! = 1*2*3;   ...   n! = 1*2*3*...*n;
	int show(int n) { // int n=5; int n = 4; int n = 3; int n = 2;  int n = 1;
		// 递推的方式 
		/*
		int num = 1;
		for(int i = 1; i <= n; i++) {
			num *= i;
		}
		return num;
		*/
		/*
		    5! = 5 * 4 * 3 * 2 * 1;
			4! = 4 * 3 * 2 * 1;
			3! = 3 * 2 * 1;
			2! = 2 * 1;
			1! = 1;
			
			5! = 5 * 4!;
			4! = 4 * 3!;
			3! = 3 * 2!;
			2! = 2 * 1!;
			1! = 1;
			
			n! = n * (n-1)!;
		  
		*/
		// 递归的方式
		// 当n的数值为1时，则阶乘的结果就是1
		/*
		if(1 == n) {
			return 1;
		}
		*/
		if(1 == n) return 1;
		// 否则阶乘的结果就是 n*(n-1)!
		return n*show(n-1);
		// show(5) => return 5*show(4); => 120
		// show(4) => return 4*show(3); => 24 
		// show(3) => return 3*show(2); => 6
		// show(2) => return 2*show(1); => 2
		// show(1) => return 1;         => 1
	}
	
	public static void main(String[] args) {
		
		// 1.声明JieChengTest类型的引用指向该类型的对象
		JieChengTest jct = new JieChengTest();
		// 2.调用方法进行计算并打印
		int res = jct.show(5);
		System.out.println("最终的计算结果是：" + res); // 120
	}
}

递归的基本概念

递归本质就是指在方法体的内部直接或间接调用当前方法自身的形式。
注意事项

  • 使用递归必须有递归的规律以及退出条件。
  • 使用递归必须使得问题简单化而不是复杂化。
  • 若递归影响到程序的执行性能，则使用递推取代之。

案例题目（费氏数列）

编程实现费式数列中第n项的数值并返回。
费式数列：1 1 2 3 5 8 13 21 ……

/*
    编程实现费氏数列的计算并打印  功能类/封装类
 */
public class Fee {
	
	// 自定义成员方法实现费氏数列中第n项数值的计算并返回，n由参数指定
	// 1 1 2 3 5 8 13  21 ....
	int show(int n) { // int n = 5; int n = 4; int n = 3; int n = 2; int n = 1;
		// 1.使用递归的方式进行计算
		/*
		// 当n=1或者n=2时，结果是1
		if(1 == n || 2 == n) {
			return 1;
		}
		// 否则结果是前两项的和
		return show(n-1) + show(n-2);
		// show(5) => return show(4) + show(3); => 5
		// show(4) => return show(3) + show(2); => 3
		// show(3) => return show(2) + show(1); => 2
		// show(2) => return 1;                 => 1
		// show(1) => return 1;                 => 1
		*/
		// 2.使用递推的方式进行计算
		int ia = 1;
		int ib = 1;
		for(int i = 3; i <= n; i++) {
			int ic = ia + ib;
			ia = ib;
			ib = ic;
		}
		return ib;
	}
}

测试：
/*
    编程实现对费氏数列类的测试  测试类
 */
public class FeeTest {
	
	public static void main(String[] args) {
	
		// 1.声明FeeTest类型的引用指向该类型的对象
		Fee ft = new Fee();
		// 2.调用方法计算并打印
		int res = ft.show(55);
		System.out.println("计算的结果是：" + res); // 5
	}
}

封装

封装的概念
通常情况下可以在测试类给成员变量赋值一些合法但不合理的数值，无论是编译阶段还是运行阶段都不会报错或者给出提示，此时与现实生活不符。
为了避免上述错误的发生，就需要对成员变量进行密封包装处理，来隐藏成员变量的细节以及保证成员变量数值的合理性，该机制就叫做封装。

/*
    编程实现Student类的封装  封装类
 */
public class Student {
	
	// 1.私有化成员变量，使用private关键字修饰
	// private关键字修饰表示私有的含义，也就是该成员变量只能在当前类的内部使用
	private int id;       // 用于描述学号的成员变量
	private String name;  // 用于描述姓名的成员变量 
	
	// 3.在公有的构造方法中调用set方法进行合理值的判断
	public Student() {}
	public Student(int id, String name) {
		//this.id = id;
		//this.name = name;
		setId(id);
		setName(name);
	}
	
	// 2.提供公有的get和set方法，并在方法体中进行合理值的判断
	// 使用public关键字修饰表示公有的含义，也就是该方法可以在任意位置使用
	public int getId() {
		return id;
	}
	public void setId(int id) {
		if(id > 0) {
			this.id = id;
		} else {
			System.out.println("学号不合理哦！！！");
		}
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	// 自定义成员方法实现特征的打印
	// 什么修饰符都没有叫做默认的访问权限，级别介于private和public之间
	public void show() {
		//System.out.println("我是" + name + "，我的学号是" + id);
		System.out.println("我是" + getName() + "，我的学号是" + getId());
	}
}

测试：

     /*
    编程实现Student类的测试
 */
public class StudentTest {
	
	public static void main(String[] args) {
		
		// 1.声明Student类型的引用指向Student类型的对象
		Student s1 = new Student();
		// 2.对成员变量进行赋值并打印
		//s1.id = -1001;
		//s1.name = "张飞";
		s1.setId(-1001);
		s1.setName("张飞");
		s1.show(); // 1001 张飞
		
		System.out.println("----------------------------------------------------");
		// 3.使用有参方式构造对象并打印特征
		Student s2 = new Student(-1001, "张飞");
		s2.show(); 
	}
}

封装的实现流程

  • 私有化成员变量，使用private关键字修饰。
  • 提供公有的get和set方法，并在方法体中进行合理值的判断。
  • 在构造方法中调用set方法进行合理值的判断。

案例题目（录入学生信息）

提示用户输入班级的学生人数以及每个学生的信息，学生的信息有：学号、姓名，最后分别打印出来。
提示：Student[]arr= new Student[num];

/*
    编程实现学生信息的录入和打印
 */

import java.util.Scanner; 
 
public class StudentTest2 {
	
	public static void main(String[] args) {
		
		// 1.提示用户输入学生的人数并使用变量记录
		System.out.println("请输入学生的人数：");
		Scanner sc = new Scanner(System.in);
		int num = sc.nextInt();
		
		// 2.根据学生的人数准备对应的一维数组
		// int[] arr = new int[3];  - 表示声明一个长度为3元素类型为int类型的一维数组
		// 数组中的每个元素都是int类型，也就是说数组中的每个元素都可以看做是一个int类型的变量，使用整数数据进行初始化 arr[0] = 10;
		// 下面的代码是声明一个长度为num元素类型为Student类型的一维数组
		// 数组中的每个元素都是Student类型，也就是说数组中的每个元素都可以看做Student类型的变量，arr[0] = new Student();
		Student[] arr = new Student[num];
		
		
		// 3.提示用户输入每个学生的信息(学号 姓名)并记录到一维数组中
		for(int i = 0; i < num; i++) {
			System.out.println("请输入第" + (i+1) + "个学生的信息(学号 姓名)：");
			arr[i] = new Student(sc.nextInt(), sc.next());
		}
		
		System.out.println("-----------------------------------------------");
		// 4.打印所有学生信息
		System.out.println("该班级的所有学生信息有：");
		for(int i = 0; i < num; i++) {
			//System.out.println(arr[i]);
			arr[i].show();
		}
	}
}

JavaBean的概念（了解）

  • JavaBean是一种Java语言写成的可重用组件，其它Java类可以通过反射机制发现和操作这些JavaBean的属性。
  • JavaBean本质上就是符合以下标准的Java类：
    类是公共的
    有一个无参的公共的构造器
    有属性，且有对应的get、set方法

总结

  1. 构造方法（重中之重）
    语法格式、默认构造方法、实现成员变量的初始化
  2. 方法重载（重点）
    概念、体现形式、实际意义
  3. this关键字（原理）
    概念、原理、使用方式
  4. 递归（难点）
    概念、使用原则
  5. 封装（重中之重）
    概念、实现流程
scala系列——初始印象
有信念，才能走的更远
08-26 656
一、scala语言有什么特点？什么是函数式编程？有什么优点？ 　　1、特点：scala语言集成面向对象和函数式编程 　　2、函数是编程解释：函数式编程是一种典范，将电脑的运算视作是函数的运算。 　　3、优点：与过程化编程相比，函数式编程里的函数计算可以随时调用。 　　4、函数式编程中，函数是一等公民。 二、scala中的闭包 闭包是一个函数，返回值依赖于声明在函数外部的一个或多个变量。 闭包的实质就是代码与用到的非局部变量的混合，即：闭包 = 代码 + 用到的非局部变量 例如： 　　　　　　
c# task添加顺序_C# Task任务详解及其使用方式
weixin_39563722的博客
12-22 343
https://blog.csdn.net/younghaiqing/article/details/81455410C#多线程编程笔记(4.3)-Task任务中实现取消选项https://blog.csdn.net/qq_35445058/article/details/808293391.Task类介绍：Task 类的表示单个操作不返回一个值，通常以异步方式执行。 Task 对象是一个的中心思...
（Java学习随堂笔记）应用：对银行账户类进行修改、覆盖toString()方法、输出格式化
Zaza的博客
09-20 710
对银行账户类进行修改 覆盖toString()方法； 声明存取款方法； 使用DecimalFormat类； 声明类方法生成特殊的实例； 声明类变量。 覆盖toString()方法 toString()方法： 讲对象的内容转换为字符串 下面两行代码等价 System.out.println(anAccount); System.out.println(anAccount.toString()); //在每个类中磨人都有一个toString方法，当需要一个字符串String类型对象的时候，给定一个对象，toSt
《快学Scala》试读——对Scala的一点了解
sunny2038的专栏
11-13 205
       我最初接触 Scala 是在《七周七语言》这本书中看到的。当时对 Scala 最深的印象就是“函数式”。现在，我也打算系统的学习Scala。打算在Java编程的时候用Scala编写部分代码，提高效率。这里就结合试读章节，给初接触Scala并想选一本书的人一点粗浅的建议。   Scala 是什么 本书的简介中是这样介绍的： Scala 是一门以 J...
java声明银行账户类_JAVA：定义一个类实现银行帐户的概念，
weixin_34223354的博客
02-21 2673
展开全部有两点建议，你的关键代码中变量命名不规范，类型也有问题，变量命名应该是驼峰式命62616964757a686964616fe58685e5aeb931333365653763名，账号应该为String型，余额为浮点型，完整代码如下：/***银行账户类*/publicclassBankAccount{privateStringaccount;//账户privatedoubl...
shiro1.2.2
08-01
1. **配置 ShiroRealm**：自定义 Realm 类实现认证和授权逻辑，将用户的数据库查询和权限检查封装其中。 2. **创建 Shiro Filter**：配置 Shiro 过滤器链，定义哪些 URL 需要经过哪些过滤器，如 anon（匿名访问）、...
小程序 柚子培训教育v1.2.2小程序源码
02-21
7. **组件化开发**：微信小程序支持组件化开发，可将常用的功能或界面封装成自定义组件，提高代码复用性和开发效率。柚子培训教育小程序可能会有自定义组件，如课程列表组件、评价组件等。 8. **版本管理和发布流程...
log4cplus日志封装log
06-16
这个封装类通常会包含一些静态方法，每个方法对应一个日志级别，比如`debug()`, `info()`, `warn()`, `error()`等。通过这种方式，开发者可以直接调用相应级别的方法，而无需每次都创建`Logger`对象，极大地提高了...
mybatis-spring-1.2.2
08-30
在 1.2.2 版本中，你可以利用 Spring 的声明式事务管理，只需在服务层的方法上添加 @Transactional 注解，就可以自动开启和提交事务，处理异常时进行回滚。 6. **SqlSessionTemplate 和 SqlSessionDaoSupport：** ...
angularjs1.2.2
02-17
在AngularJS 1.2.2版本中，它引入了多个改进和优化，为开发者提供了更好的性能和稳定性。以下是对这个版本的关键特性和功能的详细讲解。 1. **依赖注入**：AngularJS的核心特性之一是依赖注入（Dependency ...
c# task添加顺序_C#-ContinueWith与在一个任务中顺序执行
weixin_39717029的博客
12-22 585
我刚刚开始熟悉Task Parallel Library,并且遇到了一个琐碎的问题,无法找到明确的答案.以下摘要与何时应该选择一个摘要之间有什么区别？Task t = Task.Factory.StartNew(() => {Result result = Utils.Calculate();Utils.ProcessResults(result);});和Task t = Task.Fac...
c# task添加顺序_c# – Task.ContinueWith执行顺序
weixin_39549852的博客
12-22 343
显然,我不了解如何使用ContinueWith方法.我的目标是执行任务,完成后返回一条消息.这是我的代码：public string UploadFile(){if (Request.Content.IsMimeMultipartContent()){//Save fileMultipartFormDataStreamProvider provider = new MultipartFormDat...
艾叔：Scala编程基础入门教程（001）-Scala和Java比较、Scala对于初学者的缺点
aishuc的博客
09-09 455
1.1  Scala是一门强大的语言，那么，它和其它主流的编程语言相比，有什么特点？ 1）Scala支持面向对象，在Scala上完全可以像C++/Java那样，使用面向对象的特性； 2）Scala兼容Java库，Scala程序是基于JVM运行的，Scala代码编译后，输出文件是可以在JVM上运行的字节码，因此，它与丰富的Java库是完全兼容的，在Scala代码中，可以无缝调用Java库所提供的...
Task执行流程
fighting
04-10 1657
1、源码走读 （1）当Driver中的SchedulerBackend（Standalone模式为CoarseGrainedSchedulerBackend）给ExecutorBackend（Standalone模式为CoarseGrainedExecutorBackend）发送LaunchTask之后，CoarseGrainedExecutorBackend在收到LaunchTask消息后，E...
进制转换和变量
weixin_30613727的博客
04-10 128
进制转换和变量 　　计算机内存存储数据的部位有硬盘和内存 　　硬盘存储的是可见数据，内存存储的是不可见数据 　　硬盘，内存所存储的数据都是二进制数据 　　我们使用的计算机室为了实现数据存储，数据运算，数据管理 　　[1]我们（程序员）必须了解数据是如何存储到计算机中的 　　[2]我们（程序员）必须了解，我们如何通过代码将数据存储到计算机中，以及如何使用这些数据 　　[对于人类]我们人...
2021-07-14 字节、数据类型、变量的命名规范、运算符
qq_43524652的博客
07-14 160
字节 位（bit）：是计算机内部数据储存的最小单位，11001101是一个八位二进制 字节（byte）：是计算机处理数据的基本单位，习惯上用大写B来表示 1B（byte，字节） = 8bit（位） 字符：是指计算机中使用的字母、数字、字和符号 1bit表示1位 1byte表示一个字节 1B = 8b 1024B = 1KB 1024KB = 1M 1024M = 1G 数据类型 强数据类型（java属于强数据类型） 要求变量的使用要严格符合使用规定，所有的变量都必须先定义后使用 弱数据类型
第四课：二进制
cambrianbaby的博客
05-31 242
1、二进制的原理，存储单元 MB/GB/TB 解释 0 计算机中的二进制表示： 单个数字 1 或 0，1 位二进制数字命名为位(bit),也称 1 比特。 1 字节（byte）的概念： 1byte=8bit，即 1byte 代表 8 位数字。最早期的电脑为八位的，即以八位为单位处理数据。为了方便，将八位数字命名为 1 字节（1byte）. 2 十进制与二进制的区别： 十进制有 10 个数字，0-9，逢 10 进 1（不存在 10 这个数字），则每向左进一位，数字大 10 倍。 二进制..
.NET Task 揭秘（3）async 与 AsyncMethodBuilder
最新发布
m0_62396648的博客
07-01 691
本文为系列博客什么是 TaskTask 的回调执行与 awaitasync 与 AsyncMethodBuilder（本文）总结与常见误区（TODO）上文我们学习了 await 这个语法糖背后的实现，了解了 await 这个关键词是如何去等待 Task 的完成并获取 Task 执行结果。并且我们还实现了一个简单的 awaitable 类型，它可以让我们自定义 await 的行为。// 回调，简化起见，未将其包裹到 TaskContinuation 这样的容器里。
C# Unity3D await/async与Task-Like的自定义
yueh0607
02-09 1204
从零 实现自定义轻量 0GC 产出 Task-Like ，支持自定义await和async的任务
tablecrow-1.2.2 Python库的介绍与安装方法
- 使用库可以缩短开发周期，因为许多常用的、经过良好测试的功能已经封装好可以直接使用。 - 库通常由社区维护，遇到问题时可以寻求社区支持。 - 由于库经常被不同项目重复使用，因此在使用过程中遇到的任何问题...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值