JAVA学习打卡第八天——JAVA常用类
内部类
什么是内部类
-
在一个类的内部再定义一个完整的类
class Outer { class Inner { } } -
内部类特点
-
编译后可生成独立的字节码文件
-
内部类可以直接访问外部类的私有成员，而不破坏封装
public class Body { private String name; class Header { public void show() { System.out.println(name); } } } -
可以为外部类提供必要的内部功能组件
-
成员内部类
-
在类的内部定义，与实例变量、实例方法同级别的类
-
外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象
-
当外部类、内部类存在重名属性时，会优先访问内部类属性
-
成员内部类不能定义静态成员，但可以包含静态常量
-
示例
//外部类 public class Outer { //实例变量 private String name = "xianyun_out"; private int age = 20; //内部类 class Inner { private String address = "Beijing"; private String phone = "110"; private String name = "xianyun_in"; private static final String country = "ya'an"; private static String school = "sc";//编译报错 public void show() { //打印外部类的属性 System.out.println(Outer.this.name);//内部类存在同名属性时，访问外部类 System.out.println(age); //打印内部类的属性 System.out.println(name); System.out.println(address); System.out.println(phone); } } }public class Test { public static void main(String[] args) { //创建一个外部类对象 Outer outer = new Outer(); //创建内部类对象 Outer.Inner inner_1 = outer.new Inner(); //一步到位 Outer.Inner inner_2 = new Outer().new Inner(); inner_1.show(); System.out.println("================="); inner_2.show(); } }
静态内部类
-
不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员
-
示例
public class Outer { private String name = "xxx"; private int age = 20; //静态内部类：级别和外部类相同 static class Inner { private String address = "Shanghai"; private String phone = "111"; private static int count = 1000; public void show() { //调用外部内成员：创建外部类对象，再调用 Outer outer = new Outer(); System.out.println(outer.name); System.out.println(outer.age); //调用静态内部类的成员：直接调用 System.out.println(address); System.out.println(phone); //调用静态内部类的静态属性 System.out.println(Inner.count); } } }public class test { public static void main(String[] args) { //直接创建静态内部类对象 Outer.Inner inner = new Outer.Inner(); //调用方法 inner.show(); } }
局部内部类
-
定义在外部类方法中，作用范围和创建对象范围仅限于当前方法
-
局部内部类中不能包含静态成员，但可以包含静态常量
-
局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final
-
示例
public class Outer { private String name = "xxx"; private int age = 20; public void show() { //定义局部变量 String address = "Ya'an"; //局部内部类：前面不能加任何访问修饰符 class Inner { //局部内部类属性 private String phone = "111"; private String email = "111@qq.com"; //局部内部类方法 public void show2() { //访问外部类属性：直接访问 System.out.println(Outer.this.name); System.out.println(Outer.this.age); //访问内部类属性：直接访问 System.out.println(this.phone); System.out.println(this.email); //访问方法的局部变量：直接访问，但此变量默认变成常量，后续无法再改变 System.out.println(address); } } //在方法内部创建对象 Inner inner = new Inner(); inner.show2(); } }public class test { public static void main(String[] args) { Outer outer = new Outer(); outer.show(); } }
匿名内部类
-
没有类名的局部内部类（一切特征都与局部内部类相同）
-
必须继承一个父类或者实现一个接口
-
示例
-
public interface USB { void service(); }public class Mouse implements USB { public void service() { System.out.println("连接电脑成功，鼠标开始工作"); } }public class testUsb { public static void main(String[] args) { //创建接口类型的变量 USB usb = new Mouse(); usb.service(); //局部内部类连接接口 class Fan implements USB { public void service() { System.out.println("连接电脑成功，风扇开始工作"); } } //使用局部内部类创建对象 USB usb_2 = new Fan(); usb_2.service(); //匿名内部类 USB usb_3 = new USB() { public void service() { System.out.println("连接电脑成功，风扇工作开始……"); } }; usb_3.service(); } }
Object类
- 超类、基类，所有类的直接或间接父类，位于继承树的最顶层
- 任何类，如没有书写extends显示继承某个类，都默认直接继承Object类，否则为间接继承
- Object类中所定义的方法，是所有对象都具备的方法
- Object类型可以存储任何对象
- 作为参数，可接受任何对象
- 作为返回值，可返回任何对象
Object类常用方法
getClass()方法
-
public final Class<?> getClass(){}
-
返回引用中存储的实际对象类型
-
应用：通常用于判断两个引用中实际存储对象类型是否一致
-
示例
public class Student { private String name; private int age; public Student() { } public Student(String name, int age) { super(); this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } }public class test { public static void main(String[] args) { Student student_1 = new Student("student_1", 18); Student student_2 = new Student("student_2", 17); //判断 student_1 和 student_2 是不是同一个类型 Class class_1 = student_1.getClass(); Class class_2 = student_2.getClass(); if (class_1 == class_2) { System.out.println("student_1 和 student_2 属于同一个类型"); } else { System.out.println("student_1 和 student_2 不属于同一个类型"); } } }
hashCode()方法
-
public int hashCode(){}
-
返回该对象的哈希码值
-
哈希值是根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值
-
一般情况下相同对象返回相同哈希码
-
示例
package Javastudy.Day_8.Student; public class test { public static void main(String[] args) { Student student_1 = new Student("student_1", 18); Student student_2 = new Student("student_2", 17); System.out.println(student_1.hashCode()); System.out.println(student_2.hashCode()); } }
toString()方法
-
public String toString(){}
-
返回该对象的字符串表示（表现形式）
-
可以根据程序需求覆盖该方法，如：展示对象各个属性值
-
示例
public class Student { private String name; private int age; public Student() { } public Student(String name, int age) { super(); this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } //重写toString方法 public String toString() { return name + ";" + age; } }package Javastudy.Day_8.Student; public class test { public static void main(String[] args) { Student student_1 = new Student("student_1", 18); Student student_2 = new Student("student_2", 17); //toString： //原始定义 System.out.println(student_1.toString());//Javastudy.Day_8.Student.Student@1b6d3586 System.out.println(student_2.toString());//Javastudy.Day_8.Student.Student@4554617c //重写后 System.out.println(student_1.toString());//student_1;18 System.out.println(student_2.toString());//student_2;17 } }
equals()方法
-
public boolean equals(Object object) {}
-
默认实现为(this == objt)，比较两个对象地址是否相同
-
可进行覆盖，比较两个对象的内容是否相同
-
equals方法覆盖步骤
- 比较两个引用是否指向同一个对象
- 判断obj是否为null
- 判断两个引用指向的实际对象类型是否一致
- 强制类型转换
- 依次比较各个属性值是否相同
-
示例
public class Student { private String name; private int age; public Student() { } public Student(String name, int age) { super(); this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } //重写equals方法 public boolean equals(Object obj) { //判断两个对象是否是同一个引用 if(this == obj) { return true; } //判断obj是否为null if(obj == null) { return false; } //判断是否是同一个类型 if(obj instanceof Student) { //强制类型转换 Student s = (Student) obj; //比较属性 if (this.name.equals(s.getName()) && this.age == s.getAge()) { return true; } } return false; } }package Javastudy.Day_8.Student; public class test { public static void main(String[] args) { Student student_1 = new Student("student_1", 18); Student student_2 = new Student("student_2", 17); //equals： System.out.println(student_1.equals(student_2));//false //定义两个内容相同的对象 Student student_4 = new Student("student_s", 18); Student student_5 = new Student("student_s", 18); //原始方法 System.out.println(student_5.equals(student_4));//false //重写后 System.out.println(student_5.equals(student_4));//true } }
finalize()方法
-
当对象被判定为垃圾对象时，有JVM自动调用此方法，用以标记垃圾对象，进入回收队列
-
垃圾对象：没有有效引用指向此对象时，为垃圾对象
-
垃圾回收：由GC销毁垃圾对象，释放数据存储空间
-
自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象
-
手动回收机制：使用System.gc()；通知JVM执行垃圾回收
-
示例
-
package Javastudy.Day_8.Student; public class Student { private String name; private int age; public Student() { } public Student(String name, int age) { super(); this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } //重写finalize() public void finalize() throws Throwable { System.out.println(this.name + "对象被回收了"); } }public class test_2 { public static void main(String[] args) { Student s1 = new Student("aaa", 20); Student s2 = new Student("bbb", 20); Student s3 = new Student("ccc", 20); Student s4 = new Student("ddd", 20); Student s5 = new Student("eee", 20); new Student("fff", 20); new Student("ggg", 20); new Student("hhh", 20); new Student("iii", 20); new Student("jjj", 20); //回收垃圾 System.gc(); System.out.println("回收垃圾"); } }
包装类
-
包装类就是基本数据类型所对应的引用数据类型
-
Object可统一所有数据，包装类的默认值是null
基本数据类型 包装类型 byte Byte short Short int Integer long Long float Float double Double boolean Boolean char Character
类型转换与装箱、拆箱
-
装箱：基本类型转换为引用类型
-
拆箱：引用类型转换为基本类型
-
8种包装类提供不同类型间的转换方式：
-
Number父类中提供的6个共性方法
public class test { public static void main(String[] args) { //JDK1.5前 //类型转换：装箱，基本类型---------->引用类型 int num1 = 18;//基本类型（存放于栈空间） //使用Integer类创建对象 Integer integer1 = new Integer(num1);//integer：引用类型，存放于堆空间 Integer integer2 = Integer.valueOf(num1); System.out.println("装箱"); System.out.println(integer1); System.out.println(integer2); //类型转换：拆箱，引用-------------->基本 Integer integer3 = new Integer(100);//引用类型（存放于堆空间） int num2 = integer3.intValue();//num2：基本类型，存放于栈空间 System.out.println("拆箱"); System.out.println(num2); //JDK1.5后：自动装箱 int age = 30;//基本类型 //自动装箱 Integer integer4 = age; System.out.println("自动装箱"); System.out.println(integer4); //自动拆箱 int age2 = integer4; System.out.println("自动拆箱"); System.out.println(age2); } } -
parseXXX()静态方法
public class test2 { public static void main(String[] args) { //基本类型和字符串之间转换 //基本类型转成字符串 int num1 = 255; //使用“+” String str1 = "" + num1; //使用Integer中的toString()方法 String str2 = Integer.toString(num1); System.out.println(str1); System.out.println(str2); //toString重载方法：toString(num, 进制) String str3 = Integer.toString(num1, 16); System.out.println(str3); //字符串转成基本类型 String str = "150"; //使用Integer.parseXXX() int n1 = Integer.parseInt(str); System.out.println(n1); //boolean字符串形式转成基本类型 String str4 = "true"; boolean b1 = Boolean.parseBoolean(str4); System.out.println(b1); } } -
valueOf()静态方法
-
整数缓冲区
-
Java预先创建了256个常用的整数包装类型对象
-
在实际应用当中，对已创建的对象进行复用
-
示例
public class integer { public static void main(String[] args) { Integer integer1 = new Integer(100); Integer integer2 = new Integer(100); System.out.println(integer1 == integer2);//false Integer integer3 = 100;//-------> Integer integer3 = Integer.valueOf(100) Integer integer4 = 100; System.out.println(integer3 == integer4);//true Integer integer5 = 200; Integer integer6 = 200; System.out.println(integer5 == integer6);//false } }
String类
-
字符串是常量，创建之后不可改变
-
字符串字面值存储在字符串池中，可以共享
-
String s = “Hello”；产生一个对象，字符串池中存储
-
String s = new String(“Hello”)；产生两个对象，堆、池中各存储一个
-
示例
public class test_1 { public static void main(String[] args) { String name = "Hello";//“Hello”常量存储在字符串池中 name = "zhangsan";//"zhangsan"赋值给name，并未改变"Hello"，而是在字符串池中再开辟空间 String name2 = "zhangsan"; System.out.println(name == name2);//true String str = new String("java");//堆和池中都产生"java",str指向堆中 String str1 = new String("java"); String str2 = "java"; System.out.println(str == str2);//false System.out.println(str == str1);//false System.out.println(str2.equals(str));//true------->String中重写了equals } }
常用方法
-
public int length()：返回字符串长度
-
public char charAt(int index)：根据下标获取字符
-
public boolean contains(String str)：判断当前字符串中是否包含str
-
public char[] toCharArray()：将字符串转换成数组
-
public int indexOf(String str)：查找str首次出现的下标，存在，则返回下标，不存在，则返回-1
-
public int lastIndexOf(String str)：查找字符串在当前字符串中最后一次出现的下标索引
-
public String trim()：去掉字符串前后的空格
-
public String toUpperCase()：将小写转成大写
-
public boolean endWith(String str)：判断字符串是否以str结尾
-
public String replace(char oldChar,char newChar)：将旧字符串替换成新字符串
-
public String[] split(String str)：根据str做拆分
-
示例
import java.util.Arrays; public class test_2 { public static void main(String[] args) { //字符串常用方法 String content = "java 是 世界上 最好的 编程语言"; String content2 = " Hello world "; //leagth() System.out.println("==========length=========="); System.out.println(content.length()); //charAt(int index) System.out.println("==========charAt=========="); System.out.println(content.charAt(0)); System.out.println(content.charAt(18)); //contains(String str) System.out.println("==========contains=========="); System.out.println(content.contains("java")); System.out.println(content.contains("php")); //toCharArray(String str) System.out.println("==========toCharArray=========="); System.out.println(Arrays.toString(content.toCharArray())); //indexOf(String str) System.out.println("==========indexOf=========="); System.out.println(content.indexOf("世界上")); System.out.println(content.indexOf("php")); //lastIndexOf System.out.println("==========lastIndexOf=========="); System.out.println(content.lastIndexOf("java")); System.out.println(content.lastIndexOf("php")); //trim System.out.println("==========trim=========="); System.out.println(content2.trim()); //toUpperCase、toLowerCase System.out.println("==========toUpperCase、toLowerCase=========="); System.out.println(content2.toUpperCase()); System.out.println(content2.toLowerCase()); //endWith、startWith System.out.println("==========endWith、startWith=========="); String filename = "hello.java"; System.out.println(filename.endsWith(".java")); System.out.println(filename.startsWith("hello")); //replace System.out.println("==========replace=========="); System.out.println(content.replace("java", "php")); //split System.out.println("==========split=========="); String say = "java is the best programing language"; String[] str = say.split(" "); System.out.println(str.length); for (String s : str) { System.out.println(s); } //equals、equalsIgnoreCase String s1 = "hello"; String s2 = "HELLO"; System.out.println("==========equals=========="); System.out.println(s1.equals(s2)); System.out.println("==========equalsIgnoreCase=========="); System.out.println(s1.equalsIgnoreCase(s2)); //compareTo System.out.println("==========compareTo=========="); String s3 = "abc"; String s4 = "xyz"; System.out.println(s3.compareTo(s4)); } }
-
可变字符串
-
StringBuffer：可变长字符串，JDK1.0提供，运行效率慢、线程安全
-
StringBuilder：可变长字符串，JDK5.0提供，运行效率快、线程不安全
public class test3 { public static void main(String[] args) { // StringBuffer sb = new StringBuffer(); StringBuilder sb = new StringBuilder(); //追加 sb.append("java"); System.out.println(sb); sb.append(" and php"); System.out.println(sb); //insert sb.insert(0,"I say:"); System.out.println(sb); //replace sb.replace(0, 5, "you say"); System.out.println(sb); //delete sb.delete(0, 8); System.out.println(sb); } }
-
BigDecimal类
-
很多实际应用中需要精确运算，而double是近似值存储，不符合要求，需要借助BigDecimal
-
位置：java.math包中
-
作用：精确计算浮点数
-
创建方式：BigDecimal bd = new BidDecimal(“1.0”);
-
示例
import java.math.BigDecimal; public class testBigDecimal { public static void main(String[] args) { double d1 = 1.0; double d2 = 0.9; //正常计算：精度丢失 System.out.println("==========正常计算=========="); System.out.println(d1 - d2); //借助BigDecimal System.out.println("==========BidDecimal=========="); BigDecimal bd1 = new BigDecimal("1.0"); BigDecimal bd2 = new BigDecimal("0.9"); System.out.println("加法：" + bd1.subtract(bd2)); System.out.println("减法：" + bd1.add(bd2)); System.out.println("乘法：" + bd1.multiply(bd2)); System.out.println("除法：" + bd2.divide(bd1));//如果除不尽则会报错 } }
109
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
