12对象

7.2对象

7.2.1创建对象

对象是类的实例

 

类的名称 对象名称 = new 类的名称();

7.3继承

继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法,或子类从父类继承方法,使得子类具有父类相同的行为。

在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的,一般形式如下:

class 父类 {

}

 

class 子类 extends 父类 {

}

public class Animal {

    private String name;  

    private int id;

    public Animal(String myName, String myid) {

        //初始化属性值

    }

    public void eat() {  //吃东西方法的具体实现  }

    public void sleep() { //睡觉方法的具体实现  }

}

 

public class Penguin  extends  Animal{

}

implements关键字

public interface A {

    public void eat();

    public void sleep();

}

 

public interface B {

    public void show();

}

 

public class C implements A,B {

}

super 与 this 关键字

super关键字:我们可以通过super关键字来实现对父类成员的访问,用来引用当前对象的父类。

this关键字:指向自己的引用。

class Animal {

  void eat() {

    System.out.println("animal : eat");

  }

}

 

class Dog extends Animal {

  void eat() {

    System.out.println("dog : eat");

  }

  void eatTest() {

    this.eat();   // this 调用自己的方法

    super.eat();  // super 调用父类方法

  }

}

 

public class Test {

  public static void main(String[] args) {

    Animal a = new Animal();

    a.eat();

    Dog d = new Dog();

    d.eatTest();

  }

final关键字

 

final 关键字声明类可以把类定义为不能继承的,即最终类;或者用于修饰方法,该方法不能被子类重写:

 

声明类:

final class 类名 {//类体}

 

 

声明方法:

修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}

 

 

注:实例变量也可以被定义为 final,被定义为 final 的变量不能被修改。被声明为 final 类的方法自动地声明为 final,但是实例变量并不是 final

构造器

构造器

 

子类是不继承父类的构造器(构造方法或者构造函数)的,它只是调用(隐式或显式)。如果父类的构造器带有参数,则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。

 

如果父类构造器没有参数,则在子类的构造器中不需要使用 super 关键字调用父类构造器,系统会自动调用父类的无参构造器。

 

class SuperClass {

  private int n;

  SuperClass(){

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

  }

  SuperClass(int n) {

    System.out.println("SuperClass(int n)");

    this.n = n;

  }

}

// SubClass 类继承

class SubClass extends SuperClass{

  private int n;

 

  SubClass(){ // 自动调用父类的无参数构造器

    System.out.println("SubClass");

  } 

 

  public SubClass(int n){

    super(300);  // 调用父类中带有参数的构造器

    System.out.println("SubClass(int n):"+n);

    this.n = n;

  }

}

// SubClas2 类继承

class SubClass2 extends SuperClass{

  private int n;

 

  SubClass2(){

    super(300);  // 调用父类中带有参数的构造器

    System.out.println("SubClass2");

  } 

 

  public SubClass2(int n){ // 自动调用父类的无参数构造器

    System.out.println("SubClass2(int n):"+n);

    this.n = n;

  }

}

public class TestSuperSub{

  public static void main (String args[]){

    System.out.println("------SubClass 类继承------");

    SubClass sc1 = new SubClass();

    SubClass sc2 = new SubClass(100);

    System.out.println("------SubClass2 类继承------");

    SubClass2 sc3 = new SubClass2();

    SubClass2 sc4 = new SubClass2(200);

  }

}

 

输出结果为:

------SubClass 类继承------

SuperClass()

SubClass

SuperClass(int n)

SubClass(int n):100

------SubClass2 类继承------

SuperClass(int n)

SubClass2

SuperClass()

SubClass2(int n):200

重写(Override)

重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变,核心重写!

 

重写的好处在于子类可以根据需要,定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。

 

重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如: 父类的一个方法申明了一个检查异常 IOException,但是在重写这个方法的时候不能抛出 Exception 异常,因为 Exception 是 IOException 的父类,只能抛出 IOException 的子类异常。

 

在面向对象原则里,重写意味着可以重写任何现有方法。实例如下:

class Animal{

   public void move(){

      System.out.println("动物可以移动");

   }

}

 

class Dog extends Animal{

   public void move(){

      System.out.println("狗可以跑和走");

   }

}

 

public class TestDog{

   public static void main(String args[]){

      Animal a = new Animal(); // Animal 对象

      Animal b = new Dog(); // Dog 对象

 

      a.move();// 执行 Animal 类的方法

 

      b.move();//执行 Dog 类的方法

   }

}

Super关键字的使用

 

当需要在子类中调用父类的被重写方法时,要使用super关键字。

 

 

TestDog.java 文件代码:

 

class Animal{

   public void move(){

      System.out.println("动物可以移动");

   }

}

 

class Dog extends Animal{

   public void move(){

      super.move(); // 应用super类的方法

      System.out.println("狗可以跑和走");

   }

}

 

public class TestDog{

   public static void main(String args[]){

 

      Animal b = new Dog(); // Dog 对象

      b.move(); //执行 Dog类的方法

 

   }

}

 

重载(Overload)

重载(overloading) 是在一个类里面,方法名字相同,而参数不同。返回类型可以相同也可以不同。

 

每个重载的方法(或者构造函数)都必须有一个独一无二的参数类型列表。

 

最常用的地方就是构造器的重载。

 

重载规则:

被重载的方法必须改变参数列表(参数个数或类型不一样);

被重载的方法可以改变返回类型;

被重载的方法可以改变访问修饰符;

被重载的方法可以声明新的或更广的检查异常;

方法能够在同一个类中或者在一个子类中被重载。

无法以返回值类型作为重载函数的区分标准。

public class Overloading {

    public int test(){

        System.out.println("test1");

        return 1;

    }

 

    public void test(int a){

        System.out.println("test2");

    }  

 

    //以下两个参数类型顺序不同

    public String test(int a,String s){

        System.out.println("test3");

        return "returntest3";

    }  

 

    public String test(String s,int a){

        System.out.println("test4");

        return "returntest4";

    }  

 

    public static void main(String[] args){

        Overloading o = new Overloading();

        System.out.println(o.test());

        o.test(1);

        System.out.println(o.test(1,"test3"));

        System.out.println(o.test("test4",1));

    }

}

                       

多态

猜你喜欢

转载自www.cnblogs.com/Aha-Best/p/10884513.html
0条评论
添加一条新回复