精华内容
下载资源
问答
  • java 抽象类 接口 多态

    2017-05-26 09:29:29
    java 抽象类 接口 多态 java 继承和多态 子类重写父类的实例方式,产生自己的功能行为,当把创建的子类对象的引用赋给父类对象,然后该父类对象(上转型对象)调用这个实例方法时就可能具有多种形态 java 接口和...

    java 抽象类 接口 多态

    java 继承和多态
    子类重写父类的实例方式,产生自己的功能行为,当把创建的子类对象的引用赋给父类对象,然后该父类对象(上转型对象)调用这个实例方法时就可能具有多种形态

    java 接口和多态
    java 舍弃c++的多重继承机制,使用单继承,即一个类只能有一个父类,易于管理和维护,
    java 使用接口,一个类可以实现多个接口,实现多态:
    不同的类在实现同一个接口时可能具有不同的实现,那么当接口变量在回调类实现的接口方法时就具有了多种形态

    面向抽象编程:
    指当设计某种重要的类时,不让该类面向具体的类,而是面向抽象类,即所设计类中重要数据是抽象类声明的对象,而不是具体类声明的对象。

    面向接口编程:
    核心思想—接口回调,即接口变量存放实现该接口的类的对象的引用,通过接口变量就可以回调类实现的接口方法。
    //1、接口
    public interface MyInterface{
    public void test();
    }
    //2、实现接口的类
    class MyClass implements MyInterface{
    @Override
    public void test() {
    System.out.println(“reinvoke”);
    }
    }
    public class Test {
    public static void main(String[] args){
    MyInterface mytest = new MyClass(); //3、接口变量存放实现该接口类的对象的引用
    mytest.test(); //4、通过接口变量回调类实现的接口方法
    }
    }

    两种定义抽象方式:抽象类、接口

    抽象类、接口的区别

    1、语法层面上的区别
    a、抽象类可以提供成员方法的实现细节,
    接口中只能存在public abstract类型的方法,且不能有具体的实现方法。
    b、抽象类中的成员变量可以是各种类型的,
    接口中的成员变量只能是public static final类型的,必须给其初值,实现类中不能重新定义,也不能改变其值
    c、抽象类可以有静态代码块和静态方法,
    接口中不能含有静态代码块以及静态方法
    d、一个类只能继承一个抽象类(继承关系),而一个类却可以实现多个接口,抽象类可以定义构造函数,接口则不能

    2、设计层面上的区别(设计理念)
    抽象类
    是”is-a”关系,是对一种事物的抽象,即对类抽象,抽象类是对整个类整体进行抽象,包括属性、行为。
    它作为很多子类的父类,是一种模板式设计
    接口
    是”like-a”关系,是对行为的抽象。即对类局部(行为)进行抽象
    它是一种行为规范,是一种辐射式设计

    类的成员不写访问修饰时默认为default。默认对于同一个包中的其他类相当于公开(public),
    对于不是同一个包中的其他类相当于私有(private)。受保护(protected)对子类相当于公开,
    对不是同一包中的没有父子关系的类相当于私有
    这里写图片描述

    展开全文
  • 抽象类什么是抽象类JAVA允许在类中只声明方法而不提供方法的实现。 这种只有声明而没有方法体的方法称为抽象方法,而包含一个或多个抽象方法的类称为抽象类。抽象(abstract)类: 抽象类是以abstract关键字为开头的...

    抽象类

    什么是抽象类

    JAVA允许在类中只声明方法而不提供方法的实现。
    这种只有声明而没有方法体的方法称为抽象方法,而包含一个或多个抽象方法的类称为抽象类。

    抽象(abstract)类:
    抽象类是以abstract关键字为开头的类。
    抽象方法在声明中也要加上 abstract 。

    abstract class Employee{        //抽象类:以abstract关键字为开头的类
        abstract void raiseSalary();    //抽象方法:只有声明而没有方法体的方法
    }
    

    注意:
    1. 抽象类在使用上有特殊的限制,即不能创建抽象类实例。
    2. 如果抽象类的子类实现了抽象方法,即可以创建该子类的实例对象,否则该子类也是抽象类(对,没有看错),也不能创建实例。
    3. So,一般将抽象类构造方法的访问权限声明为protected而不是public,从而保证这个构造方法能由其子类调用,而不被其他无关的类调用。
    关于注意点1和2的代码:

    abstract class Employee{        //抽象类:以abstract关键字为开头的类
        abstract void raiseSalary(int i);   //抽象方法:只有声明而没有方法体的方法
    }
    
    class Manager extends Employee{ //抽象类的子类
        void raiseSalaty(int i){    //实现抽象方法
            System.out.println("hello");
        }
    }
    
    public static void main(String[] args) {
            Employee e = new Manager();     //创建Employee 子类 Manager的对象
            Employee e = new Employee();    //错误!Employee为抽象类
        }

    抽象类的作用

    Eg. 现在有 4 个类,
    Shape()—形状类
    Circle()—圆形类
    Square()—正方形类
    Triangle()—三角形类
    类关系
    *Color( ) 属性定义在父类里
    show( ) 方法可以定义成抽象方法

    Shape 类是顶层类。实际上Shape类的对象是没有实际意义的。
    定义Shape类的目的并不是为了在程序中创建并操作它的对象,而是为了定义几何形状类体系的通用接口,这些接口在Shape类中并不需要给出具体实现,而由它的各个子类提供自己的实现。

    还有如果设计者如果想禁止创建某个类的实例对象,只需要在类的声明加abstract关键字。

    抽象类的总结

    抽象类:专门设计让子类继承的类
    特点:
    包括一个或多个抽象方法(只有方法说明,没有方法体);
    如果子类不是抽象类,必须实现其父类的抽象方法;
    抽象类不能被实例化(即不能直接创建对象);
    抽象类不一定要包含抽象方法,若类中包含了抽象方法,则该类必须被定义为抽象类。

    接口(interface)

    Java的接口使抽象类的概念的更深一层。接口是一种“纯”抽象类。
    接口中声明了方法,但不定义方法体。
    为什么要使用接口?
    类继承对于重用父类中的代码很有用,而Java只支持单继承,在遇到需要多继承的情况,可以通过接口来帮助实现

    接口的定义:

    “正规”的接口的定义写法:

    interface  接口名称
    {
           final  static 数据类型  成员变量=值;//常量
           public abstract 返回类型  方法名称(参数…);//抽象方法
    }

    注意事项:
    1. 成员变量必须为常量
    2. 方法必须为抽象方法

    萌新 前面特意强调“正规”,让我们来看这么一段代码:

    interface  iShape2D{
         double pi=3.14;        //成员变量必须初始化
         void area();                //抽象方法,没有方法体
    }

    为什么这段代码里的接口中定义的常量没有加final,而且声明的方法也没有加abstract
    因为:
    1. 在接口中定义的常量默认具有public,final,static的属性。(常量名通常大写)。
    2. 在接口中声明的方法默认具有public和abstract属性。
    另外:如果在子接口中定义了父接口同名的常量方法,则父接口中的常量被隐藏,方法被重写。

    接口的实现与使用

    接口类:类的声明中用imlements 子句来表示一个类实现了某个接口,在类中可以使用接口的常量,而且必须实现接口中定义的所有方法。

    interface  iShape2D{
         double pi=3.14;             //成员变量必须初始化
         area();                         //抽象方法,没有方法体
    }
    
    Class CCircle implements iShape2D {//实现接口类
        public CCircle (double r) {      //构造器
        Radius=r; 
        }   
        public void area() {                 //定义area()的处理方法    
            System.out.print(“area=“+pi*radius*radius);
        }
    }

    一个类可以实现多个接口,在implements子句中用逗号分隔。
    接口可以像类一样作为数据类型来用,并且可以支持多态,此时任何实现该接口的类都可认为是该接口的“子类”。

    多重继承

    Java中规定一个类只能继承一个父类,但是可以实现多个接口,Java是利用接口实现多重继承的。
    一个类可以从一个父类继承,并且可以同时继承其他接口(多个)。

    public class Bird extends Animal implements Flyer{
    
    }

    注意:在子类声明中,extends 子句必须放在 implements 之前。

    通过继承扩展接口

    接口定义后,可能在某种情况下需要对接口进行扩展,如增加新的方法。
    但这样会带来问题:所有实现【这个被增加方法的接口】的【类】都将因为这个而不能工作。
    因为类实现接口必须要实现接口中的所有方法。

    那么,为了既能扩展接口,又保证不影响实现接口中的类。
    一种可行的方法:创建接口的子接口来增加新的方法。

    interface ShapeArea extends Shape{
        double area();
    }

    这样的话,原来的那些使用Shape接口的依旧使用,要使用新的方法的类,则实现ShapeArea接口。
    也可以通过接口继承将几个接口合并为一个接口,在子接口声明中的extends关键字后引用多个基础接口,这些接口通过‘,’分隔。

    接口和抽象类的区别

    1. 接口中所有方法都是抽象的,抽象类中可以定义带有方法体的接口。
    2. 一个类可以实现多个接口,但是只能继承一个抽象父类。
    3. 接口与实现他的类不构成类的继承体系,即接口不是类体系的一部分,因此不相关的类也可以实现相同的接口。而抽象类是属于一个类的继承体系,并且一般位于类体系的顶层。

    使用的接口的主要优势:一个类可以通过实现多个接口从而实现多重继承。
    所以你要用 接口 还是 要用抽象类呢?
    只有必须使用方法定义或成员变量时,才应该考虑抽象类。

    展开全文
  • Java 抽象类 接口 继承 实现

    千次阅读 2016-07-23 17:21:14
    接口抽象类的概念不一样。接口是对动作的抽象,抽象类是对根源的抽象。 抽象类表示的是,这个对象是什么。接口表示的是,这个对象能做什么。比如,男人,女人,这两个类(如果是类的话……),他们的抽象类是人。...

    引言

    接口和抽象类的概念不一样。接口是对动作的抽象,抽象类是对根源的抽象。
    抽象类表示的是,这个对象是什么。接口表示的是,这个对象能做什么。比如,男人,女人,这两个类(如果是类的话……),他们的抽象类是人。说明,他们都是人。
    人可以吃东西,狗也可以吃东西,你可以把“吃东西”定义成一个接口,然后让这些类去实现它(类实现多个接口,实现多个动作).
    所以,在高级语言上,一个类只能继承一个类(抽象类,java类的单继承,接口可以多继承)。(正如人不可能同时是生物和非生物),但是可以实现多个接口(吃饭接口、走路接口)。
    第一点. 接口是抽象类的变体,接口中所有的方法都是抽象的。而抽象类是声明方法的存在而不去实现它的类。
    第二点. 接口可以多继承,抽象类不行
    第三点. 接口定义方法,不能实现,而抽象类可以实现部分方法。
    第四点. 接口中基本数据类型为static 而抽类象不是的。
    当你关注一个事物的本质的时候,用抽象类;当你关注一个操作的时候,用接口。

    PS(一个类只能继承一个类),类的单继承:

    public class MyClassOne {
        int  len =  1 ;
    }
    public class MyClassTwo {
        int  len =  2 ;
    }
    //下面编译不过,去掉,MyClassTwo 编译过
    public class MyClass extends MyClassOne, MyClassTwo{   
        public static void main(String args[]){
            MyClass my = new MyClass();
            System.out.println(my.len);
    
        }
    }
    

    抽象类

    有时候,我们可能想要构造一个很抽象的父类对象,它可能仅仅代表一个分类或抽象概念,它的实例没有任何意义,因此不希望它能被实例化。例如:有一个父类 水果(Fruit),它有几个子类苹果(Apple)、“橘子(Orange)、香蕉(Banana)等。水果在这里仅仅只是作为一个分类, 显然水果的实例没有什么意义(就好像一个人如果告诉你他买了一些水果但是却不告诉你是苹果还是橘子,你很难想象他到底买的是什么。)。而水果类又要能被子 类化,这就要求我们使用抽象类(abstract)来解决这个问题。
    在java中,通过在class关键字前增加abstract修饰符,就可以将一个类定义成抽象类。抽象类不能被实例化。例如:
    定义抽象类水果(Fruit)

        public abstract class Fruit { 
                      …… 
        } 
    

    如果我们试图用以下语句来获得一个实例,将无法编译成功。
    Fruit fruit = new Fruit(); // 不能实例化
    而我们仍然可以构造水果类的子类,如:

    public class Apple extends Fruit { 
                       …… 
               }
    // 子类 橘子(Orange)
    public class Orange extends Fruit { 
                       …… 
               }
    

    这样就达到我们的目的了。 ->实例化
    抽象类除了能象普通类一样可以拥有一般的属性和方法,也可以拥有抽象方法(abstract method)。例如:
    抽象类 形状(Shape)拥有抽象方法draw()。

       public abstract class Shape { 
                    …… 
                   public abstract void draw(); 
                   …… 
               }
    

    抽象方法与抽象的行为相对应,通常是这个行为对父对象没有意义,而子对象有具体动作。例如方法draw()对于类Shape没有意义,而类 Shape的子类矩形(Rectangle)的方法draw()可以有实际的动作(根据矩形的四个顶点画出矩形的四个边),子类圆(Circle)的方法 draw()也可以有实际的动作(根据圆心和半径画出圆周)。
    抽象类可以有抽象方法也可以没有抽象方法;但是如果一个类有抽象方法,那这个类只能定义为抽象类
    如果按照以下代码类“形状(Shape)”仍然拥有抽象方法draw(),但没有定义为抽象类,将会编译失败。

     public class Shape {       //只能定义为抽象类abstract
                      …… 
                      public abstract void draw(); 
                      …… 
               }
    

    抽象方法还有一个特点是,它强迫子类要么仍然保持抽象性(即不具体实现该方法并仍然定义为抽象类),要么具体表现出这个方法的行为(实现具体的动作或者通过抛出UnsupportedOperationException异常来表明不支持该行为)。这样也可以强化多态性。
    这里写图片描述

    匿名内部类实例化

    abstract class B {
        private String str;
    
        public B(String a) {
            System.out.println("父类已经实例化");
            this.str=a;
            System.out.println(str);
        }
    
        public abstract void play();
    }
    
    public class A {
    
        public static void main(String[] args) {
            B aa = new B("test") {
                @Override
                public void play() {
                    System.out.print("B play method");
                }
            };
    
            aa.play();
        }
    
    }
    

    输出
    父类已经实例化
    test
    B play method

    抽象类的确不能实例化。
    这种格式(new TestAbs(){要重写的方法})叫匿名内部类,实际上是实例化一个它的子类。其实就相当于下面这样,只是匿名不匿名的区别。

    class Test extends B{
        @Override
                public void play() {
                    System.out.print("B play method");
                }
    }
    B aa = new Test();
    aa.play("test");
    

    接口

    java语言使用关键字interface定义一个接口。接口也是抽象对象,它甚至比抽象类更抽象。接口中的方法都是抽象方法 (接口中一般只包含一组public抽象方法,且必须是公有抽象方法,但方法定义中public abstract可省略,也可以包含public 静态final数据)。
    一个接口可以继承其他接口(可多个);一个类通过关键字implements声明要实现一个接口,并具体实现接口的方法。
    例如:有一个接口InterfaceA,

    public   interface  InterfaceA {    
             void  methodA();    
    }  
    

    类ClassA实现接口InterfaceA。

    public   class  ClassA  implements InterfaceA {    
              public   void  methodA() {    
                   System.out.println( "methodA of ClassA implements InterfaceA" );    
             }    
    }
    

    如果是抽象类实现一个接口,那么抽象类中可以不具体实现接口的方法(保持其抽象性),而由其子类去实现。
    抽象类ClassB实现接口InterfaceA,但是没有具体实现方法methodA(),

    public abstract class ClassBS implements InterfaceA{ }
    // 子类ClassBSub实现接口InterfaceA,但是没有具体实现方法methodA(),

    public   class  ClassBSub implements InterfaceA{    
             public   void  methodA() {    
                 System.out.println( "methodA of ClassBSub the subclass of ClassB" );    
            }    
    }
    

    接口继承

    public interface Interface1 {
        int  len =  1 ;
        void  output();
    }
    
    public interface Interface2 {
        int  len =  2 ;
        void  output();
    }
    
    public interface Interface3 extends Interface1, Interface2 {
        int  len =  3 ;
        @Override
        void  output();
    }
    
    public class InterfaceSub implements Interface1, Interface2 {
        public void output() {
            System.out.println("output in class interfaceTest.InterfaceSub.");
        }
    
        public void outputLen(int type) {
            switch (type) {
                case Interface1.len:
                    System.out.println("len of interfaceTest.Interface1=." + type);
                    break;
                case Interface2.len:
                    System.out.println("len of interfaceTest.Interface2=." + type);
                    break;
                case Interface3.len:
                    System.out.println("len of interfaceTest.Interface2=." + type);
                    break;
            }
        }
        public   static   void  main(String[] args) {
            InterfaceSub interfaceSub=  new InterfaceSub();
    //        interfaceTest.Interface1 a = new interfaceTest.Interface1() {
    //            @Override
    //            public void output() {
                    interfaceTest.Interface1.len
    //            }
    //        };
            interfaceSub.output();
            interfaceSub.outputLen(1);
            interfaceSub.outputLen(2);
            interfaceSub.outputLen(3);
        }
    }
    

    输出

    output in class interfaceTest.InterfaceSub.
    len of interfaceTest.Interface1=.1
    len of interfaceTest.Interface2=.2
    len of interfaceTest.Interface2=.3
    

    区别

    接口和抽象类显著的共同点是接口和抽象类都可以有抽象方法。

    接口和抽象类的不同点

    (1)抽象类可以有实例变量,而接口不能拥有实例变量(接口是公开的,里面不能有私有的方法或变量,是用于让别人使用的,而抽象类是可以有私有方法或私有变量的),接口中的变量都是静态的常量(public static final)。 (首先接口是一种高度抽象的"模版",,而接口中的属性也就是’模版’的成员,就应当是所有实现"模版"的实现类的共有特性,所以它是public 的 ,是所有实现类共有的 .否则具体实现类不能使用该变量,则就没有了定义的意义,一个既是static又是final的字段表示只占据一段不能改变的存储空间 )
    (2) 抽象类可以有非抽象方法,而接口只能有抽象方法(public abstract 默认省略)
    (3)抽象的子类可以选择性实现其基类的抽象方法,而接口的子类必须实现

    java允许一个接口继承(extend)多个父接口,也允许一个类实现多个接口,而这样的多继承有上面提到的缺点马? (类单继承,接口多继承)
    答案是没有,这是由接口的抽象性决定的。
    正如前面介绍的,在接口中不能有实例变量,只能有静态的常量,不能有具体的方法(包含方法体),只能有抽象方法,因此也就摒弃了多继承的缺点。
    对于一个类实现多个接口的情况,因为接口只有抽象方法,具体方法只能由实现接口的类实现,在调用的时候始终只会调用实现类的方法(不存在歧义), 因此不存在多继承的第二个缺点;而又因为接口只有静态的常量,但是由于静态变量是在编译期决定调用关系的,即使存在一定的冲突也会在编译时提示出错;而引 用静态变量一般直接使用类名或接口名,从而避免产生歧义,因此也不存在多继承的第一个缺点。
    对于一个接口继承多个父接口的情况也一样不存在这些缺点。
    请看以下示例。
    接口A:

    public   interface  InterfaceA {    
            int  len =  1 ;    
            void  output();    
    }
    

    接口B:

    public   interface  InterfaceB {    
               int  len =  2 ;    
               void  output();    
    }
    
    

    接口InterfaceSub继承接口A和接口B:
    public interface InterfaceSub extends InterfaceA, interfaceB { }

    类Xyz实现接口InterfaceSub:

    public   class  Xyz  implements  InterfaceSub {    
             public   void  output() {    
                    System.out.println( "output in class Xyz." );    
            }    
              public   void  outputLen( int  type) {    
                      switch (type) {    
                              case  InterfaceA.len:    
                                     System.out.println( "len of InterfaceA=." +type);    
                                      break ;    
                              case  InterfaceB.len:    
                                     System.out.println( "len of InterfaceB=." +type);    
                                      break ;    
                     }    
            }    
            public   static   void  main(String[] args) {    
                   Xyz xyz=  new  Xyz ();    
                   xyz .output();    
                   xyz .outputLen();    
           }   
     }
    //或者
    public class Xyz implements InterfaceA,InterfaceB {
       ...
    } 
    

    以上代码不存在什么问题,但是如果试图编写以下存在冲突的代码,则会编译失败(根本就访问不了len)。

    Xyz xyz =  new  Xyz();    
    int  len = xyz.len;    
    System.out.println(len);  
    

    疑问

    Java实现接口必须重写其中全部的方法吗

    抽象类可以不用,普通类必须全部重写。
    比如

    public interface A {//定义一个接口
       public void show();//定义一个接口方法
    } 
    public abstract class AExtend implements A{
      //抽象类实现接口A,但可以不实现show方法,由子类再去实现
    }
    

    Java 接口 对象 = new 实现类 与 实现类 对象= new 实现类 区别

    接口 :
    public interface UserService {
    // 注册
    public void regist();
    }
    实现类:
    public class UserServiceImpl implements UserService {
    @Override
    public void regist() {
    System.out.println("区别");
    }
    }
    main(){
    UserService userService = new UserServiceImpl();
    userService.regist();
    }
    //匿名类 new接口 需要实现方法
    UserService userService3 =   new UserService() {
                @Override
                public void regist() {
                    // you impl
    
                }
           };
    

    问题

    为什么main 函数中 构造对象的时候 是:
    1) UserService userService = new UserServiceImpl(); 而不是
    UserServiceImpl userService = new UserServiceImpl();第二种可以的

    接口的设计主要还是为了实现多态的。

    你这里觉得没区别是因为你只有一个UserServiceImpl实现类。
    假设我们还有类A,B,C,他们都具有共同的行为regist。
    假设我们还有个方法(其他变量使用do方法)

    void do(UserService us){
        //us.regist();
    }
    

    当然如果不用interface,那么你可能要定义4个方法来应对我们不同的对象了

    void do(UserServiceImpl us){
        //us.regist();
    }
    void do(A us){
        //us.regist();
    }
    ...
    

    尽管他们方法体一样,要做的事一样。可是如果没有interface,我们还是要乖乖的这样做。

    当然抽象类也可以这么用,但是因为一个类只能继承一个类,如果把抽象类拿来当接口用,那多态就是笑话了。

    参考:
    http://blog.csdn.net/lyflower/article/details/4204449
    http://swearyd7.iteye.com/blog/1471798
    http://blog.csdn.net/fenglibing/article/details/2745123
    http://zhidao.baidu.com/link?url=lvYrFKZHw0Uj4MLM56b1YCxUbJyPqPDQRhlBVOWBmMlHqwrax9VUYiDiO6dUZnLcb0AEP5BIbI0BsY_bWuBwM_
    http://www.cnblogs.com/liangqiyuan/p/5568464.html(抽象类)
    https://www.cnblogs.com/nerxious/archive/2013/01/25/2876489.html(匿名类小结)
    https://www.zhihu.com/question/34797840(为什么说Java中抽象类不可以实例化?)

    展开全文
  • 抽象类 普通类是一个完善的功能类,可以直接产生对象并调用,其中的方法都已经实现完整 抽象类最大的特点是包含了抽象方法,抽象方法是只声明而未实现(没有方法体的方法),抽象方法定义时要用abstract关键字完成,...

    抽象类

    普通类是一个完善的功能类,可以直接产生对象并调用,其中的方法都已经实现完整

    抽象类最大的特点是包含了抽象方法,抽象方法是只声明而未实现(没有方法体的方法),抽象方法定义时要用abstract关键字完成,抽象类关键字要用abstract关键字声明。

    抽象类的使用原则:

    1.      抽象类必须有子类,用extends继承,一个子类只能继承一个抽象类

    2.      子类必须覆写抽象类中的全部抽象方法

    3.      抽象类可以使用对象的向上转型方式,通过子类进行实例化操作

    4.      将内部类定义为内部抽象类,同时使用static声明,这就表示一个外部类

    抽象类的应用:模板设计模式

     

     

    接口

    接口属于一种特殊的类,如果一个类定义时全部由抽象方法和全局常量组成,那么这种类就称为接口,接口使用interface关键字进行定义的。

     

    全局常量就是用public static final定义的

     

    接口使用原则:

    1.      每一个接口必须定义子类,子类用implements关键字实现接口

    2.      接口的子类必须覆写接口中所定义的全部抽象方法

    3.      利用接口的子类,采用对象的向上转型方式,进行接口的实例化操作

    class 子类 [extends 父类]  [implements 接口1,接口2,……]

     

    Ø  每一个子类可以实现多个接口,但是只能继承一个父类(或抽象类)

    Ø  如果一个子类既要实现接口又要继承抽象类,则应该采用先继承后实现的方式完成。

    Ø  定义接口方法时,就算没有写上public,最终也将是public,即接口中的访问权限只有一种:public

    Ø  每一个抽象类都可以实现多个接口一个接口却不可以继承抽象类但是一个接口可以同时继承多个接口


    接口的实际作用:

    ü  工厂设计模式

    例:

    interface fruit{     //定义接口
    	public abstract void eat();
    }
    
    class Apple implements fruit{   //实现接口
    	public void eat(){
    		System.out.println("吃苹果");
    	}
    }
    
    class Orange implements fruit{   //实现接口
    	public void eat(){
    		System.out.println("吃橘子");
    	}
    }
    
    class Factory{     //过渡断
    	public static fruit getInstance(String classname){
    		if("apple".equals(classname)){
    			return new Apple();
    		}
    		if("orange".equals(classname)){
    			return new Orange();
    		}
    		return null;
    	}
    }
    
    
    public class test {
    	public static void main(String args[]){
    		fruit f=Factory.getInstance("apple");
    		f.eat();
    	}
    
    }
    

    ü  代理设计模式(proxy)

    例:

    interface Network{          //定义Network接口
    	public void browse();     //定义浏览的抽象方法
    }
    
    class Real implements Network{        //真实的上网操作
    	public void browse(){             //覆写抽象方法
    		System.out.println("上网浏览信息");
    	}
    }
    
    class Pro_xy implements Network{      //代理上网
    	private Network net;              
    	public Pro_xy(Network net){        //设置代理的真实操作
    		this.net=net;                  //设置代理的子类
    	}
    	public void check(){              //与具体上网相关的操作
    		System.out.println("检查用户信息是否合法");
    	}
    	public void browse(){
    		this.check();                 //可以同时调用多个与具体上网相关的操作
    		this.net.browse();            //调用真实的上网操作
    	}
    }
    
    
    
    public class proxy {
    	public static void main(String args[]){
    		Network net=null;            //定义借口对象
    		net=new Pro_xy(new Real());  //实例化代理,同时传入代理的真实操作
    		net.browse();                //客户只关心上网浏览功能
    	}
    
    }
    

    接口与抽象类:

    抽象类一个最大的缺点是一个子类只可以继承一个抽象类,存在单继承局限,所以接口与抽象类都可以使用时,要优先考虑接口。

     

    Object类

    Object类可以接收所有类的实例化对象,即Object类是所有类的父类

    对于任意一个简单的java类而言,理论上应该覆写Object类中的3个方法

    ü  取得对象信息:public String toString();

    如果一个对象直接输出,那么默认情况下输出的是一个对象的地址。

    例:

    class Person{
    	
    }
    
    public class test_demo {
    	public static void main(String args[]){
    		Person per=new Person();
    		System.out.println(per);
    		System.out.println(per.toString());
    	}
    
    }
    

    所以对象输出默认调用了Object类中的toString()方法,每一个子类也可以根据自己的需要进行覆写。

    例:

    class Person{
    	private String name;
    	private int age;
    	public Person(String name,int age){
    		this.name=name;
    		this.age=age;
    	}
    	public String toString(){
    		return "姓名:"+ this.name +",年龄:" + this.age;
    	}
    }
    
    public class test_demo {
    	public static void main(String args[]){
    		Person per=new Person("Anne",19);
    		System.out.println(per);
    		System.out.println(per.toString());
    	}
    
    }
    

    ü  对象比较:equals()

    String类也是Object类的子类,所以String类的equals()方法就是覆写了Object类的equals()方法。在Object类中,默认的equals()方法实现比较的是两个对象的内存地址数值。

    ü  使用Object接收所有引用数据类型

    Object类是可以接收所有引用数据类型的数据,这就包括了数组、接口、类。

     

    包装类

    在java设计中一直提倡一个原则:一切皆对象。这个原则本身有一个漏洞——基本数据类型不是对象

    将基本数据类型作为一个类的属性保存起来,这就相当于把基本数据类型包装了一下。

    例:

    class Int{
    	private int num;
    	public Int(int num){
    		this.num=num;
    	}
    	public int IntValue(){
    		return this.num;
    	}
    }
    
    public class test_demo {
    	public static void main(String args[]){
    		Int temp=new Int(12);
    		int result=temp.IntValue();
    		System.out.println(result*result);
    	}
    
    }
    

    装箱与拆箱

    装箱:将基本数据类型变为包装类

    拆箱:将包装类变为基本数据类型

     

    包装类最大的优点在于:将字符串变为指定的基本数据类型

    ²  Integer类:public static int parseInt(String s);

    ²  Double类:public static double parseDouble(String s);

    ²  Boolean类:public static boolean parseBoolean(String s)

     

    基本数据类型变为字符串

    1.    任何基本数据类型遇到String后都会变为String型数据

    2.    利用String类的方法public static String valueOf(数据类型 变量)



    展开全文
  • Java抽象类接口、内部类题库

    千次阅读 2017-07-26 20:24:54
    Person和Test的代码如下所示,则代码中的错误语句是( C )。(选择一项)   public class Person { public String name; public Person(String name) { this.name = name;
  • java 抽象类 接口
  • Java 抽象类接口

    2015-03-09 13:14:29
    Java 抽象类接口
  • Java 抽象类接口 图解
  • Java抽象类接口

    千次阅读 2016-06-07 11:20:39
    抽象类接口java语言中对抽象概念进行定义的两种机制,正是由于他们的存在才赋予java强大的面向对象的能力。他们两者之间对抽象概念的支持有很大的相似,甚至可以互换,但是也有区别。 一、抽象类 我们都...
  • 1 继承抽象类 和继承普通类 有声明区别啊? as:当然有区别了,继承抽象类必须重写或说实现抽象类里的所有抽象方法,普通类看情况而定比较随意。...2 java 抽象类java接口类有什么区别 抽象类( abstract meth
  • java抽象类接口

    千次阅读 2015-01-12 16:13:39
    Java接口Java抽象类的认识 很难理解为什么要有接口这个概念,虽说是可以实现所谓的多继承,可一个只有方法名,没有方法体的东西,我实现它又有什么用呢?我从它那什么也得不到,除了一些方法名,我直接在具体类...
  • Java 抽象类接口

    千次阅读 2018-12-04 21:45:27
    Java语言中使用abstract class来定义抽象类 抽象类除了不能实例化对象之外,类的其它功能依然存在,成员变量、成员方法和构造方法的访问方式和普通类一样。 由于抽象类不能实例化对象,但可以定义一个引用。抽象...
  • 抽象类 不应该被实例化的类,不能被new出来,有一种抽象的意义 例: Animal-->bird--->nightinggale Animal类如果被初始化是什么样子的?没有意义 于是就把Animal类定义为抽象类抽象类内部可以有不...
  • java抽象类接口

    2020-11-08 13:08:22
    1.抽象类(提高开发效率) 关键字 abstract 特点 不能用new关键字来创建对象,抽象类是让子类继承 抽象类中可以没有抽象方法,但是有抽象方法的类一定为抽象类 抽象方法只有方法声明,方法实现在子类中 子类继承...
  • java 抽象类接口

    2014-02-26 15:05:19
    java抽象类 如果这个类的成员方法有是abstract的,这个类就是抽象类了(这有点类似于c++的virtual f()=0),并且,一个抽象类不要求所有的方法都是抽象的,只要有一个方法是抽象的,这个类就是抽象的了,不能被...
  • Java抽象类和抽象接口的区别
  • Java接口Java抽象类

    2012-03-26 17:58:45
    Java接口Java抽象类 关键字: java接口 java抽象类 默认适配模式 Java接口Java抽象类有太多...(2)Java接口的优点:由于Java的单继承性,一个Java类只能实现一个Java抽象类,而却可以实现任意多个接口,因...
  • Java抽象类接口的区别 抽象类接口的区别 区别点 抽象类 接口 定义 包含一个抽象方法的类 抽象方法和全局变量 组成 构造方法 抽象方法 普通方法 常量 变量 常量 抽象方法 ...
  • java抽象类接口

    千次阅读 2019-05-14 17:34:15
    java抽象类接口 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 开发工具与关键技术:MyEclipse10 作者:朱海恩 撰写时间: 2019.04.30 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~...
  • Java抽象类接口问题

    2017-03-11 15:52:29
    接口之间是否可以继承,抽象类是否可以实现接口抽象类能继承普通类吗
  • java抽象类实现接口

    千次阅读 2019-06-04 10:37:22
    阅读集合框架的源码的时候,发现AbstractConllection继承自Collection,我不太明白为什么使用抽象类实现接口,但是经过我查阅资料,然后自己又写了个demo,基本弄明白这么写的好处了,而且,我感觉,这就是抽象工厂...
  • Java接口Java抽象类

    2013-04-23 08:36:36
    Java接口Java抽象类有太多相似的地方,又有太多特别的地方,究竟在什么地方,才是它们的最佳位置呢?把它们比较一下,你就可以发现了。 1、Java接口Java抽象类最大的一个区别,就在于Java抽象类可以提供某些...
  • Java抽象类&接口

    2016-06-22 00:19:50
    接口抽象类有什么区别 选择使用接口抽象类的依据是什么?
  • 抽象类(abstract) 抽象类是有抽象方法的类,抽象方法是没有方法体的方法 abstract class Animal{ public abstract void sleep();//这是一个抽象方法 } . 特点 1.可以修饰方法或者类 2.抽象类里可以没有抽象...
  • Java 抽象类,抽象方法和接口

    千次阅读 2015-03-26 20:50:40
    讲述Java抽象类,抽象方法和接口的各种用法。
  • Java 继承 抽象类 接口

    千次阅读 2016-12-25 20:43:07
    JAVA继承 抽象类 接口 作者: 嗯呢 一.类的继承 通过继承可以实现代码的复用,被继承的类称为父类或超类(superclass),由继承而得到的类称为子类(subclass)。一个父类可以拥有多个子类,但一个类只能有一个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 39,449
精华内容 15,779
关键字:

java抽象类接口

java 订阅