关闭

黑马程序员_面向对象下

227人阅读 评论(0) 收藏 举报

---------------------- android培训java培训、期待与您交流! ---------------------- Super()this() 调用语句不能同时出现在一个构造函数中

(调用不能通过)

This() super()调用语句只能作为构造函数中的第一句出现

(和调用过程相矛盾)

 

 

重写

子类中有和父类相同的名词调用的时候是子类中的名词而不是父类中的名词

publicclass Person {

     publicint age ;

     public Stringname;

     public Person(String name,int age){

        this.age = age;

        this.name = name;

     }

     publicvoid getInfo()

     {

        System.out.println("name="+name+"age="+age);

     }

      class Studentextends Person{

         public Stringschool ="unknow";

        

         public Student(String name,int age,String school) {

           super(name, age);

           this.school= school;

      

       }

         publicvoid getInfo(){

 

              System.out.println("school"+school+",name"+name+",age"+age);

             }

     }

getInfo 调用的是子类

如果想要掉用父类只需在this.school= school; super.getInfo();

或者System.out.println("school"+school+",name"+name+",age"+age);

改为System.out.println("school="+school+””);

Super.getInfo();

 

final  关键字

 final标记的类不能被继承

final 标记的方法不能被子类重写

final 标记的变量(成员变量或者局部常量)集成为常量,只能赋值一次

public static final共同标记常量时,这个常量就变成了全局的常量

 

final 的赋值只能在变量定义初始位置初始化或者构造方法里面赋值

publicclass Person {

//public final String x=”abc”;

   

public int age;

public String age;

public Person(String name,int age)

{    this.age = age;

This.name = name;

}

     

     publicvoid getInfo()

     {

//或者 x = “abc”

        System.out.println("name="+name+"age="+age);

     }

float

常量的作用和java中定义常量的方法

 void 函数没有返回值

抽象类

java中可以定义一些不含方法体的方法,他的方法体的实现交给该类的子类根据自己的情况去实现,这样的方法九叫做抽象方法;  包含抽象方法的类就是抽象类

 

抽象类必须使用bastract关键字来修饰,抽象方法也必须使用 abstract来修饰

抽象类不能被实例化,也就是不能用new关键字去产生对象

抽象方法只需声明不需要实现

含有抽象方法胡类必须被声明为抽象类,抽象类 胡子类必须覆盖所有抽象方法才能被实例化,否则这个子类还是个抽象类

例如一个简单的抽象类

 

abstractclassss {

    abstractintaa (int x,int y);

}

注意后面写的;不是{}。

{}代表的是一个函数

不是所有抽象类里面的方法都是抽象方法

abstractclassss {

    abstractintaa (int x,int y);

void  name (){

 

}

}

 

含有抽象方法胡类必须被声明为抽象类,抽象类 胡子类必须覆盖所有抽象方法才能被实例化,

 

 classss {

    abstractintaa (int x,int y);

    class BBextends ss

    {

    int aa(int x,int y)

    { return 1;}

    }

 

}

 

 

 接口(interface:如果一个抽象类中的所有方法都是抽象,我们就可以将这个类用另一个方法来定义,也就是接口。

接口是抽象方法肯常量值的定义的集合,本质上接口是一种特殊的抽象类,这种抽象类中包含常量肯方法的定义,而没有变量和方法的实现

 

接口中的成员都是public访问类型的,接口里的变量,默认是用public static final标识的

Interface只能定义常量

 

可以定义一个新的接口用extends关键字去继承一个已经有的接口

interface Runner {

    intID = 1;

    void run();

}

interface Animalextends Runner{

    void breathed();

}

 classFish implements Animal{

     publicvoid run(){

        System.out.println("fish is swinging");

     }

    publicvoid breathe(){

       System.out.println("fish is bubiong");

    }

    abstractclass LandAnimalimplements Animal{

       publicvoid breathe(){

          

       }

    }

     

 }

 

定义一个类用implements关键字去实现一格接口中的所有方法,还可以定义一个抽象类用implements关键字去实现一格接口定义的部分方法

interface Runner {

    intID = 1;

    void run();

}

interface Animalextends Runner{

    void breathed();

}

 

 

一个类可以继承一个父类的同时,实现一个或者多个接口,extends关键字必须位于implemnets关键字之前

interface Runner {

    intID = 1;

    void run();

}

interface Animalextends Runner{

    void breathed();

}

    interfaceFlay

       {

           void fly();

       }

       class Birdimplements Runner,Flyer{

           publicvoid run(){}

           publicvoid fly(){}

       }(用统一一个类来实现多个接口)

    }

   

继承用extends实现接口,用impleamnet

 

对象类型转换

  

强制类型转换:

 Object

比较两个对象是否相等,一般比较两个对象属性是否一样

 对象的类型转换

子类对象可以自动转换成父类;

父类转化成子类必须使用强制转换;

Instanceof 操作符可以用它来判断一个实例对象是否属于一个类

Object 类级eauals方法

class Student

{

    private Stringname;

     privateintage;

     public Student (String name,String age){

     this.name = name;

     this.age=age;

     }//是私有的时候声明个构造方法调用

      publicboolean equals (object ogj)

    {

      st = (Strdent)obj;

      if(st.name ==name&& st.age==age)

         returntrue;

      else

         returnfalse;

      }

      elsereturnfalse;

}

 publicstaticvoid main(String [] args){

   Student st1 = new Student();

   Student st2 = new Student();

 }

 

面向对象多态性

应用程序不必为每一个派生类(子类)编写功能调用,只需要对抽象类基类进行处理即可(以不变应万变,这个可以大大提高程序的可复用性);

派生类胡功能可以被基类胡引用变量调用,这叫做向后兼容,可以提高程序的可扩充性和可维护性,以前写的可以被后来程序调用,现在写的可以被以后写的调用

 

 class A {

     publicvoid func1()

     {

        System.out.println("ahjdasdf");

     }

     publicvoid fun2()

     {

        func1();

     }//在后面的编程代码被应用到

 }

 class Bextends A

 {

     publicvoid func1()

     {

        System.out.print("asdfasdf");

     }

     publicvoid func3()

     {

        System.out.println("asdfasdf");

     }

 }

 

class C {

     publicstaticvoid main(String [] args){

        B b = new B();

        call (b);

     }

     publicstaticvoid callA(A a){

        a.func1();

        b.func2();

     }

}

 

接口在面向对象编程的设计和应用广泛 

interface PCI

{

    void start();

    void stop();

}

classNetwork interface PCI

{

    publicvoid start()

    {

       System.out.println("sends..");

    }

    publicvoid stop()

    {

    System.out.println("stop....");

    }

}

  classSound interfacePUI

  {

      publicvoid start()

      {

      System.out.println("du..du");

      }

      publicvoid stop()

      {

      System.out.println("mei le ");

      }

  }

class MainBord

{

    publicvoid userPCICard (PCI p)

       {

      p.start();

      p.srop();

  }

}

 

   

匿名内部类

绿色部分是 匿名内部类应用很广泛

 

零时创建一个类并使用他的之类,用完一次后就不用

 

异常类对象不同的子类

 异常增添了代码的健壮性

自定义异常与关键字throw关键字

如何对多个异常作出处理

可以在一个方法程序中使用throwtry …..catch  语句来实现程序的跳转

一个方法被覆盖时,覆盖他的方法必须扔出相同的异常或者异常的子类     

如果父类扔出多个异常,那么重写(方法)必须扔出那些异常的一个子集,也就是说不能扔出新的异常

    ---------------------- android培训java培训、期待与您交流! ----------------------

0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    最新评论