02.java课复习

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()空指针异常