三、java面向对象基础三

1.         多态

什么是多态？

服务名相同，具体的实现不同。

Ø  方法的重载

packagecn.inspur;

 

public class Person {

    //声明一个方法

    Public void say(){

        System.err.println("给自己说...");

    }

    //这种情况不是方法的重载，会报编译错误

Public String say(){

        return “给自己说…..”;

    }

 

    //在一个类中同名的方法可以存在

    //必须要通过形式参数的方式加以区别

    Public void say(String name){

        System.err.println("给"+name+"说...");

    }

}

 

方法重载，就叫 method overload[H1] 

1：在一个类中

2：如果多个方法名称相同。

3：参数不同：参数的类型，参数的个数，参数的顺序至少有一个不相同。则就是方法的重载。

 

在Math类中，就很多的方法重载：

 

packagecn.inspur;

/**

 * 以下是所有方法叫互为重载

 */

publicclass Person {

    //声明一个方法

    publicvoid say(){

        System.err.println("给自己说...");

    }

    //在一个类中同名的方法可以存在

    //必须要通过形式参数的方式加以区别

    publicvoid say(String name){

        System.err.println("给"+name+"说...");

    }

    publicvoid say(intage){

        System.err.println("你的年龄是:"+age);

    }

    publicvoid say(String name,intage){

        System.err.println("你好:"+name+","+age);

    }

    publicvoid say(intage,Stringname){

        System.err.println("Hello:"+name+","+age);

    }

}

 

 

如何调用重载的方法：

        

在 java中调用一个方法，JVM总是按最匹配的原则，去调用这个方法：

publicclass Demo01 {

    publicvoid say(){

        System.err.println("Hello");

    }

    publicvoid say(String name){

        System.err.println("hello name :"+name);

    }

    publicvoid say(Object name){//可以接收任何的值类型

        System.err.println("hello obj is:"+name);

    }

    @Test

    publicvoid test1(){

        //say();//调用say一定是调用第一个方法

        say("Jack");//直接传递一个String类型的数值

        say(56);//由于没有接收int类型的，所以接收的就是say(object)

    }

 

Ø  方法的重写（存在继承，子类重写父类的方法）

1：方法必须要出现在子类和父类中。

         2：方法必须要名称一样。

     3：方法参数的个数，类型，顺序必须要完全一样。

4：权限的访问符号不能缩小。

5：后面扫的异常不能放大。

Ø   

Public class Demo08 {

    public static void main(String[] args) {

        //父类的变量=子类的实例》多态-》两种绑定：静态的绑定，动态绑定

        Animal a = new BlackDog();

        a.run();//BackDog is runnin..g

    }

}

class Animal {

    protected void run(){

        System.err.println("Animal is Running..");

    }

}

class Dog extends Animal{

    @Override

    Public void run(){

        System.err.println("Dog is run...");

    }

}

Class BlackDog extends Dog{

    @Override

    publicvoid run() {

        System.err.println("BlackDog is running..");

    }

}

静态绑定，是指静态方法或是成员与成员变量的类型绑定。

动态绑定是指实例（非静态，不用static）方法与变量所指的对象绑定。

publicclass Demo08 {

    publicstaticvoidmain(String[] args) {

        //Animal是数据类型

        //a是变量 - a是animal类型

        //new BlackDog()是对象

        Animal a = new BlackDog();

        a.run();//所在调用的是对象的run方法-方法与对象绑定

        System.err.println("---------");

        System.err.println(a.name);//成员变量与类型绑定=jack

        System.err.println("---------");

        a.aa();//静态的方法与类型绑定=aaa

    }

}

class Animal {

    public String name="Jack";

    public static void aa(){

        System.err.println("aaaaa");

    }

    protectedvoid run(){

        System.err.println("Animal is Running..");

    }

}

class Dog extends Animal{

    public String name="Dog";

    publicstaticvoidaa(){

        System.err.println("BBBB");

    }

    @Override

    publicvoid run(){

        System.err.println("Dog is run...");

    }

}

classBlackDogextends Dog{

    public String name="black";

    publicstaticvoidaa(){

        System.err.println("cccc");

    }

    @Override

    publicvoid run() {

        System.err.println("BlackDog is running..");

    }

}

 

2.         抽象类

抽象类和接口有共同点：

都不能实例化，出现的目的是被其他的类所继承。

 

abstract可以修饰类---抽象类

         说明这个类是抽象类。不能被new关键字实例化的类。

抽象类是专门用于让子继承的。

         abstract class Animal{

        public void eat(){

       

        }

}

 

可以修饰方法：

         被abstract修饰的方法叫抽象方法

                   1：必须要要抽象类中。

              2：不能拥有方法体。

              3：如果子类，继承了一个抽象类，且这个抽象类包含了抽象的方法，子类就必须要重写。如果子类没有重写父类的抽象方法，子类必须是一个抽象类。

Public class Demo03 {

    Public static void main(String[] args) {

        Animal animal = new Dog();

        animal.eat();

    }

}

abstract class Animal{

    Public abstract void eat();//抽象方法

}

class Dog extends Animal{

    //强制子类必须要重写父类的抽象的方法

    @Override

    Public void eat() {

    }

}

 

//一个抽象类可以没有任何的抽象方法

abstractclass Something{

    //抽象的只能定义在抽象的类中

    publicabstractvoid run();

}

abstractclass Animal extends Something{

    publicabstractvoid eat();

}

//如果一个子类，继承了抽象类，必须要实现所有没有实现的抽象的方法

class Dog extends Animal{

    //强制子类必须要重写父类的抽象的方法

    @Override

    publicvoid eat() {

    }

    @Override

    publicvoid run() {

    }

}

 

1：可以修饰类或是方法。

2：子类必须要实现父类中所有抽象的方法。

3：抽象方法不能拥有方法体，且抽象方法必须要抽象类中。

 

 

3.         接口

---

 [H1]