一、内部类
内部类:在一个类的内部,定义了一个完整的类。
class mather{
class son{
}
}
内部类可以访问外部类的私有成员,从而不破坏外部类的封装性。
分类:成员内部类、静态内部类、局部内部类、匿名内部类
成员内部类
- 在类的内部定义,与实现变量、实例方法同级别的类
- 外部类的一个实例部分,创建内部类对象时,必须依赖外部类对象
Outer out = new Outer();
Inner in = out.new Inner();
- 当外部类、内部类存在重名属性时,会优先访问内部类属性
- 成员内部类不能定义静态成员
public class main{
public static void main(String[] args){
Out out = new Out();
In in = out.new In();
System.out.println(in.q);//结果:10
in.function();//结果:你好
}
}
class Out{
class In{
int q = 10;
public void function(){
System.out.println("你好");
}
}
}
静态内部类
① 位置:定义在类以内,方法以外,被static修饰
② 静态内部类中可以定义静态成员和非静态成员
③ 创建静态内部类的对象只需要依赖于外部类的类名:
Outer.Inner i = new Outer.Inner();
④ 访问静态内部类的静态成员时,直接利用类名即可:
外部类名.内部类名.静态属性
外部类名.内部类名.方法名(实参);
⑤ 静态内部类中可以直接访问外部类的静态成员(静态的属性和方法);
但是不可以直接访问外部类的非静态成员。
局部内部类(类比局部变量)
① 位置:定义在方法以内,作用范围和创建对象范围仅限于当前方法
② 创建局部内部类对象必须在定义它的方法内部,并且必须在定义位置后面的地方可 以对其创建对象。
③ 局部内部类中可以访问定义它的方法内部的局部变量,但是要求局部变量必须加 final(java语法规定)
public class Innering{
public static void main(String[] args){
···
class myclass{
int q;
public void function(){
System.out.println("你好啊");
}
}
class Inner extends myclass{
int b = 20;
}
Inner in = new Inner();
in.q = 10;
in.function();//你好啊
ystem.out.println(in.b + in.q);//30
}
}
匿名内部类
① 匿名内部类是特殊的局部内部类
② 特点:
a. 匿名内部类必须实现一个接口或是继承一个父类
b. 基于匿名内部类只能创建该类的一个对象,而且匿名内部类的定义和对象的创建一起完成
没有类名的局部内部类(一切特征都与局部内部类相同),必须继承一个父类或者一个接口 定义类、实现类、创建对象的语法合并,只能创建一个该类的对象
优点: 减少代码量 缺点: 可读性差
二、常用类
1、Object类
(1)、超类、基类,所有类的直接或间接父类,位于继承树的最顶层。
任何类,如没有书写extends显示继承某个类,都默认为直接继承Object类,否则为间接继承
(2)、Object中常用的方法:
getClass()方法
getClass() 返回此 Object 的运行时该对象的类. 该方法返回一个Class对象, 可以通过该对象可以获取某个类的相关信息, 如构造方法 属性 方法 等.
public class textgetClass {
public static void main(String[] args) {
Doy doy = new Doy();
Class doyClass = doy.getClass();
System.out.println(doyClass);//结果:class textJava.Doy
}
}
class Doy {
private String name;
private int age;
private void showDoy(){
System.out.println(name+"有"+age+"个");
}
}
通常用于判断两个引用中实际存储对象类型是否一致
public class textgetClass {
public static void main(String[] args) {
Doy doy = new Doy();
Class doyClass = doy.getClass();
Cat cat = new Cat();
Class catClass = cat.getClass();
System.out.println(doyClass == catClass);//结果:false
}
class Doy {
private String name;
private int age;
private void showDoy(){
System.out.println(name+"有"+age+"个");
}
}
class Cat {
private String name;
private int q;
private void showDoy(){
System.out.println(name+"有"+q+"个");
}
}
}
hashCode()方法
返回该对象的十六进制的哈希码值
作用:已知散列表(Hash table,也叫哈希表),是根据关键码值(Key value)而直接进行访问的数据结构。也就是说,它通过把关键码值映射到表中一个位置来访问记录,以加快查找的速度。
public class textHashCode{
public static void main(String[] args){
Son son = new Son();
System.out.println(son.hashCode());//结果:460141958
System.out.println(son);//结果:textJava.Son@1b6d3586
}
class Son{···}
}
toString()方法
返回该对象的字符串表示(表现形式)
覆盖原则:将对象的所有属性拼凑成一个String结果作为返回值返回
字符串构成:对象.getClass().getName()+"@"+Integer.toHexString(对象.hashCode())。
public class text08 {
public static void main(String[] args) {
myString m1 = new myString();
System.out.println(m1.toString());//textJava.myString@4554617c
class myString{
}
}
//对象.getClass().getName()+"@"+Integer.toHexString
equals()方法
默认实现为(this == obj),比较两个对象地址是否相同
可进行覆盖,比较两个对象的内容是否相同
public boolean equals(Object o){
//将 this 和 o进行比较
//(1) 自反性:判断两个引用是否指向同样一个对象
if(this == o){
return true;
}
//(2)判断 o是否为空
if(o==null){
return false;
}
//(3) 判断两个引用中存储的实际对象类型是否一致
if(this.getClass()!=o.getClass()){
return false;
}
//(4) 强制类型转换–>对下一个步骤准备
当前对象类型 s = (当前对象类型)o;
//(5) 将属性内容进行比较:基本数据类型:==引用:equals比较
if(this.age==s.age && this.name.equals(s.name)){
return true;
}else{
return false;
}
}
finalize()方法
- 当对象被判定为垃圾对象时,由JVM自动调用此方法,用以标记垃圾对象
- 垃圾对象:没有有效引用指向此对象时,为垃圾对象
- 垃圾回收:由GC销毁垃圾对象,释放数据存储空间
- 自动回收机制:JVM的内存耗尽,一次性回收所有垃圾对象
- 手动回收机制:使用System.gc();通知JVM执行垃圾回收
包装类
8种基本数据类型对应的对象类型,称为基本数据类型的包装类。
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
8中包装类提供不同类型间的转换方式:
Number父类中提供的6个共性方法
parseXXX()静态方法
parseByte(“123”);
valueOf()静态方法
Byte b = new Byte.valueOf((byte)10);
Byte b = new Byte.valueOf(“20”);
String类
- 字符串是常量,创建之后不可改变
- 字符串字面值存储在字符串池中,可以共享
- 创建字符串对象的两种方式
String s = “Hello”; //产生一个对象,字符串池中存储
String s = new String(“Hello”); //产生两个对象,堆、池中各存储一个
String类常用方法:
//用法
public class textString {
public static void main(String[] args) {
String str = "a";
String string = "abcdefrg";
System.out.println(string.charAt(1));//结果:b
System.out.println(string.startsWith(str));//结果:true
System.out.println(string.toUpperCase(Locale.ROOT));//结果:ABCDEFRG
}
}
BigDecimal类
作用: 精确计算浮点数
创建方式:
BigDecimal bd = new BigDecimal(“1.0”);
方法:
BigDecimal add(BigDecimal2 bd)//+
BigDecimal subtract(BigDecimal bd)//-
BigDecimal multiply(BigDecimal bd)//*
BigDecimal divide(BigDecimal bd)///
BigDecimal bi1 = new BigDecimal("1.01");
BigDecimal bi2 = new BigDecimal("0.01");
BigDecimal result1 = bi1.add(bi2);
System.out.println(result1);//结果:1.02
三、异常
概念: 程序在运行过程中出现的特殊情况
异常处理的必要性: 任何程序都可能存在大量的未知问题、错误;如果不对这些问题进行正确处理,则可能导致程序的中断,造成不必要的损失。
异常的分类
Throwable: 可抛出的,一切错误或异常的父类,位于java.lang包下
Error: JVM、硬件、执行逻辑错误,不能手动处理
Exception: 程序在运行和配置中产生的问题,可处理
RuntimeException: 运行时异常,可处理,可不处理
CheckedException: 受查异常,必须处理
手动抛出异常:
语法:throw new 异常类型(“实际参数”);
异常的处理(try-catch-finally)
try{
异常代码
}catch(Exception e){
printStackTrace();//打印堆栈跟踪信息
}finally{
释放资源
}