1.抽象类 不能被实例化(有抽象方法class必须写abstract)(专门做父类被继承),不能加final,static,private也不能加在方法上,static直接用类可以调用
abstract class A{
abstract void xxx();
void xxx1(){};
}
class B extends A{
void xxx(){
}
}
A a=new B();
2.接口
public interface f1{
int i=10; //等价final static int i=10;静态常量
void xx();//默认abstract
//jdk1 - 7.0 后 8.0允许默认方法有方法体
default void aaa(){
}
//允许静态方法
static void bbb(){
}
//接口可以继承接口
interface f2 extends k2,k1{
}
//普通类不能继承接口,类实现接口
class cc implements f2{
}
//实现的类可以new出来调用
//类方法,就是接口名.出来 fi.bbb(); 不属于new出来的
//权限大,才可以改写
}
//接口 的变量被子类继承
``private 空 protected public
3.(成员)内部类 a是t2的内部类, t2是a的外部类,和其他成员平级
可以访问我们外面成员(方法,类)
public class T2{
class A{
}
}
A a1=A();//(x)找不到那个内部类
//先new 外部类
T2 t2=new T2();
T2.A a=t2.new A();
//等同
T2.A a=new T2().new A();
4.静态内部类(内部类加static)(静态成员,不可以访问非静态成员)
T2.A a=new A.A11();
5.方法内部类(在方法里面定义类,只能在方法里面定义)
void aa(){
class AA{
}
AA aa=new AA();
}
6.匿名类(抽象类可以new,覆盖了父类的方法,相当于上转型对象)({}代表匿名类)
Speak speak =new Speak(){
//实际上是匿名类改写父类的方法
public void aa(){
}
public void bb(){//这个是新增的方法,上转型会失去,调用报错
}
};
speak.aa();
/****相当于****/
class R extends Speak{
public void aa(){
}
}
7.内部类可以访问外部类中的私有成员
8.内部类有多种访问权限
9.!!lambda表达式(简化代替匿名内部类,不是任何时候都可以用)
interface Inter{ void f1(int a)
}Inter inter2=(a)->{sout("xxx")}; Inter inter2=a->{sout("xxx")}; //只能单接口(一个接口一个方法) inter2.f1(5);
10.异常处理
异常: 程序运行出现的错误
1.数组越界
2.除数为0
异常的分类
1. Throwable是所有异常的父类
--Error(系统错误)-- --Exception(可以处理的异常)----
-------------- (检查型异常,必须捕获)----- RuntimeException(可以不处理<捕获>非检查异常)-------
FileReader fileReader=new FileReader("F:A.TXT");//必须要捕获,
异常处理
//相当于 if | else if | else
try{
//有可能出现异常的代码
}catch(ArithmeticException e){
//Exception e
}catch(InputMismatchException e){
}finally{
//无论是否执行
}
//只会有一个异常被捕获,要从小异常到到异常(子类到父类)
11.抛出异常(回避异常)(子类的异常给父类处理)
throws与throw区别
throws抛出异常类型
throw 生成异常对象
//抛给调用这个方法的程序,一层一层处理,最后给虚拟机
public double aa() throws Exception{ //抛出异常类
if(r<0){
throw new Exception();
} //必须要处理,try catch,或者在父类
}
public class testException {
class AA{
AA(int a) throws Exception {
if(a==0){
throw new MyException();
}
}
}
public static void main(String[] args) {
testException testException = new testException();
try{
AA aa = testException.new AA(0);
}catch (Exception e){e.printStackTrace();}
System.out.println("continue");
}
class MyException extends Exception{
MyException(){
System.out.println("发生异常");
}
}
}
12.自定义异常(异常的语句先于return执行)
class xxxException extends Exception{
public xxxException(){
sout("不合法")
}
}
try{}catch(Exception e){}//方法体不写直接调用构造方法
//父类抛出异常,子类只能抛出相同的异常或者不抛出
//return在所有异常后执行(对异常处理没有影响)
下面一段代码的执行输出结果是( )。
下面一段代码的执行输出结果是( )。
try {
System.out.print("try ");
return;
} finally {
System.out.print("finally ");
}
try-->finally-->return
//System.exit(0);直接离开下面的finally
//null.length()空指针异常