1.包装类
1.1 包装类的特点
包装类的使用场景和优点:
1）某些方法的参数必须是对象，为了让基本数据类型的数据作为参数；
2）包装类还提供更多的功能例如:
- 获得类型的最大值:Integer.
MAX_VALUE- 最小值Integer.
MIN_VALUE- 将一个包装类型转为基本数据类型integer.
doubleValue()- 将字符串转化为数字Integer.
parseInt("100")- 将数字转化为字符串Integer.
toString(10)。等等3）其他重要的功能:可以实现字符串和基本数据类型的相互转换
Java是面向对象型语言，我们给八大基本类型分别对应一个包装类,包装类均位于java.lang包：
| 基本数据类型 | 包装类：属于引用类型 |
|---|---|
| byte | java.lang.Byte（父类Number） |
| short | java.lang.Short（父类Number） |
| int | java.lang.Integer（父类Number） |
| long | java.lang.Long（父类Number） |
| float | java.lang.Float（父类Number） |
| double | java.lang.Double（父类Number） |
| char | java.lang.Character（父类Object） |
| boolean | java.lang.Boolean（父类Object） |
1.2 父类Number方法
| 方法名 | 作用 |
|---|---|
| byte byteValue() | 以 byte 形式返回指定的数值 |
| abstract double doubleValue() | 以 double 形式返回指定的数值 |
| abstract float floatValue() | 以 float 形式返回指定的数值 |
| abstract int intValue() | 以 int形式返回指定的数值 |
| abstract long longValue() | 以 long形式返回指定的数值 |
| short shortValue() | 以 short形式返回指定的数值 |
以上这些方法的 数字包装类的 子类都有；方法作用：拆箱
1.3 手动装箱、拆箱
package com.lCommonClasses.packages;
public class Integer1 {
public static void main(String[] args) {
/**这个基本数据类型，进行构造方法的包装达到了：
* 基本数据类型向引用数据类型的转换。*/
// 基本数据类型 -(转换为)->引用数据类型（装箱）
Integer integ = new Integer(129);
System.out.println(integ);
// 将引用数据类型--(转换为)-> 基本数据类型
double dv = integ.doubleValue();
System.out.println(dv);
}
}
1.4 构造方法
Jdk1.9适用，Jdk1.9之后就不推荐
1）Byte、Short、Long、Float、Double、Boolean的构造方法和Integer的构造方法一样。
//public 包装类名字(基本数据类型名字 value)
public Integer(int value) { this.value = value; }
public Integer(String s) throws NumberFormatException {
this.value = parseInt(s, 10);
}
2）Character只有一个构造方法
public Character(char value) {
this.value = value;
}
3）Float共有三个构造方法
还有一个构造方法，如下：
public Float(double value) {
this.value = (float)value;
}
package com.lCommonClasses.packages;
/**
* 包装类的手动装箱、拆箱
*/
public class Integer1 {
public static void main(String[] args) {
/**1.这个基本数据类型，进行构造方法的包装达到了：
* 基本数据类型向引用数据类型的转换。*/
// 基本数据类型 -(转换为)->引用数据类型（装箱）
Byte b = new Byte((byte) 6);
Short s = new Short((short) 8);
Integer i = new Integer(10);
Long l = new Long("12");
Float f = new Float(1.40);
Double d = new Double("1.60");
Character c = new Character('g');
Boolean bool = true;
System.out.println(b);
// 将引用数据类型--(转换为)-> 基本数据类型
double dv = i.doubleValue();
System.out.println(dv);
/** 2.包装类常量 */
System.out.println(Short.MAX_VALUE);
System.out.println(Double.MIN_VALUE);
}
}
1.5 自动装箱和拆箱
自动装箱：基本数据类型自动转换成包装类；（自动装箱实际上是
new 对象了）
自动拆箱：包装类自动转换成基本数据类型
优点：
- 方便编程；
- 有了自动拆箱之后，Number类中的方法就用不着了
1.5.1 code
package com.lCommonClasses.packages;
public class Integer1 {
public static void main(String[] args) {
/** 3.自动装箱和拆箱（jdk1.5新特性）*/
//基本数据类型--(自动转换)-->包装类型:自动装箱
Integer x= 1024;//等同于:Integer z= new Integer(900);
System.out.println(x +1);
//包装类型--(自动转换)-->基本数据类型:自动拆箱
int i1= x;//x:包装类型; y:基本数据类型
System.out.println(i1);
//自动装箱实际上是 new对象了
Integer x1= 1024;
System.out.println(x== x1);//false：比较的是引用地址
System.out.println(x.equals(x1));//true
}
}
特点：
==不会触发自动拆箱机制==永远判断的都是两个对象的内存地址是否相同。- 只有
+ - * /等运算的时候才会触发自动拆箱机制
1.5.2 （方法区）整数型常量池
1）java中为了提高程序的执行效率，将 [-128 ~ 127] 之间所有的包装对象提前创建好， 放到了一个方法区的“整数型常量池”当中了。
2）目的：只要用这个区间的数据不需要再new了，直接从整数型常量池当中取出来。
1.6 Integer包装类的方法
注意： Byte、Short、Long、Float、Double、Boolean 和 Integer的方法差不多相同。
| 方法名: | 作用 |
|---|---|
| static Integer decode(String nm) | 将String转成Integer |
| static int compare(int x, int y) | x=y: 返回 0；x> y: 返回 1；x< y: 返回 -1 |
| static int signum(int i) | 符号函数；负数: 返回-1；正数: 返回1；0: 返回0 |
| static String toBinaryString(int i) | 将i转成 二进制 |
| static String toOctalString(int i ) | 将i转成 八进制 |
| static String toHexString(int i) | 将i转成 十六进制 |
static int parseInt(String s) | 字符串转int |
static Integer valueOf(String s) | 字符串转Integer |
String toString() | Integer转String |
boolean equals(Object obj) | 判断两个Integer是否相等 |
package com.lCommonClasses.packages;
/** Integer 的方法使用 */
public class Integer2 {
public static void main(String[] args) {
Integer integer= Integer.decode("+127");
System.out.println(integer);//自动拆箱
String st1= "110";
Integer in1= -10;
Integer in2= 10;
//1.parseInt(String s);字符串转int
System.out.println(Integer.parseInt(st1));//110
/*2.valueOf(String s); 字符串 转成Integer;class java.lang.Integer
decode(String nm); String转成Integer;class java.lang.Integer*/
System.out.println(Integer.valueOf(st1).getClass());
System.out.println(Integer.decode(st1).getClass());
//3.toString(int i); Integer转String;class java.lang.String
System.out.println(Integer.toString(in1).getClass());
//4.a.equals(b); 判断两个Integer是否相等;
System.out.println(in1.equals(in2));//false
//5.compare(a,b); 比较 a、b的大小;in1< in2:-1
System.out.println(Integer.compare(in1, in2));
//6.signum(int i); 符号函数: <0:-1; >0:1; =0:0
System.out.println(Integer.signum(in1));//-1
System.out.println(Integer.signum(in2));//1
/*7.toBinaryString(int i);将i转成 二进制;11111111111111111111111111110110
toOctalString(int i);将i转成 八进制;37777777766
toHexString(int i);将i转成 十六进制;fffffff6 */
System.out.println(Integer.toBinaryString(in1));
System.out.println(Integer.toOctalString(in1));
System.out.println(Integer.toHexString(in1));
}
}
1.7 Character方法
| 方法名 | 作用 |
|---|---|
| char charValue() | 将Character转成char |
| int compareTo(Character anotherCharacter) | 判断两个Character是否相等；相等返回0；前大后小返回1；后大前小返回-1 |
| 常用方法 | |
| boolean equals(Object obj) | 判断两个Character是否相等 |
| String toString() | 将Character转成String |
| static boolean isDigit(char ch) | 判断ch是不是数字 |
| static boolean isLetter(char ch) | 判断ch是不是字母 |
| static boolean isLetterOrDigit(char ch) | 判断ch是不是字母或数字 |
| static boolean isLowerCase(char ch) | 判断ch是不是小写字母 |
| static boolean isUpperCase(char ch) | 判断ch是不是大写字母 |
| static boolean isSpaceChar(char ch) | 判断ch是不是空格 |
| static Character valueOf(char c) | 将char转成Character |
package com.lCommonClasses.character;
/** Character方法 */
public class Character1 {
public static void main(String[] args) {
Character a = 'a';
Character b = 'B';
/*1.charValue(); 将Character转成char;a
valueOf(char c); 将char转成Character; a */
System.out.println(a.charValue());
System.out.println(Character.valueOf(a));
//2.equals(); 判断两个Character是否相等;false
System.out.println(a.equals(b));
/*3.toString(); 将Character转成String;
class java.lang.String*/
System.out.println(b.toString().getClass());
Character c = '6';
//4.isDigit(char ch); 判断ch是不是数字; true
System.out.println(Character.isDigit(c));
//5.isLetter(char ch); 判断ch是不是字母;false
System.out.println(Character.isLetter(c));
/*6.isLetterOrDigit(char ch);
isLetterOrDigit(int codePoint);
判断ch是不是字母或数字;true / true */
System.out.println(Character.isLetterOrDigit(a));
System.out.println(Character.isLetterOrDigit(c));
//7.isLowerCase(char ch); 判断ch是不是小写字母; true
System.out.println(Character.isLowerCase(a));
//8.isUpperCase(char ch);判断ch是不是大写字母; true
System.out.println(Character.isUpperCase(b));
//9.isSpaceChar(' ');判断ch是不是空格; true
System.out.println(Character.isSpaceChar(' '));
/*10. a.compareTo(b);判断两个Character是否相等:
a=b:返回0; a>b:返回1; a<b:返回-1 */
System.out.println(a.compareTo(b));//-1
}
}
2. File类
创建文件：create new file
查看文件：find、madir、canRead、length、getPath
修改文件：
删除文件：delete
//TODO
8.枚举
所有的枚举类型隐性地 继承自java.lang.Enum。枚举实质上还是类，而每个被枚举的成员实质就是一个枚举类型的实例，他们默认都是public static final 修饰的。可以直接通过枚举类型名使用它们。
注意:
强烈建议当你需要定义一组常量时，使用枚举类型;
另外尽量不要 使用枚举的高级特性
package com.lCommonClasses.gEnum;
/**
* 枚举就是用来表示有限个数的定值,
* 不能输入别的参数使用,限制用户输入数据.
*/
public enum Gender {
Man,Woman
}
package com.lCommonClasses.gEnum;
public class Enum1 {
public static void main(String[] args) {
AddPerson person = new AddPerson("张三", Gender.Man);
System.out.println(person+
person.getName()+person.getGender());
}
}
class AddPerson{
String name ;
Gender gender;
public AddPerson() {}
public AddPerson(String name, Gender gender) {
this.name = name;
this.gender = gender;
}
public String getName() { return name; }
public Gender getGender() { return gender; }
@Override
public String toString() {
return "AddPerson{" +
"name: '" + name + '\'' +
", gender: '" + gender +
'\'' + '}';
}
}
476
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
