Java基础教程(18)--继续_玖富娱乐主管发布


玖富娱乐是一家为代理招商,直属主管信息发布为主的资讯网站,同时也兼顾玖富娱乐代理注册登录地址。

一.继续的观点

  继续是面向工具中一个异常重要的观点,运用继续能够从逻辑和条理上更好地组织代码,大大进步代码的复用性。在Java中,继续能够使得子类具有父类的属性和要领或许从新界说、追加属性和要领。在Java中,运用extends关键字来透露显示继续。
  从另一个类派生而来的类称为子类(也称为派生类),派生子类的类称为父类(也称为超类或基类)。当建立一个类时,总是在继续(Object类除外),若是没有明确指出要继续的类,这个类就会隐式地继续Object类。在Java中,Object类是一切类的先人,一切类都是Object类的子女。

  在上一篇教程中,我们晓得接口能够多继续。然则类不支撑多继续,也就是说每一个类只能直接继续自一个父类。
  继续的设法主意很简朴但又很壮大。当你想建立一个新类而且已有一个包罗你想要的代码的类时,你能够从现有的类来派生你的新类。在如许做时,你能够重用现有类的域和要领,而无需从新编写它们。

继续父类的成员

  子类继续了父类一切的public成员和protected成员(域、要领和嵌套类)。若是子类和父类在同一个包中,它还继续了父类的包私有成员。能够按原样运用继续自父类的成员,也能够替代、隐蔽或增补它们。组织要领不是成员,因而它们不会被子类继续,然则能够在子类中挪用父类的组织要领:

  • 继续的域能够直接运用,就像一般的域一样。
  • 能够在子类中声明雷同称号的域来隐蔽继续自父类中的域(不引荐)。
  • 能够声明父类中不存在的新域。
  • 继续的要领能够直接运用,就像一般的要领一样。
  • 能够在子类中编写署名雷同的实例要领来重写继续自父类中的要领。
  • 能够在子类中编写署名雷同的静态要领来隐蔽父类中的静态要领。
  • 能够在子类中编写父类中不存在的要领。
  • 能够在子类的组织要领中挪用父类的组织要领,不管是隐式地或许显式地经由过程super关键字去挪用。

  子类不继续父类的private成员。然则,若是父类具有接见其private字段的public或protected要领,则子类也能够运用这些要领。
  能够在子类中声明雷同称号的域来隐蔽继续自父类中的域,纵然它们范例分歧。掩盖今后只能经由过程super关键字去接见。一般来说,不发起隐蔽域,因为如许做会大大下降代码的可读性。
  嵌套类能够接见其外部类的一切私有成员。因而,子类继续的public或protected嵌套类能够间接接见父类的一切私有成员。

范例转换

  我们晓得,能够将对一个工具的援用赋值给它对应的类范例的变量,比方:

MountainBike myBike = new MountainBike();

  MountainBike类继续自Bicycle类,而Bicycle类继续自Object类。因而,我们能够说一个MountBike肯定是一个Bicycle,也能够说一个MountainBike肯定是一个Object,因而,下面的两种写法都是准确的:

Bicycle bicycle = new MountainBike();
Object obj = new MountainBike();

  这类范例转换是隐式的,也就是说父类范例的变量能够援用子类工具。这类将子类范例的变量转换为父类范例的操纵称为向上转型。实际上,在上一篇教程中,我们运用接口范例的变量去援用完成类的实例也是这向上转型。
  但反过来不肯定建立。我们不克不及说一个Bicycle肯定是一个MountBike,也不克不及说一个Object肯定是一个MountBike。因而,若是我们像下面如许写:

Bicycle bicycle = new MountainBike();
MountBike myBike = bicycle;

  则会获得一个编译时毛病。因为编译器不晓得bicycle是不是援用了一个MountBike的实例。固然,若是我们肯定bicycle援用的就是MountBike类的实例,能够对它举行范例转换:

Bicycle bicycle = new MountainBike();
MountBike myBike = (MountBike) bicycle;

  bicycle变量本来是Bicycle范例的,这里我们将它举行转换后赋值给了子类范例MountBike。这类范例转换必需显现指定,将父类范例的变量转换为子类范例的操纵称为向下转型。
  这类写法能够经由过程编译,然则有能够发生运转时异常。比方:

String bicycle = "MountBike";
MountBike myBike = (MountBike) bicycle;

  上面的写法将会在运转的时刻抛出一个ClassCastException异常。因为bicycle援用的工具是String范例的,它没法转换成MountBike范例。能够运用instanceof运算符来在转换前举行检测:

if (myBike instanceof MountBike) {
    MountBike myBike = (MountBike) bicycle;
}

  instanceof运算符前面是需检测的变量,背面能够是类,也能够是接口。它用来检测前面的工具是不是是背面的类的实例或接口的完成类。

二.重写或隐蔽要领

1.重写父类的实例要领

  在子类中,能够从新编写署名雷同(回想一下,署名雷同是指两个要领的称号和参数列表都雷同)的要领来掩盖继续自父类的要领,如许一来,子类中的要领将会掩盖父类中的要领,当经由过程子类的工具去挪用这个要领时,将会实行子类中的要领而不是父类中的要领。斟酌下面的Animal类:

public class Animal {
    public void method() {
        System.out.println("Method from Animal.");
    }
}

  如今我们要编写一个子类Tiger,并掩盖父类中的method要领:

public class Tiger extends Animal {
    public void method() {
        System.out.println("Method from Tiger.");
    }
}

  当挪用new Tiger().method()时,将会输出“Method from Tiger.”。如许就完成了要领的掩盖,这类行动也称为重写。
  然则,在掩盖父类的过程当中,必须要恪守以下几个准绳,不然编译器将给出毛病:

  1. 子类要领的权限不克不及低于父类要领的权限。比方,父类中的要领时public,子类掩盖这个要领后将权限修改成private,编译器将给出毛病提醒;
  2. 子类要领的返回值必需和父类一样或许小于父类要领的返回值范例。比方,父类要领的返回值是String,子类要领的返回值是Object,编译器将给出毛病提醒;
  3. 子类要领抛出的异常必需和父类一样或许小于父类要领抛出的异常(有关异常的内容会在今后的文章中举行引见)。比方,父类抛出IndexOutOfBoundException,子类抛出Exception,编译器将会给出毛病提醒。

  在掩盖父类要领时,能够在要领上面加上@Override注解(在Java基础教程(16)--注解一文中有提到)。这个注解一来能够进步代码的可读性,在浏览代码时能够晓得这个要领是在掩盖父类要领;二来也能够让编译器帮我们校验父类中是不是存在这个要领,以制止手误带来的题目。

2.隐蔽父类的静态要领

  若是在子类中界说了与父类署名雷同的静态要领,那末子类中的这个要领会将父类中的要领隐蔽。。子类中与父类署名雷同的实例要领会将父类中的要领掩盖,掩盖今后父类中的要领在子类中将不存在。比方:

class SuperClass {
    public void instanceMethod() {
        System.out.println("Instance method in SuperClass.");
    }
}

public class SubClass extends SuperClass {
    public void instanceMethod() {
        System.out.println("Instance method in SubClass.");
    }

    public static void main(String[] args) {
        SubClass sub = new SubClass();
        sub.instanceMethod();
        SuperClass sup = sub;
        sup.instanceMethod();
    }
}

  上面的例子会输出:

Instance method in SubClass.
Instance method in SubClass.

  子类掩盖了父类的要领,以是子类中只需一个instanceMethod,不管怎样调换援用变量的范例,都邑挪用子类重写后的这个要领。
  而子类中与父类署名雷同的静态要领会将父类中的要领隐蔽,也就是说实际上在子类中这两个要领是同时存在的,怎样去挪用它们完整取决于援用变量的范例,比方:

class SuperClass {
    public static void staticMethod() {
        System.out.println("Static method in SuperClass.");
    }
}

public class SubClass extends SuperClass {
    public static void staticMethod() {
        System.out.println("Static method in SubClass.");
    }

    public static void main(String[] args) {
        SubClass sub = new SubClass();
        sub.staticMethod();
        SuperClass sup = sub;
        sup.staticMethod();
    }
}

  上面的例子会输出:

Static method in SubClass.
Static method in SuperClass.

  子类隐蔽了父类的静态要领。若是经由过程子类范例的援用变量挪用这个要领,则会挑选子类的静态要领;若是经由过程父类范例的援用变量去挪用这个要领,则会挑选父类的静态要领。

3.接口中的要领

  接口中的默许要领和笼统要领就像实例要领那样被完成类继续。但是,当父类和接口供应雷同署名的默许要领时,Java编译器将会依照以下划定规矩来处理争执:

  • 实例要领优先于接口的静态要领。
      斟酌下面的类和接口:
public class Horse {
    public String identifyMyself() {
        return "I am a horse.";
    }
}
public interface Flyer {
    default public String identifyMyself() {
        return "I am able to fly.";
    }
}
public interface Mythical {
    default public String identifyMyself() {
        return "I am a mythical creature.";
    }
}
public class Pegasus extends Horse implements Flyer, Mythical {
    public static void main(String[] args) {
        Pegasus myApp = new Pegasus();
        System.out.println(myApp.identifyMyself());
    }
}

  上面的例子将会输出“I am a horse.”。

  • 已被掩盖的要领将被疏忽。当父范例具有配合的先人时,能够会涌现这类状况。斟酌下面的类和接口:
public interface Animal {
    default public String identifyMyself() {
        return "I am an animal.";
    }
}
public interface EggLayer extends Animal {
    default public String identifyMyself() {
        return "I am able to lay eggs.";
    }
}
public interface FireBreather extends Animal { }
public class Dragon implements EggLayer, FireBreather {
    public static void main (String... args) {
        Dragon myApp = new Dragon();
        System.out.println(myApp.identifyMyself());
    }
}

  上面的例子将输出“I am able to lay eggs.”。
  不只是两个接口,一个类和一个接口也是云云:

public interface Animal {
    default public String identifyMyself() {
        return "I am an animal.";
    }
}
public interface EggLayer extends Animal {
    default public String identifyMyself() {
        return "I am able to lay eggs.";
    }
}
class FireBreather implements Animal { }
public class Dragon extends FireBreather implements EggLayer {
    public static void main (String... args) {
        Dragon myApp = new Dragon();
        System.out.println(myApp.identifyMyself());
    }
}

  上面的例子仍然会输出“I am able to lay eggs.”。

  若是两个或多个自力界说的默许要领争执,或许默许要领与笼统要领争执,则Java编译器会发生编译毛病。此时必需显式掩盖超范例要领。假定存在由计算机控制而且能够飞的汽车,如今有两个接口供应了startEngine要领的默许完成:

public interface OperateCar {
    // ...
    default public int startEngine(EncryptedKey key) {
        // Implementation
    }
}
public interface FlyCar {
    // ...
    default public int startEngine(EncryptedKey key) {
        // Implementation
    }
}

  同时完成了OperateCar和FlyCar接口的类必需掩盖要领startEngine。不外能够经由过程super关键字来挪用默许完成:

-玖富娱乐是一家为代理招商,直属主管信息发布为主的资讯网站,同时也兼顾玖富娱乐代理注册登录地址。-
public class FlyingCar implements OperateCar, FlyCar {
    // ...
    public int startEngine(EncryptedKey key) {
        FlyCar.super.startEngine(key);
        OperateCar.super.startEngine(key);
    }
}

  super前面的范例必需界说或许继续了被挪用的默许要领。这类情势的挪用用来辨别多完成时署名雷同的默许要领。在类中或在接口中都能够运用super关键字来挪用默许要领。
  继续的实例要领能够掩盖笼统要领。斟酌下面的例子:

public interface Mammal {
    String identifyMyself();
}
public class Horse {
    public String identifyMyself() {
        return "I am a horse.";
    }
}
public class Mustang extends Horse implements Mammal {
    public static void main(String... args) {
        Mustang myApp = new Mustang();
        System.out.println(myApp.identifyMyself());
    }
}

  上面的例子将会输出“I am a horse.”。Mustang类继续了Horse的identifyMyself要领,这个要领恰好掩盖了Mammal类中的笼统要领identifyMyself。
  接口中的静态要领永久不会被继续。
  下面的表格总结了当界说与父类中署名雷同的要领时能够涌现的状况:
||父类的实例要领|父类的静态要领|
|--|--|--|
|子类的实例要领|掩盖|编译毛病|
|子类的静态要领|编译毛病|隐蔽|
  在子类中,能够对从父类中继续的要领举行重载。如许的要领既不隐蔽也不掩盖父类的要领,它们是新要领,关于子类来说是独一的。

三.多态

  在生物学中,多态的界说是说一个器官或物种会有分歧的形状或阶段。这个界说如今也被应用在像Java如许的面向工具言语中。子类能够界说属于它们自身的奇特的行动,但仍然保存父类中一些原始的功用。
  比方,Bicycle类中有一个要领printDescription:

public void printDescription(){
    System.out.println("Bike is in gear "   this.gear   " with a cadence of "   
        this.cadence   " and travelling at a speed of "   this.speed   ". ");
}

  为了演示多态性,我们界说了两个Bicycle类的子类MountainBike和RoadBike。
  起首建立MountainBike类,这里我们给MountainBike类增添了一个suspension域,用来透露显示自行车的减震器范例:

public class MountainBike extends Bicycle {
    private String suspension;

    public MountainBike(
               int startCadence,
               int startSpeed,
               int startGear,
               String suspensionType){
        super(startCadence,
              startSpeed,
              startGear);
        this.setSuspension(suspensionType);
    }

    public String getSuspension(){
      return this.suspension;
    }

    public void setSuspension(String suspensionType) {
        this.suspension = suspensionType;
    }

    public void printDescription() {
        super.printDescription();
        System.out.println("The "   "MountainBike has a"  
            getSuspension()   " suspension.");
    }
} 

  注重被掩盖的要领printDescription。不只输出了继续自Bicycle类中的属性,还将suspension属性也增添到了输出中。
  接下来建立RoadBike类。因为公路自行车有许多异常细的轮胎,这里增添了一个tireWidth属性来透露显示轮胎的宽度:

public class RoadBike extends Bicycle{
    // In millimeters (mm)
    private int tireWidth;

    public RoadBike(int startCadence,
                    int startSpeed,
                    int startGear,
                    int newTireWidth){
        super(startCadence,
              startSpeed,
              startGear);
        this.setTireWidth(newTireWidth);
    }

    public int getTireWidth(){
      return this.tireWidth;
    }

    public void setTireWidth(int newTireWidth){
        this.tireWidth = newTireWidth;
    }

    public void printDescription(){
        super.printDescription();
        System.out.println("The RoadBike"   " has "   getTireWidth()  
            " MM tires.");
    }
}

  这里的printDescription要领和上面一样,不只输出了之前的属性,还输出了新增添的tireWidth属性。
  下面的测试顺序建立了三个Bicycle变量,这三个变量离别援用了Bicycle、MountainBike和RoadBike类的实例:

public class TestBikes {
  public static void main(String[] args){
    Bicycle bike01, bike02, bike03;

    bike01 = new Bicycle(20, 10, 1);
    bike02 = new MountainBike(20, 10, 5, "Dual");
    bike03 = new RoadBike(40, 20, 8, 23);

    bike01.printDescription();
    bike02.printDescription();
    bike03.printDescription();
  }
}

  上面的顺序输出以下:

Bike is in gear 1 with a cadence of 20 and travelling at a speed of 10. 

Bike is in gear 5 with a cadence of 20 and travelling at a speed of 10. 
The MountainBike has a Dual suspension.

Bike is in gear 8 with a cadence of 40 and travelling at a speed of 20. 
The RoadBike has 23 MM tires.

  JVM为每一个工具挪用适宜的要领,而不是完整挪用变量范例中界说的要领。此行动称为虚要领挪用,它是Java言语中显示多态特征的一种体式格局。

四.super关键字

1.接见父类成员

  若是子类掩盖了父类的要领,能够经由过程super关键字去挪用父类的要领。还能够运用super关键字去接见被隐蔽的域(只管不勉励隐蔽域)。
  斟酌下面的SuperClass类:

public class Superclass {
    public void printMethod() {
        System.out.println("Printed in Superclass.");
    }
}

  下面是它的子类SubClass,它掩盖了printMethod要领:

public class Subclass extends Superclass {
    // overrides printMethod in Superclass
    public void printMethod() {
        super.printMethod();
        System.out.println("Printed in Subclass.");
    }
    public static void main(String[] args) {
        Subclass s = new Subclass();
        s.printMethod();    
    }
}

  在上面的例子中,虽然printMethod要领被掩盖,但仍然能够经由过程super关键字去挪用它。这个顺序的输出以下:

Printed in Superclass.
Printed in Subclass.

2.父类组织器

  能够经由过程super关键字来挪用父类的组织要领。在上面的MountBike类的组织要领中,它先是挪用了父类的组织要领,然后又增添了自身的初始化代码:

public MountainBike(int startHeight, int startCadence, int startSpeed, int startGear) {
    super(startCadence, startSpeed, startGear);
    seatHeight = startHeight;
}   

  挪用父类组织器的语法以下:

super();

super(parameter list);

  super()将会挪用父类的无参组织要领,super(parameter list)将会挪用婚配参数列表的父类组织要领。挪用父类组织要领的语句必需放在子类组织要领的第一行。
  若是子类的组织要领没有显式地挪用父类的组织要领,编译器在编译时将会自动在子类组织要领的第一行插进去对父类无参组织要领的挪用。若是父类没有没有参组织要领,则会发生编译毛病。Object类有没有参组织要领,若是Object类是独一的父类,则不会涌现这个题目。
  因为子类的组织要领会显式或隐式地挪用父类的组织要领,而父类组织要领又会显式或隐式地挪用它的父类的组织要领,如许终究肯定会回到Object类的组织要领,我们将这类行动称为组织要领链。

五.final关键字

  能够将在要领前运用final关键字,如许这个要领将不克不及被子类重写。Object类中就有很多如许的要领,比方getClass要领:

public final Class<?> getClass()

  这意味着没法在任何一个类中重写getClass()要领。
  在组织要领中挪用的要领一般应当生命为final。若是组织函数挪用非final的要领,那末子类重写这个要领后能够会形成料想不到的效果。
  还能够将类声明为final。声明为final的类不克不及被继续。比方String类就是一个final类,没有任何一个类能够继续它。

六.笼统类和笼统要领

  笼统类是在类界说前运用了abstract关键字的类,它既能够包罗也能够不包罗笼统要领。笼统类没法实例化,然则能够被继续。
  笼统要领是指没有详细完成的要领,比方:

abstract void moveTo(double deltaX, double deltaY);

  笼统类中的笼统要领前面必须要运用abstract关键字,而接口中的笼统要领则不须要运用abstract关键字(能够运用,但没必要)。笼统要领前不克不及够运用private修饰符,因为笼统类的笼统要领是肯定要被子类继续或重写的,若是运用private修饰符,那末子类将没法继续父类的笼统要领。恰是因为笼统类的笼统要领肯定要被子类继续或重写,因而protected修饰符也是没有意义的。另外,若是不实用权限修饰符,则笼统要领的权限是包私有的,这类写法在以后笼统类中虽然不会发生毛病,但当子类与这个笼统类不在同一个包中时,子类没法继续父类的笼统要领,也会发生毛病。综上所述,笼统类的笼统要领前必需运用public权限修饰符。
  若是某个类中包罗笼统要领,那末这个类必需声明为abstract。子类会继续父类的笼统要领。只需子类中有没掩盖的笼统要领,那末子类也必需声明为abstract。
  一般来说,一个类在完成接口时,必需完成该接口的悉数笼统要领。然则若是没有完成一切的笼统要领,则须要将这个类声明为笼统类。

笼统类与接口的对照

  下面从语法方面临笼统类与接口举行对照:

  1. 笼统要领:笼统类与接口中都既能够包罗笼统要领,也能够不包罗笼统要领。但分歧的是,笼统类中的笼统要领前面必须要运用abstract关键字,而接口中的笼统要领则不须要;笼统类的笼统要领的权限修饰符必需运用public修饰符,而接口中的笼统要领则不须要,因为接口中的笼统要领默许是且必需是public的。
  2. 默许要领:从Java8最先,接口中能够为要领供应默许完成,如许的要领称为默许要领,默许要领前要运用default关键字。而笼统类中也能够为要领供应完成,不外我们并不将如许的要领称为默许要领,为了与笼统要领辨别,我们将笼统类中除笼统要领以外的要领称为详细要领。接口中的默许要领默许是且必需是public,而笼统类中的详细要领则能够运用任何权限修饰符。
  3. 静态要领:就像一般的类一样,笼统类中也能够有静态要领。从Java8最先,接口中也能够界说静态要领。笼统类中的静态要领能够运用任何权限修饰符,而接口中的静态要领则默许是且只能是public。
  4. :笼统类和接口中都能够界说域。分歧的是,接口中的域默许都是public、static和final的,而笼统类则没有此限定,能够在笼统类中声明非public域、非static域和非final域。
  5. 继续:和一般类一样,笼统类只支撑单继续,而接口则支撑多继续。

  接下来,从设想层面上对笼统类与接口举行对照:

声明:以下内容节选自大神海子的《深切明白Java的接口和笼统类》一文,原文链接深切明白Java的接口和笼统类,若有侵权请联络自己删除。转载本文时请保存此段声明,不然保存追究其法律责任的权益。

  1. 笼统类是对一种事物的笼统,即对类笼统,而接口是对行动的笼统。笼统类是对全部类团体举行笼统,包孕属性、行动,然则接口倒是对类局部(行动)举行笼统。举个简朴的例子,飞机和鸟是分歧类的事物,然则它们都有一个共性,就是都邑飞。那末在设想的时刻,能够将飞机设想为一个类Airplane,将鸟设想为一个类Bird,然则不克不及将 遨游飞翔 这个特征也设想为类,因而它只是一个行动特征,并非对一类事物的笼统形貌。此时能够将 遨游飞翔 设想为一个接口Fly,包罗要领fly( ),然后Airplane和Bird离别依据自身的须要完成Fly这个接口。然后至于有分歧品种的飞机,好比战斗机、民用飞机等直接继续Airplane便可,关于鸟也是相似的,分歧品种的鸟直接继续Bird类便可。从这里能够看出,继续是一个 "是不是是"的干系,而 接口 完成则是 "有没有"的干系。若是一个类继续了某个笼统类,则子类必定是笼统类的品种,而接口完成则是有没有、具有不具有的干系,好比鸟是不是能飞(或许是不是具有遨游飞翔这个特性),能遨游飞翔则能够完成这个接口,不克不及遨游飞翔就不完成这个接口。
  2. 设想层面分歧,笼统类作为许多子类的父类,它是一种模板式设想。而接口是一种行动规范,它是一种辐射式设想。甚么是模板式设想?最简朴例子,人人都用过ppt内里的模板,若是用模板A设想了ppt B和ppt C,ppt B和ppt C大众的局部就是模板A了,若是它们的大众局部须要修改,则只须要修改模板A就能够了,不须要从新对ppt B和ppt C举行修改。而辐射式设想,好比某个电梯都装了某种报警器,一旦要更新报警器,就必需悉数更新。也就是说关于笼统类,若是须要增添新的要领,能够直接在笼统类中增添详细的完成,子类能够不举行调换;而关于接口则不可,若是接口举行了调换,则一切完成这个接口的类都必需举行响应的修改。
    下面看一个网上撒布最普遍的例子:门和警报的例子:门都有open( )和close( )两个行动,此时我们能够界说经由过程笼统类和接口来界说这个笼统观点:
abstract class Door {
    public abstract void open();
    public abstract void close();
}

或许:

interface Door {
    public abstract void open();
    public abstract void close();
}

  然则如今若是我们须要门具有报警alarm( )的功用,那末该怎样完成?下面供应两种思绪:
  1) 将这三个功用都放在笼统类内里,然则如许一来一切继续于这个笼统类的子类都具有了报警功用,然则有的门并不肯定具有报警功用;
  2) 将这三个功用都放在接口内里,须要用到报警功用的类就须要完成这个接口中的open( )和close( ),或许这个类基础就不具有open( )和close( )这两个功用,好比火警报警器。
  从这里能够看出, Door的open() 、close()和alarm()基础就属于两个分歧领域内的行动,open()和close()属于门自身固有的行动特征,而alarm()属于延长的附加行动。因而最好的处理办法是零丁将报警设想为一个接口,包罗alarm()行动,Door设想为零丁的一个笼统类,包罗open和close两种行动。再设想一个报警门继续Door类和完成Alarm接口。

interface Alram {
    void alarm();
}
abstract class Door {
    void open();
    void close();
}
class AlarmDoor extends Door implements Alarm {
    void oepn() {
      //....
    }
    void close() {
      //....
    }
    void alarm() {
      //....
    }
}

  在了解了接口和笼统类的区分和联络后,我们在编写代码时就能够依据自身的需求来天真挑选运用接口照样笼统类。

-玖富娱乐是一家为代理招商,直属主管信息发布为主的资讯网站,同时也兼顾玖富娱乐代理注册登录地址。