betway必威-betway必威官方网站
做最好的网站

betway必威官方网站难点与思量5,11接续与接口

2016.11.11继承与接口,2016.11.11继承

class Grandparent {

    public Grandparent() {
        System.out.println("GrandParent Created.");
    }

    public Grandparent(String string) {
        System.out.println("GrandParent Created.String:"   string);
    }
}

class Parent extends Grandparent {


    public Parent() {
        super("Hello.Grandparent.");
        System.out.println("Parent Created");
       // super("Hello.Grandparent.");
    }
}

class Child extends Parent {

    public Child() {
        System.out.println("Child Created");
    }

}

public class TestInherits {

    public static void main(String args[]) {
        Child c = new Child();

    }
}

 

结论:通过super调用基类构造方法,必须是子类构造方法中的第一个语句。

 

子类必须先调用父类的构造方法是因为:

构造函数(constructor)是一种特殊的方法 。主要用来在创建对象时初始化对象, 即为对象成员变量赋初始值,总与new运算符一起使用在创建对象的语句中 。特别的一个类可以有多个构造函数 ,可根据其参数个数的不同或参数类型的不同来区分它们 即构造函数的重载。构造函数的功能主要用于在类的对象创建时定义初始化的状态。


构造一个对象,先调用其构造方法,来初始化其成员函数和成员变量。
子类拥有父的成员变量和成员方法,如果不调用,则从父类继承而来的成员变量和成员方法得不到正确的初始化。
不能反过来调用也是这个原因,因为父类根本不知道子类有什么变量而且这样一来子类也得不到初始化的父类变量,导致程序运行出错!


不允许继承的类:
   final class 类名
{

}
   以final声明的方法不允许覆盖。
   以final声明的变量不允许更改。
   利用final,可以设计出一种特殊的"只读"的"不可变类"。

public class ExplorationJDKSource {

    /**
     * @param args
     */
    public static void main(String[] args) {
        System.out.println(new A());
    }

}

class A{}

 

示例中,main方法实际上调用的是:

public void println(Object x),这一方法内部调用了String类的valueOf方法。

valueOf方法内部又调用Object.toString方法:

public String toString() {

    return getClass().getName() "@"

    Integer.toHexString(hashCode());

}

hashCode方法是本地方法,由JVM设计者实现:

public  native int hashCode();

方法覆盖:

class Parent extends Grandparent {



    public int add1(){
        return 1;
    }
}

class Child extends Parent {



    public int add1(){
         return 2;
    }
    public int  superadd1(){  
        return super.add1() ;  

    } 

}

 

结论:方法覆盖要求子类与父类的方法一模一样,否则就是overload(重载)。
      在子类中,若要调用父类中被覆盖的方法,可以使用super关键字。
       1.覆盖的方法允许访问范围不能小于原方法。
       2.覆盖方法所抛出的异常不能比原方法更多。
       3.声明为final方法不允许覆盖。 例如,object的getclass()方法不能覆盖。
       4.不能覆盖静态方法。

抽象类:

1.abstract修饰的类称为“抽象类”,它只定义了什么方法应该存在,不能创建对象,必须派生出一个子类,并在子类中实现其未实现的方法之后,才能使用new关键字创建对象。

在方法前加上abstract就形成抽象方法,只有方法声明,没有实现代码

2.从抽象类继承的子类必须实现父类的所有抽象方法,否则,它仍然是抽象类

3.以下模式总是成立的:

抽象类  抽象类变量 = new  派生自抽象类的具体子类();

 

接口:

1.定义一个接口,采用关键字interface,实现一个接口,采用关键字implements

2.接口的成员函数自动成为public的,数据成员自动成为static和final的。

3.如果接口不声明为public的,则自动变为package。

4.一个类可以同时实现多个接口。

5.接口类型  接口类型的变量=new 实现了接口的具体类型()。

接口的扩充:

1.可以通过继承接口来扩充已有接口,并形成一个新的接口。 

   interface OneInterface {
void f1();
}
interface TwoInterface extends OneInterface {
void f2();
}

2.实现子接口的类,必须实现“父”“子”接口所定义的所有方法,才能被实例化(即new出一个对象)。

接口与抽象类的区别:

1.抽象类是一个不完全的类,而接口只是表明类应该具有哪些“外部”特征,不涉及任何实现细节。

2.接口基本上不具备继承的任何具体特点,它仅仅承诺了外界能够调用的方法。

3.一个类一次可以实现若干个接口,但一个类只能继承一个父类。

class Grandparent { public Grandparent() { System.out.println( "GrandParent Created." ); } public Grandparent(String string) { System.o...

 

    }

public int hashCode()

§§且supper语句必须放在前面,否则会报错。

}

    }

我们得到了一个奇特的运行结果:

       //super("Hello.Grandparent.");

不可变的“类”有何用?

 

(1).以final声明的方法不允许覆盖。

public class tezt{

}

        Parent parent=new Parent();

betway必威官方网站 1

2.     不能反过来,子类继承于父类,父类不能继承子类。

}

        parent.printValue();

//重写equals方法,判断两个对象是否相等。

    public static void main(String[] args) {

{

package test;

betway必威官方网站 2

        System.out.println("GrandParent Created.");

        System.out.println("GrandParent Created.");

       

    public Grandparent() {

public String toString() {

class Child extends Parent {

§§如果在子类的构造方法在使用之前没有调用父类的构造方法会出现继承错误

}

hashCode方法是本地方法,由JVM设计者实现:public  native int hashCode();

 

    public void f() {

    }

 betway必威官方网站 3betway必威官方网站 4

public String getDetail()

        Object hello = "Hello";

        System.out.println("GrandParent Created.");

 

public Address(String detail , String postCode)

        Cat c=new Cat();

//在构造方法里初始化两个实例属性

一:

return false;

        System.out.println("字符串是否是Comparable接口的实例:" (hello instanceof Comparable));

(2).以final声明的变量不允许更改。

        value=200;//这个value是子类自己定义的那个valu,不是从父类继承下来的那个value

        Child c = new Child();

 

public String toString() {

 

        Child c = new Child();

        //super("Hello.Grandparent.");

 

        Mammal m;

        System.out.println("Parent Created");

    public Child()

        //super("Hello.Grandparent.");

}

}

package test;

    }

 

class A { }

        //d=c;

 

 

实现子接口的类,必须实现“父”“子”接口所定义的所有方法,才能被实例化(即new出一个对象)。

class Grandparent

{

        System.out.println("Child.printValue(),myValue=" myValue);

}

    {

定义一个接口,采用关键字interface,实现一个接口,采用关键字implements

 }

    public Child() {

    {

如果接口不声明为public的,则自动变为package。

 /**
  * @param args
  */
 public static void main(String[] args) {
  System.out.println(new A());
 }

public  native int hashCode();

        child.printValue();

valueOf方法内部又调用Object.toString方法:

        //返回false。

一个类一次可以实现若干个接口,但一个类只能继承一个父类。

    public void printValue() {

接口与抽象类的区别?

class Parent extends Grandparent

前面示例中,main方法实际上调用的是:

        System.out.println(value);//打印出来的是子类自定义的那个value的值,这个值是200

Java中“接口”的语法特性。

 

&访问它们可以不用加锁,因而能提供较高的性能。

代码示例:

{

 

 

class Child extends Parent{

        super("Hello.Grandparent.");

 

this.detail = "";

 

}

class ChildClass extends FatherClass {

 

结果如上,分析

    3.参看ExplorationJDKSource.java示例

        //System.out.println("字符串是否是Math类的实例:" (a instanceof Math));

//仅为两个实例属性提供getter方法

 betway必威官方网站 5

    public static void main(String args[]) {

        //但hello变量的实际类型是String

 

八:

interface OneInterface {

1.     子类拥有父的成员变量和成员方法,如果不调用,则从父类继承而来的成员变量和成员方法得不到正确的初始化,父类的属性不存在,子类的属性也不会存在

public class TestInherits {

        System.out.println("Parent Created");

我们来看一段代码(示例Fruit.java ):注意最后一句,一个字串和一个对象“相加”,前页的示例中,Fruit类覆盖了Object类的toString方法。

1.     子类对象赋值给基类对象,基类对象调用子类对象的方法

5.接口知识。

        parent=child;

    }

 

}

}

 

 betway必威官方网站 6

在“ ”运算中,当任何一个对象与一个String对象,连接时,会隐式地调用其toString()方法,默认情况下,此方法返回“类名 @   hashCode”。为了返回有意义的信息,子类可以重写toString()方法。

 

        //super("Hello.Grandparent.");

 

    }

        System.out.println("父类的value属性值=" value);

一个类可以同时实现多个接口。

 

void f2();

}

何为“不可变的类”?

{

 

 

        System.out.println("Child Created");

  }

{

    {

}

 

在继承时候,构造方法先调用上面的,再进行下面的。

 

后面这一串奇怪的字符其实是hash值。

 

return detail.hashCode()   postCode.hashCode();

 

&可以方便和安全地用于多线程环境中,

        parent.printValue();

    package yanzheng;

 betway必威官方网站 7

}

子类中建立与父类相同的方法,supper实现子类中父类被覆盖的方法,supper可以引用方法,也可以引用变量

class Child extends Parent {

{

本文由betway必威发布于编程开发,转载请注明出处:betway必威官方网站难点与思量5,11接续与接口

TAG标签: betway必威
Ctrl+D 将本页面保存为书签,全面了解最新资讯,方便快捷。