7_31上午&下午复习

抽象类

关键字abstract  有抽象方法的类就叫做抽象类,不能被private修饰

特点:

1． 抽象类可以被继承、可以多态

2． 与普通的类相比,在抽象类中,可以有抽象方法,也可以有别的方法。普通类中没有抽象方法

3． 抽象方法、抽象类前有abstract修饰

 

1．抽象方法的表示:

public abstract void per();

         特点:    抽象方法没有实现方法

 

2．抽象类要在类名前加abstract

     abstract  class A

{

}

3．父类与子类中使用抽象方法

父类中抽象方法不能直接在子类中使用,子类要使用父类中的抽象方法,就必须先实现该抽象方法

 

4.      抽象类与普通类的不同

               à ①抽象类有抽象方法

               à ②抽象类不能new,即不能生成对象

例如:   Public abstractclass person

{

}

       Publiccalss student extends person {

Person p1= new person();  //错误 person是抽象类;

Person p1= new student();

 //正确抽象类可以等于它的子类创建的对象,student不是抽象类

}

接口

使用关键字 implement interface

接口的特点:

1． 接口中的方法都是抽象方法

2． 接口中的变量都是常量

3.  一个类implement接口类就必须实现接口中的所有的抽象方法

4．接口可以多态,但不能生成对象

5．接口类生成的对象=实现接口的类生成的对象

6．接口可以继承接口

interface 表示接口类 implement表示引用接口类

例子:

 publicinterface Comput

        { int max=100; //原型为 public static  final  int  max=100;

         int f();      //原型为 public  abstract int  f();

         int f(int s);  //原型为 public abstract int  f(int s);

        }

         public class A implements Comput  //引用接口后要实现方法

          { intb;

            Public int f()

               { System.out.println(“你好”);}

            Public int f(int s)

              {System.out.println(“你好”);}

         }

 

 普通类继承与接口继承的区别

Java ①普通类只能有一个父类,但能实现多个接口,用”,”分开

②接口可以继承多个父类

例如:

Publicinterface person extends a,b,{}//正确

Public classperson extends a,b,{}  //错误 因为①

 

 

 

下午

Final

Final定义的变量不能修改,final修饰变量是常量

Final 修饰的变量没有默认值

Final定义方法,不能被子类覆盖

Final修饰的类不能做父类,即没有子类

 

Finally

finally{}里的语句,不管有没有其他中断语句,不管有没有异常/中断,一定执行,除非停电,且在return之前执行

 

Static

静态的变量共用一个内存空间,类生成的对象公用同一个内存空间

非静态的变量拥有独立的空间

 

一个类中静态方法与实例方法的区别:

①类中静态的方法只能访问静态的变量,静态的方法

②非静态的方法可以访问静态及非静态的变量/方法

在父类与子类中的区别:

①   父类中的静态的方法/变量在子类中可以直接通过父类的类名来访问

②    而非静态的东西只能通过创建对象来访问

访问权限

权限从高到低排列顺序:

   Public  protected 友好的  private

Public è 在本身类中,访问不受限制

在任何类中都可以通过类名访问

创建对象后可以,可以用对象访问

 

Private è 在本身类中,访问不受限制

在另外的类中创建对象,也不能访问

任何类中都不能通过类名访问

 

Protect  è在本身类中,访问不受限制

在同一个包中可以通过类名访问,

创建对象后可以,可以用对象访问

不同包可以,有继承关系的  

 

Friendly è缺省的

        在本身类中,访问不受限制

在同一个包中可以通过类名访问,

创建对象后可以,可以用对象访问

不同的包不可以

继承中访问权限

Public 在继承中访问无限制

 

子类与父类在同一个包中:

      子类继承其父类中所有不是private变量、方法。且访问权限不变

 

子类与父类不在同一包中：

     子类继承父类中的protected  public变量、方法。且访问权限不变

 

异常 try&catch

一.  try{}不能单独使用

try {}可以跟catch{}一起使用

try {}也可以跟finally{}一起使用

 

二.  try{}内用来存放可能产生异常的语句

catch{}内用来捕获异常

例子: publicclass yanzhen {

        publicstaticvoid main(String[]args) {

       System.out.println("请输入年龄");

       Scanner sc=new Scanner(System.in); //生成键盘输入的对象

       int age=0;

       try{ //有可能出现异常的代码写在try块中

            age=sc.nextInt();//接受年龄

            System.out.println("aaaaa");

}

catch(Exception e){ //捕获异常，并且处理异常.

           System.out.println("年龄输入错误"); 

           e.printStackTrace();

        }

}}

注:表示异常类型,exception为其它输入异常等的父类

 

异常》》》自己抛出异常,有两种方法

第一种:在方法声明时throwsexception

publicclass ExceptionMyself {

publicvoid test2()throwsException{

                int i=10;

                if(i<20){

              thrownew Exception("自己抛出异常");//自己抛出异常

               }  }

}

在调异常方法时,要用try & catch处理异常

 

publicclass ExceptionMyself {

    publicstaticvoid main(String[] args) {

       ExceptionMyself2 em=new ExceptionMyself2();

           try {

           em.test2();

       } catch(Exception e) {

           // TODOAuto-generated catch block

           e.printStackTrace();

       } }}

 

第二种:try catch.直接处理

publicclass ExceptionMyself2 {

    publicvoid test(){

       int i=10;

       if(i<20){

                  try{

              //自己抛出异常

              thrownew Exception("自己抛出异常");

           }catch(Exception e){

              System.out.println(e.getMessage());

//输出thrownew Exception("");””里的内容

e.printStackTrace()

           }}  }

}

publicclass ExceptionMyself {

    publicstaticvoid main(String[] args) {

       ExceptionMyself2 em=new ExceptionMyself2();

       em.test();

}