Java易混知识点列表比较

• 类一级成员与实例成员

	类一级成员	实例成员
属于	类本身	类创建的实例对象
举例	static（变量/方法/初始化块）、内部类	普通成员
直接访问	类名.member	对象.member

 class superc{
    int i=5;
    void show(){System.out.println("the i is :"+i);}
}
public class subc extends superc{
    int i=6;
    public static void main(String[] arg){
    subc s=new subc();  
    System.out.println(s.i);
    s.show();  //父类域中的show
    }
}

output->
6
the i is :5
//变量i的访问权限修饰符缺省，继承后默认为同包可见
//在创建子类对象时，同名变量遵循变量遮蔽，覆盖父类i
//在调用show方法时，i的作用域为整个父类，包括方法

• 重载与重写

	重载overload	重写override
	类内	父子类间
方法名	同	同
参数列表	不同	同
返回值	（无关）	同
方法体	不同	不同
访问权限		不能比父类更严格

错了3个输出👆：B重写父类同名方法后没有A-A的输出

输出为：in Son.show-Father（f2向上转型后重写Father类内的Father方法，并损失掉Son/Grandson作为形参的特有方法

• 动态绑定与静态绑定

多态	动态绑定	静态绑定
	编译	运行
	重写方法oberride（类间，只异方法体）	重载方法overload（类内，只用同名）
	虚函数（能被子类重写的方法）	final、static、private修饰的方法
	实例方法	成员变量
绑定类型	对象类型（实际）	引用类型（声明）

• 接口与抽象类

	接口interface	抽象类abstract
	只有常量+抽象方法	至少一个抽象方法（只声明不实现）
方法默认	public abstract
常量(字段)默认	public static final
单个类可以有	多个接口	唯一抽象类
构造方法	没有	可以有
		不能被final修饰

• 简单工厂模式实现接口

enum CarType{ACar,BCar,CCar};

interface Car{
    void drive();
}
//具体类
class ACar implements Car{
    @Override
    public void drive(){System.out.println("ACar is ready");}
}
class BCar implements Car{
    @Override
    public void drive(){System.out.println("BCar is ready");}
}
class CCar implements Car{
    @Override
    public void drive(){System.out.println("CCar is ready");}
}

//工厂类
class CarFactory{
    public static Car getInstance(CarType ct){
        if(ct!=null)
            switch (ct) {
                case ACar:
                    return new ACar(); 
                case BCar:
                    return new BCar();
                case CCar:
                    return new CCar();
                default:
                    return null;
            }
        return null;
    }
}

public class test{
    public static void main(String[] args){
        //接口不能实例化，只能通过具体类实现向上转型
        Car c1=new ACar();
        c1.drive();
        Car c2=CarFactory.getInstance(CarType.BCar);
        c2.drive();
    }
}

• 内部类

	实例内部类	静态嵌套类	局部内部类	匿名内部类
属性	类成员	独立，类一级成员	类方法内，特性同局部变量
持有outer.this实例	1	0	0	1
可以被static修饰	1	1	0	0
依附outer实例	1	0	1	1
有constructor	1	1	1	0
访问outer的private	1	1	1	1
访问权限	outer所有（含private	outer静态成员	outer所有，方法的final局部变量	outer所有，方法的final局部变量

• 常考异常类

名称	描述
NullPointerException	空指针异常
IndexOutOfBoundsException	数组索引越界异常
ArithmeticException	算术异常，比如除以0
ClassCastException	类型转换异常，试图将一个对象强制转换为不兼容的类型
NumberFormatException	数字格式异常，将字符串转换为数字时格式错误
IllegalArgumentException	向方法传递了错误类型、空值、或者超出范围的值
IOException	输入输出异常，通常发生在文件操作中

• 从异常中获取信息

方法	类型	描述
e.getMessage()	String	获取异常的简要描述信息
e.toString()	String	返回异常的类名和详细消息，格式为：类名: 消息
e.printStackTrace()	void	将异常的堆栈跟踪信息打印到控制台
e.getStackTrace()	StackTraceElement 数组	异常对象相关的堆栈跟踪信息

area (test:10)
main (test:15)

• 抛出异常

	描述	词性	位置
throws	声明异常	预告	( )后{ }前
throw	抛出异常	行动	类体内

• String对象生成后值不变

//String类型常用函数
String str=new String("wer chinese, ur korean.");
System.out.println(str.length());
System.out.println(str.indexOf('r'));
System.out.println(str.startsWith("we"));
System.out.println(str.compareTo("hello"));
System.out.println(str.substring(1,5));
str=str.replaceAll("r "," are ");
System.out.println(str);
String[] strs=str.split("[,\\s]",4);
for(var v:strs)
    System.out.println(v);

• 四种遍历容器方式

//1.增强式for循环
for(String s:a)
    System.out.println(s);

//2.foreach
a.forEach(o->{System.out.println(o);});

//3.迭代器iterator
Iterator<String> i=a.iterator();
while(i.hasNext())
    System.out.println(i.next());

//4.普通for
for(int j=0;j<a.size();j++)
    System.out.println(a.get(j));