第4关:This关键字------Java面向对象 - 类与对象

package step3;

import java.util.Scanner;

public class Test {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String name = sc.next();
		int age = sc.nextInt();
		String sex = sc.next();
		Person p = new Person(name,age,sex);
		p.display();
	}
}

class Person{
	String name = "张三";
	int age = 18; 
	String sex = "男";
	/********** Begin **********/

	public Person(String name,int age,String sex){
		this(age);
		this.name=name;
		this.sex=sex;
	}
	
	public Person(int age){
		this.age = age;
	}
	
	public void display(){
		System.out.println("name:" + name);
		System.out.println("age:" + age);
		System.out.println("sex:" + sex);
	}


	/********** End **********/
}

  • 2
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Java面向对象程序设计笔记: 目录----非原创,上课的时候老师给的资料哦 第一章 Java 前凑 3 1. Java前凑 3 Java产生的目的 3 Java的诞生的历史 3 2.Java语言的特点 3 简单性 3 面向对象 3 网络技能 3 3.Java语言与其他语言的区别 4 第二章 Java面向对象程序设计初步 4 1. 程序语言的分类 4 解释型语言Java是编译解释型语言Java编译器、解释器、JVM以及OS之间的系 4 JVM的结构与作用 4 2. 程序设计的发展过程 4 程序设计的发展过程 4 O-O发展过程 5 O-O的体系 5 O-O程序设计与结构化程序设计的区别 5 3. Java应用程序 5 搭建开发环境 5 4. 类的设计与对象的构造 6 类的两个要素 6 构造函数 7 Java对内存的管理 7 Java源文件的结构 7 第三章 Java语法 8 1. Java注释 8 2. 标识符 9 3. 数据类型 9 基本数据类型 9 引用数据类型 9 5. 变量 9 6. 运算符 9 7. 数据的传输 9 8. 程序的逻辑控制语句 9 9. 数组 9 第四章 JavaOO程序设计 9 1.Java面向对象编程的特点 9 2.继承 10 2.1继承 10 2.2.Super关键字: 10 2.3.this关键字: 10 2.4.子类对象的构造和初始化: 11 2.5.方法的覆盖: 11 2.6.各种数据类型之间的相互转换: 12 3.静态成员 13 4. Final关键字: 13 5. 抽象类: 13 6. 接口 14 7. 接口与抽象类的区别: 15 8. 设计模式 15 单一设计模式: 15 策略模式: 16 模板模式: 16 组合设计模式: 16 9. 多态 16 10. 内部类 17 第五章 Java集合对象 18 1.List 18 2.Set 18 3.Map 19 第六章 常用的API类 21 1.对文件进行操作的类 21 2.对String对象操作的类 24 3. 对时间处理的类 25 4. 对系统处理的类: 26 5. 数据运算的类 27 6. 正则表达式 27 第七章 异常处理 32 第八章Oracle数据库基础 32 第九章JDBC编 32 第十章GUI编程 32
Java面向对象 1 1 学习方法与要求 1 2 面向对象语言与面向过程语言的区别 7 3 面向对象?什么对象? 8 4 什么是类? 9 5 如何创建一个类Class? 10 6 如何使用类创建对象 10 7 引用与实例 11 8 实例属性与实例方法 11 9 实例属性与实例方法的使用 12 10 实例属性属于实例本身,与其他实例没有系 13 11 javaBean编码规范 14 12 练习: 15 13 什么构造方法 16 14 构造方法的作用? 17 15 this关键字 17 16 方法调用时的引用传递还是值传递 19 17 面向对象语言的三大特性:封装,继承,多态 20 18 什么是封装?封装在哪? 20 18.1 封装的好处? 20 19 访问修饰符 20 20 面向对象的特性-继承 21 20.1 继承的关键字:extends 21 20.2 继承的语法格式: 21 20.3 继承的好处 21 20.4 Object类 21 20.5 继承是以什么方法实现的? 22 20.6 两个子类的实例,super会指向同一个父类实例吗? 23 20.7 在创建子类实例时,会创建父类实例,先创建哪个? 23 20.8 在子类构造方法中如何调用父类构造方法? 23 20.9 super关键字 24 20.10 父类中私有属性和私有方法可以继承吗? 24 20.11 在代码开发时先开发父类还是先开发子类? 24 20.12 父类是怎么来的? 25 20.13 父类中放的所有子类的共性。子类可以有自己的特性。 26 20.14 方法重写(核心@Override) 28 20.15 练习: 29 20.16 作业题: 31 21 类与类之间的系 32 22 GC:垃圾回收机制 33 23 Object类 33 23.1 常用方法:boolean equals(Object) 33 23.2 常用方法:String toString() 34 24 继承整理 34 25 面向对象三大特性:多态(核心) 34 25.1 多态的前提? 35 25.2 什么是多态? 35 25.3 父类的引用指向子类实例时,父类引用可以调用哪些方法? 35 26 引用类型的自动类型与强制类型转换 36 27 多态的应用 37 27.1 在使用多态时的一般格式: 37 27.2 练习:创建一个薪资专员(Persionnel),能计算员工工资,负责汇总当月所有员工的总工资数 38 27.3 练习:NewBasePlusSalesEmployee:针对BasePlusSalesEmployee有固定底薪的销售人员,有任务额度10K,满足任务额度正常发放,不满足任务额度发放底薪的80%,提成正常发放。 38 27.4 练习:设计一个形状类Shape 39 28 abstract关键字 41 28.1 abstract可以修饰的对象 41 28.2 抽象方法 41 28.3 抽象类 41 28.4 抽象方法与抽象类的系 42 28.5 抽象方法与抽象类的使用 42 28.6 abstract的使用场合 42 29 练习:写一个“愤怒的小鸟”: 43 30 final关键字 43 30.1 final可以修饰到3个地方 43 30.2 引用类型加final修饰表示引用不可变 44 31 static关键字 44 31.1 static关键字可以修饰4个地方 44 31.2 静态属性 44 31.3 静态的与实例的 45 31.4 静态代码块 45 31.5 静态方法 45 31.6 静态方法是不能被继承 46 31.7 如何区分静态方法和实例方法的应用 46 31.8 静态导入(1.5新特性) 46 32 单例模式 47 32.1 饿汉模式 47 32.2 懒汉模式 47 33 接口(interface) 48 33.1 如何创建一个接口。 48 33.2 如何使用接口 48 33.3 如何使用类实现一个接口 49 33.4 接口的细节 49 34 接口的应用(面向对象分析) 49 34.1 案例(第一版,使用接口) 50 34.2 案例(第二版) 52 35面向对象设计原则 54 1、找出应用中可能需求变化的代码,把它们独立出来,不要和那些需求不变化的的代码混在一起 54 2、针对接口编程,而不要针对实现类编程 54 3、多用组合,少用继承(包含实现) 54 4、为了交互对象之间的松耦合设计而努力 54 5、类应该对扩展开放,对修改闭 54 6、依赖倒置,要依赖抽象,不要依赖具体类 54 36 练习:超市收银 54 37 练习:接口表示一种能力,也可以是一种规范 56 38 策略模式 57 38.1 动作冒险游戏 57 38.2 类图 57 38.3 编写使用武器行为接口和实现类 58 38.4 编写角色类和子类 58 38.5 测试类 58 38.6 动作冒险游戏补丁:增加新的角色和新的技能 59 38.7 编写新的打斗行为 59 38.8 编写新的治疗行为和实现类 59 38.9 修改角色父类 60 38.10 修改King类 60 39 披萨工厂 61 39.1 编写披萨父类 61 39.2 编写各种披萨 61 39.3 编写披萨商品类 62 39.4 简单工厂 63 39.5 使用简单工厂修改商店类 63 39.6 使用简单工厂将创建对象代码单独的封装的好处? 64 39.7 使用常量优化工厂类 64 39.8 测试类 65 40 枚举(enum) 65 40.1 创建一个枚举 66 40.2 为枚举创建实例 66 40.3 如何使用枚举的实例 66 40.4 使用枚举优化披萨工厂 67 40.5 枚举类型也可以有构造方法 68 40.6 枚举类型也可以有属性 68 40.7 枚举类型也支持带参数的构造方法。 68 40.8 枚举类型也可以有实例方法 68 40.9 枚举类型也可以支持抽象方法 69 41 内部类 70 41.1 内部类的分类 70 41.2 匿名内部类 70 41.3 成员内部类 71 41.4 静态内部类 72 41.5 局部内部类 73 42 作业 :商超案例,以OOP重构 73
基本数据类型的包装类 •八大数据类型的包装类分别为:Byte、Short、Integer、Long、Character、 Float、Double、Boolean。 把基本数据类型变量包装类实例是通过对应包装类的构造器来实现的,不仅如此,8个包装类中除了 Character之外,还可以通过传入一个字符串参数来构建包装类对象。 •如果希望获得包装类对象中包装的基本类型变量,则可以使用包装类提供的XxxValue()实例方法。 自动装箱与自动拆箱 •JDk还提供了自动装箱和自动拆箱。自动装箱就是把一个基本类型的变量直接赋给对应的包装类变量,自动拆箱 则与之相反。 •包装类还可以实现基本类型变量和字符串之间的转换,除了Character之外的所有包装类都提供了一个 parseXxx(String s)静态方法。 •如果将基本类型转换为这符串,只需在后面加+ “”进行连接运算。 Java 7对包装类的增强 •Java 7为所有包装类增加一个新方法: compare(x , y)的方法。该方法用于比较两个包装类实例,当x>y, 返回大于0的数;当x==y,返回0;否则返回小于0的数。 对象的方法 •打印对象和toString方法:toString方法是系统将会输出该对象的“自我描述”信息,用以告诉外界对象具有的状 态信息。 •Object 类提供的toString方法总是返回该对象实现类的类名 + @ +hashCode值。 •==和equals比较运算符:==要求两个引用变量指向同一个对象才会返回true。equals方法则允许用户提供自 定义的相等规则。 •Object类提供的equals方法判断两个对象相等的标准与==完全相同。因此开发者通常需要重写equals方法。 类成员 •在java类里只能包含Field,方法,构造器,初始化块,内部类(接口、枚举)等5种成员。 用static修饰的类成员属 于类成员,类Field既可通过类来访问,也可以通过类的对象来访问。当通过对象来访问类属性时,系统会在底 层转换为通过该类来访问类 属性。 类成员规则 •类成员并不是属于实例,它是属于类本身的。只要类存在,类成员就存在。 •即使通过null对象来访问类成员,程序也不会引发NullPointerException。   类成员不能访问实例成员。 单例类 •如果一个类始终只能创建一个对象,称为单例类。须符合以下几个条件:   –1.我们把该类的构造器使用Private修饰,从而把该 类的所有构造器隐藏起来。   –2.则需要提供一个public方法作为该类的访问点,用于创建该类的对象,且必须使用static修饰   –3.该类还必须缓存已经创建的对象,必须用static修饰 final变量 •final修饰变量时,表示该变量一旦获得 初始值之后就不可被改变。 •final既可修饰成员变量,也可以修饰局部变量。 final修饰成员变量 •成员变量是随类的初始化或对象初始化而初始化的。final修饰的成员变量必须由程序员指定初始值。 •对于类属性而言,要么在静态初始化中初始化,要么在声明该属性时初始化。 •对于实例属性,要么在普通初始化块中指定初始值。要么在定义时、或构造器中指定初始值。 final修饰局部变量 •使用final修饰局部变量时既可以在定义时指定默认值,也可以不指定默认值。 •给局部变量赋初始值,只能一次,不能重复。 final修饰基本类型和引用类型 •当使用final修饰基本数据类型时,不能对其重新赋值,不能被改变。 •但对引用类型的变量而言,它仅仅保存的是一个引用,final只能保证他的地址不变,但不能保证对象,所以引用 类型完全可以改变他的对象。 可执行“宏替换”的final变量 •对一个final变量来说,不管它是类变量、实例变量,还是局部变量,只要该变量满足3个条件,这个final变量就 不再是一个变量,而是相当于一个直接量。   –使用final修饰符修饰;   –在定义该final变量时指定了初始值;   –该初始值可以在编译时就被确定下来。 final方法 •final方法 •final 修饰的方法不可以被重写。 •final 修饰的方法仅仅是不能重写,但它完全可以被重载。 •final 修饰的类不可以被继承 不可变的类 •不可变的类要满足以下几个条件:   –1.使用private和final修饰符来修饰该类的属性   –2.提供带参数的构造器,用于根据传入参数来初始化类里的属性   –3.仅为该类的属性提供getter方法,不要为该类的属性提供setter方法,因为普通方法无法修改final修饰的 属性   –4.如有必要,重写Object类中hashCode 和equals •缓存实例的不可变类:如果程序经常需要使用不可变类的实例,则可对实例进行缓存。 抽象方法和抽象类 •抽象方法和类都必须使用abstract来修饰,有抽象方法的类只能定义成抽象类,抽象里也可以没有抽象方法。 • 抽象类不能被实例化,可以通过其子类给他赋值,普通类里有的抽象里也有,定义抽象方法只需在普通方法上增 加abstract修饰符,并把普通方法的方法体(也就是方法后花括号括起来的部分)全部去掉,并在方法后增加分号 即可。 抽象类的特征 •抽象类的特征:有得有失,得到了新能力,可以拥有抽象方法;失去了创建对象的能力。 抽象类的作用 •抽象类代表了一种未完成的类设计,它体现的是一种模板。 •抽象类与模板模式。 接口的概念 •接口定义的是多个类共同的行为规范,这些行为是与外部交流的通道,这就意味着接口里通常是定义一组公用的 方法。 •接口体现了规范与实现分离的设计。 接口的定义 •和类定义不同,定义接口不再用class关键字,而是使用interface关键字。语法如下: •[修饰符] interface接口名 extends 父接口1,父接口2 ... •{ • 零个到多个常量定义... • 零个到多个抽象方法定义... • 零个到多个内部类、接口、枚举定义... • 零个到多个默认方法或类方法定义... •} 接口里的成分 •在定义接口时,接口里可以包含成员变量(只能是常量),方法(只能是抽象实例方法、类方法或默认方法),内 部类(包括内部接口、枚举类   –常量都是:public static final修饰   –方法都是:public abstract 修饰   –内部的类:public static 接口的继承 •接口的继承和类继承不一样,接口完全支持多继承,子接口扩展某个父接口将会获得父接口的所有抽象方法,常 量属性,内部类和枚举类定义。 使用接口 •接口可以用于声明引用类型的变量,但接口不能用于创建实例。 •当使用接口来声明引用类型的变量时,这个引用类型的变量必须引用到其实现类的对象。 •一个类可以实现一个或多个接口,继承使用extends关键字,实现接口则使用implements关键字。 实现接口 •一个类实现了一个或多个接口之后,这个类必须完全实现这些接口里所定义的全部抽象方法(也就是重写这些抽 象方法); •否则,该类将保留从父接口那里继承到的抽象方法,该类也必须定义成抽象类。 接口和抽象类的相似性 •接口和抽象类都不能被实例化,它们都位于继承树的顶端,用于被其他类实现和继承。 •接口和抽象类都可以包含抽象方法,实现接口或继承抽象类的普通子类都必须实现这些抽象方法。 接口与抽象类的区别 •接口里只能包含抽象方法,不同包含已经提供实现的方法;抽象类则完全可以包含普通方法。 •接口里不能定义静态方法;抽象类里可以定义静态方法。 •接口里只能定义静态常量属性,不能定义普通属性;抽象类里则既可以定义普通属性,也可以定义静态常量属 性。 •接口不包含构造器;抽象类里可以包含构造器,抽象类里的构造器并不是用于创建对象,而让其子类调用这些构 造器来完成属于抽象类的初始化操作。 •接口里不能包含初始化块,但抽象类则完全可以包含初始化块。 •一个类最多只能有一个直接父类,包括抽象类;但一个类可以直接实现多个接口,通过实现多个接口可以弥补 Java单继承的不足。 面向接口编程 •接口体现了规范与实现分离的原则。充分利用接口可以很好地提高系统的可扩展性和可维护性。 •接口与简单工厂模式、命令模式等。 内部类 •我们把一个类放在另一个类的内部定义,这个定义在其他类内部的类就被称为内部类,有的也叫嵌套类,包含内   部类的类也被称为外部类有的也叫宿住类。 •内部类提供了更好的封装,内部类成员可以直接访问外部类的私有数据,因为内部类被当成其他外部类成员。 •匿名内部类适合用于创建那些仅需要一次使用的类。 非静态内部类 •定义内部类非常简单,只要把一个类放在另一个类内部定义即可。 •当在非静态内部类的方法内访问某个变量时,系统优先在该方法内查找是否存在该名字的局部变量,如果存在该 名字的局部变量,就使用该变量,如果不存在,则到该方法所在的内部类中查找是否存在该名字的属性,如果存在 则使用该属性。 •总之,第一步先找局部变量,第二步,内部类的属性,第三步。外部类的属性。 本文原创作者:pipi-changing 本文原创出处:http://www.cnblogs.com/pipi-changing/ 静态内部类 •如果用static修饰一个内部类,称为静态内部类。 •静态内部类可以包含静态成员,也可以包含非静态成员。所以静态内部类不能访问外部类的实例成员,只能访问   外部类的类成员。 •静态内部类的对象寄存在外部类里,非静态内部类的对象寄存在外部类实例里 使用内部类 •1.在外部类内部使用内部类-不要在外部类的静态成员中使用非静态内部类,因为静态成员不能访问非静态成 员。 • 2.在外部类以外使用非静态内部类。   –private 修饰的内部类只能在外部类内部使用。   –在外部类以外的地方使用内部类,内部类完整的类名应该OuterClass.InnerClass.   –在外部类以外的地方使用非静态内部类创建对象的语法如下:OuterInstance.new InnerConstructor()   –在外部类以外的地方使用静态内部类创建对象的语法如下:new OuterClass.InnerConstructer(); 局部内部类 •如果把一个内部类放在方法里定义,这就是局部内部类,仅仅在这个方法里有效。 •局部内部类不能在外部类以外的地方使用,那么局部内部类也不能使用访问控制符和static修饰 匿名内部类 •匿名内部类适合创建那种只需要一次使用的类,定义匿名内部类的语法格式如下: •new 父类构造器(实例列表) |实现接口) •{ • //匿名内部类的 类体部分 •} •匿名内部类不能是抽象类,匿名内部类不能定义构造器。 Lambda表达式入门 •Lambda表达式主要作用就是代替匿名内部类的繁琐语法。它由三部分组成:   –形参列表。形参列表允许省略形参类型。如果形参列表中只有一个参数,甚至连形参列表的圆括号也可以省略。   –箭头(->),必须通过英文等号和大于符号组成。   –代码块。如果代码块只有包含一条语句,Lambda表达式允许省略代码块的花括号,如果省略了代码块的花括 号,这条语句不要用花括号表示语句结束。Lambda代码块只有一条return语句,甚至可以省略return关键字。 Lambda表达式需要返回值,而它的代码块中仅有一条省略了return的语句,Lambda表达式会自动返回这条语句的 值。 Lambda表达式与函数式接口 •如果采用匿名内部类语法来创建函数式接口的实例,只要实现一个抽象方法即可,在这种情况下即可采用 Lambda表达式来创建对象,该表达式创建出来的对象的目标类型就是这个函数式接口。 •Lambda表达式有如下两个限制:   –Lambda表达式的目标类型必须是明确的函数式接口。   –Lambda表达式只能为函数式接口创建对象。Lambda表达式只能实现一个方法,因此它只能为只有一个抽 象方法的接口(函数式接口)创建对象。 •为了保证Lambda表达式的目标类型是一个明确的函数式接口,可以有如下三种常见方式:   –将Lambda表达式赋值给函数式接口类型的变量。   –将Lambda表达式作为函数式接口类型的参数传给某个方法。   –使用函数式接口对Lambda表达式进行强制类型转换。 方法引用与构造器引用 种类 示例 说明 对应的Lambda表达式 引用类方法 类名::类方法 函数式接口中被实现方法的全部参数传给该类方法作为参数。 (a,b,...) -> 类名.类方法(a,b, ...) 引用特定对象的实例方法 特定对象::实例方法 函数式接口中被实现方法的全部参数传给该方法作为参数。 (a,b, ...) -> 特定对象.实例方法(a,b, ...) 引用某类对象的实例方法 类名::实例方法 函数式接口中被实现方法的第一个参数作为调用者,后面的参数全部传给该方法作为参数。 (a,b, ...) ->a.实例方法(b, ...) 引用构造器 类名::new 函数式接口中被实现方法的全部参数传给该构造器作为参数。 (a,b, ...) ->new 类名(a,b, ...) Lambda表达式与匿名内部类 •Lambda表达式与匿名内部类存在如下相同点:   –Lambda表达式与匿名内部类一样,都可以直接访问“effectively final”的局部变量,以及外部类的成员变 量(包括实例变量和类变量)。   –Lambda表达式创建的对象与匿名内部类生成的对象一样, 都可以直接调用从接口继承得到的默认方法。 •Lambda表达式与匿名内部类主要存在如下区别:   –匿名内部类可以为任意接口创建实例——不管接口包含多少个抽象方法,只要匿名内部类实现所有的抽象方 法即可。但Lambda表达式只能为函数式接口创建实例。   –匿名内部类可以为抽象类、甚至普通类创建实例,但Lambda表达式只能为函数式接口创建实例。   –匿名内部类实现的抽象方法的方法体允许调用接口中定义的默认方法;但Lambda表达式的代码块不允许调 用接口中定义的默认方法。 手动实现枚举类 •可以采用如下设计方式:   –通过private将构造器隐藏起来。   –把这个类的所有可能实例都使用public static final属性来保存。   –如果有必要,可以提供一些静态方法,允许其他程序根据特定参数来获取与之匹配实例。 JDK 5新增的枚举支持 •J2SE1.5新增了一个enum关键字,用以定义枚举类。正如前面看到,枚举类是一种特殊的类,它一样可以有自 己的方法和属性,可以实现一个或者多个接口,也可以定义自己的构造器。一个Java源文件中最多只能定义一个 public访问权限的枚举类,且该Java源文件也必须和该枚举类的类名相同。 枚举类 •枚举类可以实现一个或多个接口,使用enum定义的枚举类默认继承了java.lang.Enum类,而不是继承Object 类。其中java.lang.Enum类实现了java.lang.Serializable和java.lang. Comparable两个接口。 •枚举类的构造器只能使用private访问控制符,如果省略了其构造器的访问控制符,则默认使用private修饰;如 果强制指定访问控制符,则只能指定private修饰符。 •枚举类的所有实例必须在枚举类中显式列出,否则这个枚举类将永远都不能产生实例。列出这些实例时系统会自 动添加public static final修饰,无需程序员显式添加。 •所有枚举类都提供了一个values方法,该方法可以很方便地遍历所有的枚举值。 枚举类的属性、方法和构造器 •枚举类也是一种类,只是它是一种比较特殊的类,因此它一样可以使用属性和方法。 •枚举类通常应该设计成不可变类,也就说它的属性值不应该允许改变,这样会更安全,而且代码更加简洁。为 此,我们应该将枚举类的属性都使用private final 修饰。 •一旦为枚举类显式定义了带参数的构造器,则列出枚举值时也必须对应地传入参数。 实现接口的枚举类 •枚举类也可以实现一个或多个接口。与普通类实现一个或多个接口完全一样,枚举类实现一个或多个接口时,也 需要实现该接口所包含的方法。 •如果需要每个枚举值在调用同一个方法时呈现出不同的行为方式,则可以让每个枚举值分别来实现该方法,每个 枚举值提供不同的实现方式,从而让不同枚举值调用同一个方法时具有不同的行为方式。 包含抽象方法的枚举类 •可以在枚举类里定义一个抽象方法,然后把这个抽象方法交给各枚举值去实现即可。 •枚举类里定义抽象方法时无需显式使用abstract关键字将枚举类定义成抽象类,但因为枚举类需要显式创建枚举 值,而不是作为父类,所以定义每个枚举值时必须为抽象方法提供实现,否则将出现编译错误。 垃圾回收机制 •垃圾回收机制只负责回收堆内存中对象,不会回收任何任何物理资源(例如数据库连接,网络IO等资源)。 •程序无法精确控制垃圾回收的运行,垃圾回收会在合适时候进行垃圾回收。当对象永久性地失去引用后,系统就 会在合适时候回收它所占的内存。 •垃圾回收机制回收任何对象之前,总会先调用它的finalize方法,该方法可能使该对象重新复活(让一个引用变量 重新引用该对象),从而导致垃圾回收机制取消回收 对象在内存中的状态 •激活状态:当一个对象被创建后,有一个以上的引用变量引用它。则这个对象在程序中处于激活状态,程序可通 过引用变量来调用该对象的属性和方法。 •去活状态:如果程序中某个对象不再有任何引用变量引用它,它就进入了去活状态。在这个状态下,系统的垃圾 回收机制准备回收该对象所占用的内存,在回收该对象之前,系统会调用所有去活状态对象的finalize方法进行资 源清理,如果系统在调用finalize方法重新让一个引用变量引用该对象,则这个对象会再次变为激活状态;否则该 对象将进入死亡状态。 •死亡状态:当对象与所有引用变量的联都被切断,且系统会调用所有对象的finalize方法依然没有使该对象变成 激活状态,那这个对象将永久性地失去引用,最后变成死亡状态。只有当一个对象处于死亡状态时,系统才会真正 回收该对象所占有的资源。 强制垃圾回收 •强制系统垃圾回收有如下两个方法:   –调用System类的gc()静态方法:System.gc()   –调用Runtime对象的gc()实例方法:Runtime.getRuntime().gc() finalize方法 •finalize方法有如下四个特点:   –永远不要主动调用某个对象的finalize方法,该方法应交给垃圾回收机制调用。   –finalize方法的何时被调用,是否被调用具有不确定性。不要把finalize方法当成一定会被执行的方法。   –当JVM执行去活对象的finalize方法时,可能使该对象,或系统中其他对象重新变成激活状态。   –当JVM执行finalize方法时出现了异常,垃圾回收机制不会报告异常,程序继续执行。 对象的软、弱和虚引用 •强引用(StrongReference) •软引用-软引用需要通过SoftReference类来实现,当一个对象只具有软引用时,它有可能被垃圾回收机制回 收。 •弱引用-弱引用通过WeakReference类实现,弱引用和软引用很像,但弱引用的引用级别更低。对于只有弱引 用的对象而言,当系统垃圾回收机制运行时,不管系统内存是否足够,总会回收该对象所占用的内存。 •虚引用-虚引用通过PhantomReference类实现,虚应用完全类似于没有引用。虚引用对对象本身没有太大影 响,对象甚至感觉不到虚引用的存在。 修饰符的适用范围 顶层类/接口 成员属性 方法 构造器 初始化块 成员内部类 局部成员 public √ √ √ √ √ protected √ √ √ √ 包访问控制符 √ √ √ √ ○ √ ○ private √ √ √ √ abstract √ √ √ final √ √ √ √ √ static √ √ √ √ strictfp √ √ √ synchronized √ native √ transient √ volatile √ 使用JAR文件的好处 •1.安全 •2.加快下载速度 •3.压缩 •4.包封装 •5.可移植性 jar命令详解 •-c 创建新文档,-t 列出存档内容的列表, -x 展开存档中的命名文件 •-u 更新已存在的存档,-v生成详细输出到标准输出上 •-f 指定存档文件名,-m 包含 来自标文件的标明信息 •-o 只存储方式:未用ZIP压缩格式 •-m 不产生所有项的清单文件,- I 为指定的jar文件产生索引信息 •-c 改变到指定的目录, 创建可执行的JAR包 •1.使用平台相的编译器将整个应用编译成平台相的可执行性文件 •2.为整个应用编辑一个批处理文件 于JAR包的技巧 •相当于一个压缩文件。 •可使用WinRAR来压缩JAR包。 •也可使用WinRAR来查看JAR包。 现在贴出代码: AutoBoxingUnboxing Primitive2String UnsignedTest WrapperClassCompare EqualTest Person OverrideEqualsRight PrintObject StringCompareTest ToStringTest NullAccessStatic Singleton Address CacheImmutaleTest FinalErrorTest FinalLocalTest FinalLocalVariableTest FinalMethodTest FinalReferenceTest FinalReplaceTest FinalVariableTest ImmutableStringTest IntegerCacheTest Person Sub extends PrivateFinalMethodTest StringJoinTest CarSpeedMeter Circle extends Shape abstract class Shape SpeedMeter Triangle 复制代码 public class AddCommand implements Command { public void process(int[] target) { int sum = 0; for (int tmp : target) { sum += tmp; } System.out.println("数组元素的总和是:" + sum); } } **************************************************** public class BetterPrinter implements Output { private String[] printData = new String[MAX_CACHE_LINE * 2]; // 用以记录当前需打印的作业数 private int dataNum = 0; public void out() { // 只要还有作业,继续打印 while (dataNum > 0) { System.out.println("高速打印机正在打印:" + printData[0]); // 把作业队列整体前移一位,并将剩下的作业数减1 System.arraycopy(printData, 1, printData, 0, --dataNum); } } public void getData(String msg) { if (dataNum >= MAX_CACHE_LINE * 2) { System.out.println("输出队列已满,添加失败"); } else { // 把打印数据添加到队列里,已保存数据的数量加1。 printData[dataNum++] = msg; } } } ************************************************ public interface Command { // 接口里定义的process()方法用于封装“处理行为” void process(int[] target); } ********************************************** public class CommandTest { public static void main(String[] args) { ProcessArray pa = new ProcessArray(); int[] target = { 3, -4, 6, 4 }; // 第一次处理数组,具体处理行为取决于PrintCommand pa.process(target, new PrintCommand()); System.out.println("------------------"); // 第二次处理数组,具体处理行为取决于AddCommand pa.process(target, new AddCommand()); } } ************************************************* public class Computer { private Output out; public Computer(Output out) { this.out = out; } // 定义一个模拟获取字符串输入的方法 public void keyIn(String msg) { out.getData(msg); } // 定义一个模拟打印的方法 public void print() { out.out(); } } ********************************************** interface interfaceA { int PROP_A = 5; void testA(); } interface interfaceB { int PROP_B = 6; void testB(); } interface interfaceC extends interfaceA, interfaceB { int PROP_C = 7; void testC(); } public class InterfaceExtendsTest { public static void main(String[] args) { System.out.println(interfaceC.PROP_A); System.out.println(interfaceC.PROP_B); System.out.println(interfaceC.PROP_C); } } ************************************************** public interface Output { // 接口里定义的成员变量只能是常量 int MAX_CACHE_LINE = 50; // 接口里定义的普通方法只能是public的抽象方法 void out(); void getData(String msg); // 在接口中定义默认方法,需要使用default修饰 default void print(String... msgs) { for (String msg : msgs) { System.out.println(msg); } } // 在接口中定义默认方法,需要使用default修饰 default void test() { System.out.println("默认的test()方法"); } // 在接口中定义类方法,需要使用static修饰 static String staticTest() { return "接口里的类方法"; } } ********************************************** public class OutputFactory { public Output getOutput() { // return new Printer(); return new BetterPrinter(); } public static void main(String[] args) { OutputFactory of = new OutputFactory(); Computer c = new Computer(of.getOutput()); c.keyIn("轻量级Java EE企业应用实战"); c.keyIn("疯狂Java讲义"); c.print(); } } *********************************************** public class OutputFieldTest { public static void main(String[] args) { // 访问另一个包中的Output接口的MAX_CACHE_LINE System.out.println(lee.Output.MAX_CACHE_LINE); // 下面语句将引起"为final变量赋值"的编译异常 // lee.Output.MAX_CACHE_LINE = 20; // 使用接口来调用类方法 System.out.println(lee.Output.staticTest()); } } ************************************************ public class PrintCommand implements Command { public void process(int[] target) { for (int tmp : target) { System.out.println("迭代输出目标数组的元素:" + tmp); } } } *********************************************** // 定义一个Product接口 interface Product { int getProduceTime(); } // 让Printer类实现Output和Product接口 public class Printer implements Output, Product { private String[] printData = new String[MAX_CACHE_LINE]; // 用以记录当前需打印的作业数 private int dataNum = 0; public void out() { // 只要还有作业,继续打印 while (dataNum > 0) { System.out.println("打印机打印:" + printData[0]); // 把作业队列整体前移一位,并将剩下的作业数减1 System.arraycopy(printData, 1, printData, 0, --dataNum); } } public void getData(String msg) { if (dataNum >= MAX_CACHE_LINE) { System.out.println("输出队列已满,添加失败"); } else { // 把打印数据添加到队列里,已保存数据的数量加1。 printData[dataNum++] = msg; } } public int getProduceTime() { return 45; } public static void main(String[] args) { // 创建一个Printer对象,当成Output使用 Output o = new Printer(); o.getData("轻量级Java EE企业应用实战"); o.getData("疯狂Java讲义"); o.out(); o.getData("疯狂Android讲义"); o.getData("疯狂Ajax讲义"); o.out(); // 调用Output接口中定义的默认方法 o.print("孙悟空", "猪八戒", "白骨精"); o.test(); // 创建一个Printer对象,当成Product使用 Product p = new Printer(); System.out.println(p.getProduceTime()); // 所有接口类型的引用变量都可直接赋给Object类型的变量 Object obj = p; } } ************************************************* public class ProcessArray { public void process(int[] target, Command cmd) { cmd.process(target); } } 复制代码 。。。。。。。。。。。。。。。。
最好的最简单的Java入门教程。 目录 1 Java概述 1 1.1 Java语言概述 1 1.2 Java虚拟机以及跨平台原理 2 1.3 于JVM的执行效率 2 1.4 客户端市场的折戟 3 1.5 Java的主要就业方向 3 1.5.1.1 Web开发 3 1.5.1.2 Android开发 3 1.5.1.3 客户端开发 3 1.6 Java的不同版本 4 1.6.1.1 J2SE(Java 2 Platform Standard Edition) 标准版 4 1.6.1.2 J2EE(Java 2 Platform Enterprise Edition) 企业版 4 1.6.1.3 J2ME(Java 2 Platform Micro Edition) 微型版 4 1.7 Java开发环境搭建 4 1.8 JDK 的下载 4 1.9 JDK的安装 5 1.10 环境变量的设置 9 1.11 Eclipse的安装 9 1.12 安装简体中文语言包 11 1.13 第一个Java程序示例 14 1.14 通过Eclipse运行程序 14 1.15 通过命令行运行程序 17 1.16 HelloWorld程序分析 18 1.17 Java类和对象的概念 18 1.18 面向对象编程(Object Oriented Programming, OOP) 19 1.19 Java类库及其组织结构 21 1.20 Java import及Java类的搜索路径 22 1.21 Java类的搜索路径 23 2 Java语法基础 24 2.1 Java数据类型以及变量的定义 24 2.2 对布尔型的说明 25 2.3 Java数据类型转换 26 2.4 自动数据类型转换 26 2.5 强制数据类型转换 26 2.6 Java运算符 27 2.6.1.1 数学运算符 27 2.6.1.2 系运算符 27 2.6.1.3 位运算符 27 2.6.1.4 条件运算符 28 2.7 Java流程控制 29 2.8 Java数组的定义和使用 31 2.9 数组的定义和内存分配 31 2.10 数组的初始化 31 2.11 数组引用 32 2.12 数组的遍历 32 2.13 二维数组 33 2.14 Java字符串(String) 35 2.15 字符串操作 35 2.15.1.1 1) length() 方法 36 2.15.1.2 2) charAt() 方法 36 2.15.1.3 3) contains() 方法 36 2.15.1.4 4) replace() 方法 36 2.15.1.5 5) split() 方法 36 2.16 Java StringBuffer与StringBuider 37 2.17 StringBuffer类的主要方法 37 2.17.1.1 1) append() 方法 37 2.17.1.2 2) deleteCharAt() 37 2.17.1.3 3) insert() 方法 38 2.17.1.4 4) setCharAt() 方法 38 2.18 String和StringBuffer的效率对比 38 2.19 StringBuilder类 39 2.20 总结 39 2.21 强调一下编程风格 40 3 Java类与对象 42 3.1 Java类的定义及其实例化 42 3.2 构造方法 42 3.3 创建对象 43 3.4 访问成员变量和方法 44 3.5 Java访问修饰符 45 3.6 public:公有的 45 3.7 protected:受保护的 45 3.8 private:私有的 46 3.9 默认的:不使用任何关键字 47 3.10 访问控制和继承 47 3.11 如何使用访问控制符 47 3.12 Java变量的作用域 48 3.13 Java this关键字详解 49 3.14 使用this区分同名变量 49 3.15 作为方法名来初始化对象 50 3.16 作为参数传递 51 3.17 Java方法重载 52 3.18 Java类的基本运行顺序 53 3.19 Java包装类、拆箱和装箱详解 54 3.20 包装类的应用 54 3.20.1.1 1) 实现 int 和 Integer 的相互转换 54 3.20.1.2 2) 将字符串转换为整数 55 3.20.1.3 3) 将整数转换为字符串 55 3.21 自动拆箱和装箱 56 3.22 再谈Java包 56 3.23 如何实现包 56 3.24 包的调用 56 3.24.1.1 1) 在每个类名前面加上完整的包名 57 3.24.1.2 2) 通过 import 语句引入包中的类 57 3.25 类的路径 57 3.26 包的访问权限 58 3.27 源文件的声明规则 59 3.28 一个简单的例子 59 4 Java继承和多态 61 4.1 继承的概念与实现 61 4.2 Java super关键字 63 4.3 调用隐藏变量和被覆盖的方法 63 4.4 调用父类的构造方法 64 4.5 继承中的方法的覆盖和重载 65 4.6 多态和动态绑定 66 4.7 动态绑定 69 4.8 instanceof 运算符 70 4.9 多态对象的类型转换 71 4.10 Java static关键字以及Java静态变量和静态方法 72 4.11 static 的内存分配 73 4.12 静态方法 74 4.13 静态初始器(静态块) 75 4.14 静态导入 75 4.15 Java final关键字:阻止继承和多态 76 4.16 类与类之间的系 78 4.17 依赖(uses-a) 78 4.18 聚合(has-a) 78 4.19 继承 79 4.20 Java Object类 79 4.21 equals() 方法 79 4.22 hashCode() 方法 80 4.23 toString() 方法 80
JAVA语言面向对象程序设计作业1 单项选择题 第1题 以下由for语句构成的循环执行的次数是()。 for(int i=0;true;i++); A、有语法错误,不能执行 B、无限次 C、执行1次 D、一次也不执行 答案:B 第2题 以下标识符中哪项是不合法的()。 A、BigOlLong$223 B、_utfint C、$12s D、3d 答案:D 第3题 执行完以下代码int [ ] x = new int[25];后,以下哪项说明是正确的()。 A、x[24]为0 B、x[24]未定义 C、x[25]为0 D、x[0]为空 答案:A 第4题 若在某一个类定义中定义有如下的方法: abstract void performDial(); 该方法属于()。 A、本地方法 B、最终方法 C、解态方法 D、抽象方法 答案:D 第5题 以下选项中,合法的赋值语句是()。 A、a==1; B、++I; C、a=a+1=5; D、!(++a!=b--); 答案:B 第6题 执行完以下代码int [ ] x = new int[5];后,以下哪项说明是正确的()。 A、x[4]为0 B、x[4]未定义 C、x[5]为0 D、x[0]为空 答案:A 第7题 执行下列程序段后,m,x,y的值分别是()。 int x=2,y=4; boolean m; m=++x>y--; A、true,2,4 B、false,3,3 C、treu,3,3 D、false,2,4 答案:B 第8题 在Java中,存放字符串常量的对象属于()类对象。 A、Character B、String C、StringBuffer D、Vector 答案:B 第9题 设有下面的一个类定义: class AA {static void Show(){System.out.println("我喜欢Java!"); }} class BB {void Show(){System.out.println("我喜欢C++!"); }}若已经使用AA类创建对象a和BB类创建对象b,则下面哪一个方法调用是正确的:()。 A、a.Show( ) B、AA.Show( ); b.Show( ); BB.Show( ); C、AA.Show( ) D、a.show( ); b.show( ); ; bb.show( ); 答案:C 第10题 以下for循环的执行次数是()。 for(int x=0;(x==0)&(x>4);x++); A、无限次 B、一次也不执行 C、执行4次 D、执行3次 答案:B 多项选择题 第11题 如下哪些字串是Java中的标识符? A、fieldname B、super C、3number D、#number E、mybooks 答案:A"E 第12题 Java中如下哪个约束符是正确的? A、private B、public C、protected D、protect E、friend 答案:A"B"C 第13题 如下哪些是Java中有效的关键字? A、const B、NULL C、false D、this E、native 答案:A"C"D"E 判断题 第14题 对象可以赋值,只要使用赋值号(等号)即可,相当于生成了一个各属性与赋值对象相 同的新对象。 答案:错误 第15题 Java的字符类型采用的是ASCII编码。 答案:正确 第16题 Java的各种数据类型占用固定长度,与具体的软硬件平台环境无。 答案:正确 第17题 Vector类中的对象不能是简单数据类型。 答案:正确 第18题 Java程序里,创建新的类对象用关键字new,回收无用的类对象使用关键字free。 答案:错误 第19题 类及其属性、方法可以同时有一个以上的修饰符来修饰。 答案:正确 第20题 有的类定义时可以不定义构造函数,所以构造函数不是必需的。 答案:错误 JAVA语言面向对象程序设计作业2 单项选择题 第1题 下面的语句的作用是:()。 Vector MyVector = new Vector(100,50); A、创建一个数组类对象MyVector,有100个元素的空间,每个元素的初值为50 B、创建一个向量类对象MyVector,有100个元素的空间,每个元素的初值为50 C、创建一个数组类对象MyVector,有100个元素的空间,若空间使用完时,以50个 元素空间单位递增 D、创建一个向量类对象MyVector,有100个元素的空间,若空间使用完时,以50个 元素空间单位递增 答案:D 第2题 下面程序段的输出结果是( )。 String MyStr = "Hello,"; MyStr = MyStr+"Guys!"; System.out.println(MySt
模块5 深入Java面向对象Java程序设计案例教程》教学课件05深入Java面向对象全文共47页,当前为第1页。 学习目标 01 了解Java面向对象程序设计的思想原则。 02 掌握类的结构、定义及对象的创建和使用。 03 掌握成员变量(实例变量、静态变量)和成员常量(实例常量、静态常量)的定义和使用。 05 理解访问控制、数据安全性、包及封装的概念。 04 掌握成员方法(实例方法、静态方法)的定义和使用,以及成员方法重载的概念。 06 掌握构造方法(隐式、显式)的定义和使用,以及构造方法重载的概念。 07 掌握this关键字的使用。 08 了解基本数据类型变量和引用数据类型变量在数值传递上的区别。 《Java程序设计案例教程》教学课件05深入Java面向对象全文共47页,当前为第2页。 技能目标 1.能够在MyEclipse IDE中定义子类继承父类。 2.能够在子类的定义中使用super关键字及重写父类的成员方法。 3.能够使用instanceof运算符判断对象类型。 4.能够在MyEclipse IDE中定义抽象类及定义子类继承抽象父类。 5.能够在MyEclipse IDE中定义接口及定义类实现接口。 《Java程序设计案例教程》教学课件05深入Java面向对象全文共47页,当前为第3页。 5.1 回顾与思考 在模块4我们以Circle类为例,从类的定义入手,详细分析了类的构成和使用。如果现在面临一个任务:设计一个扇形类Sector,提供计算扇形的弧长、周长和面积的方法。我们该如何解决这个问题?一个办法是完整地定义扇形类Sector,包括所有必需的成员变量及常量、构造方法、成员方法等。这个办法有个缺点,就是必须重新开始一个类的定义。能否在已完成工作的基础上(如利用Circle类),适当添加或改动部分代码,完成扇形类Sector的定义?答案是可行的。但是在编写过程中需要遵循另一个重要的面向对象设计原则:继承。 《Java程序设计案例教程》教学课件05深入Java面向对象全文共47页,当前为第4页。 5.2 继承 继承可以充分利用现有的代码,解决编程过程中代码冗余的问题,它是实现代码重用的有效手段之一。被继承的类被称为父类或超类(superclass),由继承而得到的类被称为子类(subclass)。继承增强了代码的重用性,增强了软件的扩展性。 Java中只允许单一继承,不允许多重继承,即每个类只能有一个父类。 《Java程序设计案例教程》教学课件05深入Java面向对象全文共47页,当前为第5页。 5.2 继承 Java中通过关键字extends实现子类对父类的继承。定义子类的基本语法格式如下。 修饰符 class 子类名 extends 父类名 { //类体 } 除了增加"extends 父类名"以外,其余含义和类的定义相似,可参阅4.2节。 《Java程序设计案例教程》教学课件05深入Java面向对象全文共47页,当前为第6页。 5.2 继承 5.2.1 继承的实现 【例5-1】定义类Sector,代表扇形,继承Circle类,提供计算扇形的弧长、周长和面积的方法。 首先在ch5.example包中定义父类Circle。在MyEclipse IDE中,右击myPro项目下src目录的ch5.example目录,在弹出的快捷菜单中执行"New" "Class"命令,在弹出的"New Java Class"窗口中输入类名Circle,如图5-1所示。 图5-1 创建父类Circle 图5-1 创建父类Circle 《Java程序设计案例教程》教学课件05深入Java面向对象全文共47页,当前为第7页。 5.2 继承 5.2.1 继承的实现 【例5-1】 单击Finish按钮,完成父类Circle的创建。文件名为Circle.java,其代码如下。 见书本P100-101。 然后定义子类Sector。可以手动输入子类Sector的代码,也可以采用相对规范的操作方式创建Sector类,步骤如下:右击myPro项目下src目录的ch5.example目录,在弹出的快捷菜单中执行"New" "Class"命令,在弹出的"New Java Class"窗口中输入类名Sector,如图5-2所示。 再单击Superclass文本框右边的Browse按钮,打开"Superclass Selection"窗口,如图5-3所示。 《Java程序设计案例教程》教学课件05深入Java面向对象全文共47页,当前为第8页。 5.2 继承 5.2.1 继承的实现 【例5-1】 图5-2 创建子类Sector 图5-3 选择父类Circle 《Java程序设计案例教程》教学课件05深入Java面向对象全文共47页,当前为第9页。 5.2 继
### 回答1: this关键字是指当前对象,可以用来区分同名变量或方法的调用,也可以作为参数传递给其他方法。在Java中,每个对象都有自己的this指针,指向自己的内存地址。使用this关键字可以让程序更加清晰易懂,提高代码的可读性和可维护性。 ### 回答2: Java中,this关键字代表着当前对象,在一个类中使用this关键字可以代表该类的当前实例。使用this关键字,我们可以访问当前类中的成员变量和成员方法。 this关键字主要有以下两种用法: 1. 用于访问当前对象的成员变量或成员方法 在一个对象的成员方法中,可以使用this关键字来访问该对象的成员变量或成员方法。this关键字只能在非静态方法中使用。例如: public class Student{ private String name; private int age; public void setName(String name){ this.name = name; } public void setAge(int age){ this.age = age; } } 在上面的代码中,setName()和setAge()方法使用了this关键字来访问Student类的name和age成员变量。 2. 用于调用当前对象的其他构造方法 this关键字还可以用于调用当前对象的其他构造方法。在一个构造方法中,可以使用this()调用当前类的其他构造方法。注意,this()必须是构造方法的第一条语句。例如: public class Student{ private String name; private int age; public Student(String name){ this.name = name; } public Student(String name, int age){ this(name); //调用另一个构造方法 this.age = age; } } 在上面的代码中,第二个构造方法调用了第一个构造方法,通过this(name)来传递参数。 使用this关键字可以方便地访问当前对象的成员变量和成员方法,以及方便调用当前对象的其他构造方法。熟练使用this关键字有助于编写更加优美、可读性更佳的Java代码。 ### 回答3: this关键字Java中比较常用的一个关键字,它代表当前对象。当类中存在属性与方法参数ID或name相同时,为了区分使用this关键字引用类成员变量或方法变量。主要用法可以归纳为两种: 1. this指向当前对象,可以传递当前对象给另一个方法。 当我们在类的方法中需要使用当前对象时,可以使用this关键字。例如,我们需要让对象A将自己的某个属性赋值给另一个对象B,我们可以调用B对象的某个方法,并将当前对象A作为参数传递进去,即B.setObj(this); 2. this作为构造函数调用时,可以在构造函数中调用该类的另一个构造函数。 当一个类中定义了多个构造函数时,为了在不同场景下更方便地使用构造函数,我们可以在构造函数中调用该类的另一个构造函数,并传入参数。例如,在Book类中,我们定义了多个构造函数,但它们都需要初始化书名与作者属性,在Book类的某个构造函数中,我们可以调用另一个构造函数Book(this.Title,this.Author),this代表当前对象Book,Title和Author是当前对象的属性。 需要注意的是,在使用this关键字时,如果this后面不接任何属性名或方法名,则表示调用的是当前对象自身,否则表示调用的是当前对象的某个属性或方法。如果当前对象没有该属性或方法,则会在编译时报错。 总之,this关键字Java类和对象的编程中是非常重要的,它可以传递当前对象,调用类的构造函数,指向当前对象的属性或方法等,在使用Java进行编程时,有必要对this关键字有一个清晰的理解。

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值