精华内容
下载资源
问答
  • 抽象类
    千次阅读 多人点赞
    2020-01-12 21:57:45

    1.抽象类的特点:

    	A.抽象类和抽象方法必须使用abstract修饰
    	B.抽象类中不一定有抽象方法,但是有抽象方法的类必须定义为抽象类
    	C.抽象类不能实例化
    			因为他不是具体的。
    			抽象类具有构造方法,但是不能实例化。构造方法的作用是什么?子类对父类数据进行初始化
    	D:抽象的的子类
    			a:如果不想重写方法,该子类是一个抽象类
    			b:	重写所有的的抽象方法,这时候子类是一个具体的类
    
    package test9;
    abstract class animal{
    	public abstract void eat();
    }
    //子类是抽象类
    abstract class Dog extends animal{
    	
    }
    //子类是具体类,重写抽象方法
    class cat extends animal{
    	public void eat(){
    		System.out.println("猫吃鱼");
    	}
    }
    public class main {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		//抽象类不能实例化,但是却可以通过多态的方式,来实现
    		animal a=new cat();
    		a.eat();//猫吃鱼
    	}
    
    }
    
    

    2.抽象类的成员特点:

    	成员变量:既可以是变量,也可以是常量
    	构造方法:有。
    				用于子类访问父类数据的初始化
    	成员方法:既可以是抽象的,也可以是非抽象的
    

    3.抽象类的成员方法特性:

    	A:抽象方法 强制要求子类做的事情
    	B:非抽象方法 子类继承的事情,提高代码的复用性
    
    更多相关内容
  • Java中的抽象类和接口

    千次阅读 多人点赞 2022-04-08 15:17:42
    各位铁汁们大家好呀!今天让我们继续学习java,看看java中的抽象类和接口到底是什么? 里面也会讲到多态呀,一起来看看吧

    目录

    什么是抽象类

    抽象类再实现多态中的意义 

    接口是什么


     各位铁汁们大家好呀😊

    😎今天让我们继续学习java,看看java中的抽象类和接口到底是什么🤔? 

    什么是抽象类

    🍑我们之前学过什么是类,那么抽象类是不是也是类的一种呢?

    听名字就感觉好抽象呀!说对了,他就是抽象的,不是具体的。在类中没有包含足够的信息来描绘一个具体的对象,这样的类称为抽象类。

    🌰来看一个抽象类的例子

    // 抽象类和抽象方法需要被 abstract 关键字修饰
    abstract class Shape {
        // 抽象类中的方法一般要求都是抽象方法,抽象方法没有方法体
        abstract void draw();
    }

    大家觉得这个抽象类是不是什么也没干,他唯一的方法draw()还是空的。

    像这样的类是不是就没有包含足够的信息来描绘一个具体的对象,自然也就不能实例化对象了。不信你看:

    🍑那既然一个类不能实例化,那这种抽象类存在的意义是什么呀🤔?别急,存在即合理,听我慢慢道来。


    抽象类在实现多态中的意义 

    🍑抽象类存在的一个最大意义就是被继承,当被继承后就可以利用抽象类实现多态。

    来看一段代码

    // 抽象类和抽象方法需要被 abstract 关键字修饰
    abstract class Shape {
        // 抽象类中的方法一般要求都是抽象方法,抽象方法没有方法体
        abstract void draw();
    }
    // 当一个普通类继承一个抽象类后,这个普通类必须重写抽象类中的方法
    class Cycle extends Shape {
        @Override
        void draw() {  // 重写抽象类中的draw方法
            System.out.println("画一个圆圈");
        }
    }
    
    public class Test4 {
        public static void main(String[] args) {
            //Shape shape = new Shape();  抽象类虽然不能直接实例化
            // 但可以把一个普通类对象传给一个抽象类的引用呀,即父类引用指向子类对象
            Shape shape = new Cycle(); // 这称作:向上转型
            
            /*Cycle cycle = new Cycle();
              Shape shape = cycle // 这是向上转型的另一种写法
             */
            shape.draw();         // 通过父类引用调用被子类重写的方法
        }
    }
    

    运行之后你就会发现神奇的一幕:

     

    大家在看完了代码可能会有很多疑问,别急咱们一个一个的说,

    📝什么是向上转型:一句话总结就是“父类引用指向子类对象”

    向上转型后的变化

    1. 🏀关于方法:父类引用可以调用子类和父类公用的方法(如果子类重写了父类的方法,则调用子类的方法),但子类特有的方法无法调用。
    2. 🏀关于属性: 父类引用可以调用父类的属性,不可以调用子类的属性

    向上转型的作用

    1. 🐟减少一些重复性的代码
    2. 🐟对象实例化的时候可以根据不同需求实例化不同的对象

    🌰这样的话就我们上面的代码就可以理解了

    ​ 

    📝看来,我们可以通过子类对抽象类的继承和重写,抽象类还真有点用呀!

    🍑但这和多态有什么关系呢,抽象类用起来这么麻烦,我还不如直接用普通类,也能达到这样的效果,还不用再写一个子类呢😫?

    🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟

    🌰那行,你再看看下面的代码,你就知道抽象类在实现多态时的好处了。 

    abstract class Shape {
        public abstract void draw(); // 抽象方法不能里有具体的语句
    }
    // 当一个普通类继承一个抽象类的时候,再这个子类中必须重写抽象类中的抽象方法
    class Cycle extends Shape {  
        @Override              // 如果不重写会报错,但如果继承的是普通类则不会报错,用抽象类更安全
        public void draw() {
            System.out.println("画一个圆圈");
        }
    }
    class Flower extends Shape { // 不同的子类对父类的draw方法进行了不同的重写
        @Override
        public void draw() {
            System.out.println("画一朵花");
        }
    }
    class Square extends Shape {
        @Override
        public void draw() {
            System.out.println("画一个正方形");
        }
    }
    
    public class Test4 {
        public static void main(String[] args) {
            Cycle cycle = new Cycle();   // 子类引用cycle
            Flower flower = new Flower(); // 子类引用flower
            Square square = new Square();
            
            // 数组的类型是Shape,即数组中每一个元素都是一个父类引用
            // 在这个过程其实也发生了向上转型,对抽象类中的方法进行了重写
            Shape[] shapes = {cycle, flower, square};  // 父类引用引用不同的子类对象
            for (int i = 0; i < shapes.length; i++) {
                Shape shape = shapes[i]; // 父类引用shape指向—>当前所对应的子类对象
    
                shape.draw();  // 通过父类引用调用子类重写的draw方法
            }
    
        }
    }
    

    🍑调用同一个方法竟然打印出了不同的结果😮,这难道就是所谓的多态🤔 

     是不是有点懵😂,下面我们来解释一下😉

    // 对上面的代码补充一下
    // 可能你对 Shape[] shapes = {cycle, flower, square};不太理解
    // 但上面的代码就相当于 
    
     Shape[] shapes1 = new Shape[3]; // 有三个不同的子类对象呀!数组大小为3
    
    // (将指向->子类对象)的子类引用赋值给父类对象,不就相当于该夫类引用指向->所对应的子类对象吗
    //这是向上转型的另一种写法,应为前面已经实例化了子类对象  Cycle cycle = new Cycle();   
     shapes1[0] = cycle;  // 如果前面没实例化子类对象,就要写成shape1[0] = new Cycle
     shapes1[1] = flower;
     shapes1[2] = square;

    对于多态来说,他有这三个要素

    1. 继承(我们刚才的Cycle类继承Shape抽象类)
    2. 重写(我们子类对draw方法的重写)
    3. 父类指向子类对象(就是shape1[0] = cycle -->也可以称作向上转型) 

    🍑回头再看一下我们的代码,是不是就刚好符合了多态的三要素😉。

    📝当我们的父类引用指向不同的子类对象时,当我们调用同一个draw方法时却输出了不同的结果。(其实就是该方法再子类中被重写成了不同形式)这就叫做多态 。

    嘻嘻😂,其实只要只要结合着例子来看,多态也没那么难理解呀😎

      

    🍑那为啥一定要用抽象类呢😂?我一个普通类继承普通类来实现多态不可以吗🤔

    🌰当然可以,但不太安全有风险;

         

    但如果是抽象类的话,就不一样了😉 

      

    🍑从这我们也可以看出,当用抽象类的时候,编译器自动就对我们是否重写进行了校验,而充分利用编译器的校验, 在实际开发中是非常有意义的 。所以说抽象类还是有用的,嘻嘻😉

    📝好了,相信到这里你对抽象类也有了一个大概的认识😊,下面我们来简单做一下总结

    1. 使用abstract修饰的类或方法,就抽象类或者抽象方法
    2. 抽象类是不能具体的描述一个对象,不能用抽象类直接实例化对象
    3. 抽象类里面的成员变量和成员方法,都是和普通类一样的,只不过就是不能进行实例化了
    4. 当一个普通类继承这个抽象类后,那么这个普通类必须重写抽象类当中的所有的抽象方法🤔(我们之前说过抽象类是不具体的,没有包含足够的信息来描述一个对象,所以我们需要把他补充完整)
    5. 但当一个抽象类A继承了抽象类B,这是抽象类A就可以不重写抽象类B当中的抽象方法
    6. final不能修饰抽象类和抽象方法(因为抽象类存在的最大意义就是被继承,而被final修饰的不能被继承,final和抽象,他们两个是天敌😂)
    7. 抽象方法不能被private修饰(抽象方法一般都是要被重写的,你被private修饰了,还怎么重写😫)
    8. 抽象类当中不一定有抽象方法,但如果一个类中有抽象方法,那么这个类一定是抽象类

    🌰哈哈,上面的8条总结是不是臭长臭长的,大家也不用专门去记(用的多了,自然就记住了😉)

    🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟


    接口是什么

    🍑抽象类是从多个类中抽象出来的模板,如果将这种抽象进行的更彻底,则可以提炼出一种更加特殊的“抽象类”——接口(Interface)🤔。

    📝接口是Java中最重要的概念之一,它可以被理解为一种特殊的类,不同的是接口的成员没有执行体,是由全局常量和公共的抽象方法所组成😎。

    如何定义一个接口呢?下面我们来看一个栗子🌰

    //接口的定义格式与定义类的格式基本相同,将class关键字换成 interface 关键字,就定义了一个接口
    
    public interface 接口名称{
    // 定义变量
    int a = 10;      // 接口当中的成员变量默认都是public static final
    
    // 抽象方法
    public abstract void method1(); // public abstract 是固定搭配,可以不写
    void method2();  //  接口当中的成员方法默认都是public abstract, 更推荐用第二种来定义方法 
    }

    可以看到接口和类其实还是有很多相似点:

    📝接口中也包含抽象方法,所以也不能直接实例化接口🤔,那么我们怎么用接口呢?

    🍑哈哈,很简单😉,我们再用一个普通类实现这个接口不就行了吗😂,不同的是抽象类是被子类来继承而实现的,而接口与类之间则是用关键字implements来实现

    📝就像普通类实现实现抽象类一样,一个类实现某个接口则必须实现该接口中的抽象方法,否则该类必须被定义为抽象类🤔。


     通过接口实现多态

    🍑铁汁们!刚才我们是用抽象类来实现多态,那么现在我们可以尝试用接口来实现多态,嘻嘻😎

    接口可以看成是一种特殊的类,只能用 interface 关键字修饰
    interface IShape {
        int a = 10;   接口当中的成员变量默认都是public static final
        int b = 23;
        void draw();  接口当中的成员方法一般只能是抽象方法,默认是public abstract(JDK1.8以前)
      
        default void show() {
            System.out.println("接口中的其他方法");//接口中的其他方法也可以实现,但要用default修饰
        }
        public static void test() {
            System.out.println("这是接口当中的一个静态的方法");
        }
    }
    
    // 一个普通的类要想实现接口,可以用implement, 
    //因为接口也是抽象方法的,所以实现接口的这个类也要重写抽象方法
    class Cycle implements IShape {
    
        @Override
        public void draw() {
            System.out.println("画一个圆圈");
        }
    }
    class Square implements IShape {
        @Override
        public void draw() {
            System.out.println("画一个正方形");
        }
    }
    class Flower implements IShape {
    
        @Override
        public void draw() {
            System.out.println("画一朵花");
        }
    }
    public class Test4 {
        public static void main(String[] args) {
            // IShape iShape = new IShape(); 接口也不能直接实例化
            Cycle cycle = new Cycle();
            Square square = new Square();
            Flower flower = new Flower();
            // 这里的IShape接口就相当与抽象类中父类,接口类型也是一种引用类型
    
            IShape[] iShapes = {cycle, square, flower}; // 这个过程其实就发生了向上转型
    
            for (IShape iShape : iShapes) { // 增强型的for—each循环,也可以写成普通的for循环形式
                iShape.draw();              // 通过重写实现了多态
            }
        }
    }
    引用变量cycle和square都赋值给了Shape类型的引用变量shape,
    但当执行shape.draw()时,java虚拟机到底要调用谁重写的的draw方法,
    就看此时接口引用的是那个对象的,是shape的、还是cycle的

     😎看一下运行结果😎

     看完代码你可能有点晕😫,但没关系。一般接口咱也不这么用,直接使用抽象类不就好了😉(我只是演示一下用接口也能实现多态😂)

    🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑

    📝下面我们来总结一下Java中接口的几个主要特点

    1. 🌰接口中可以包含变量和方法,变量被隐式指定为 public static final,方法被隐式指定为 public abstract(JDK 1.8 d一个类可以同时实现多个接口,一个类实现某个接口则必须实现该接口中的抽象方法,否则该类必须被定义为抽象类
    2. 🌰接口支持多继承,即一个接口可以继承(extends)多个接口,间接解决了 Java 中类不能多继承的问题。

    🍑那么接口一般用在什么地方呢?

    • 一般情况下,实现类和它的抽象类之前具有 "is-a" 的关系,但是如果我们想达到同样的目的,但是又不存在这种关系时,使用接口。
    • 由于 Java 中单继承的特性,导致一个类只能继承一个类,但是可以实现一个或多个接口,此时可以使用接口。

    🌰下面就让我们来看看接口的正确用法:帮助java实现“ 多继承 ”😎

    由于 Java 中单继承的特性,导致一个类只能继承一个类,但是可以实现一个或多个接口,此时可以使用接口。
    class Animal {
        String name;        // 不能使用private,后面的子类也要用
    
        public Animal(String name) { // 父类的自定义的构造方法
            this.name = name;
        }
    }
    interface IFlying {   // 自定义多种接口
        void fly();
    }
    interface IRunning {
        void run();
    }
    interface ISwimming {
        void swimming();
    }
    // 小鸭子,不仅会跑,还会游泳、飞行
    一个类继承父类,并实现多个接口,间接的解决java中不能多继承的问题
    class Duck extends Animal implements IRunning, ISwimming, IFlying {
    
        public Duck(String name) {  // 子类构造方法
            super(name);            // 必须在子类构造方法的第一行
            // 在给实现子类的构造方法前,先要用super()调用实现父类的构造方法,比较先有父后有子呀!
            // 因为父类自己定义了构造方法,编译器不会自动给给子类构造方法中添加super();来实现父类的构造方法,需要我们自己实现
        }
        // 对接口中的抽象方法进行重写
        @Override
        public void fly() {
            System.out.println(this.name + "正在用翅膀飞");
        }
    
        @Override
        public void run() {
            System.out.println(this.name + "正在用两条腿跑");
        }
    
        @Override
        public void swimming() {
            System.out.println(this.name + "正在漂在水上");
        }
    
    }
    
    public class 接口的使用 {  // 不用学我用中文名作为类名,我只是为演示方便
        public static void main(String[] args) {
            Duck duck = new Duck("第一个小鸭子");  // 实例化鸭子对象
            duck.fly();  // 通过引用 变量名.方法名 输出重写后的方法
            duck.run();
            duck.swimming();
        }
    }
    有人可能会说干嘛用接口,我直接在父类Animal中实现fly、run、swimming这些属性,
    然后不同的动物子类再继承父类这些方法不行吗?
    
    但问题是,鸭子会fly、swimming,那猫会飞和游泳吗?你再写个其他动物的子类是不是就不行了
    而用接口呢?我们只是把这种飞、游泳的行为给抽象出来了,
    
    只要一个子类有这种行为,他就可以实现相对应的接口,接口是更加灵活的
    
    

     📝上面的代码展示了 Java 面向对象编程中最常见的用法: 一个类继承一个父类, 同时实现多个接口。

     📝继承表达的含义是 is - a 语义, 而接口表达的含义是 具有 xxx 特性 ,能实现接口的类和该接口并不一定有is_a的关系,只要该类有这个接口的特性就行

    猫是一种动物, 具有会跑的特性.

    青蛙也是一种动物, 既能跑, 也能游泳

    鸭子也是一种动物, 既能跑, 也能游, 还能飞

     🍑这样设计有什么好处呢? 时刻牢记多态的好处, 让程序猿忘记类型. 有了接口之后, 类的使用者就不必关注具体类型,只要这个类有有这个特性就好。

    举个栗子🌰

    class Robot implements IRunning {
        private String name;
        public Robot(String name) {
            this.name = name;
        }
        // 对run方法进行重写
        @Override
        public void run() {
            System.out.println("机器人" + this.name + "正在跑");
        }
    }
    public class Test4 {
        public static void main(String[] args) {
            Robot robot1 = new Robot("图图");
            robot1.run();
        }
    }
    // 执行结果
    机器人图图正在跑

    😎只要能跑就行,管他是机器人还是动物呢😂,接口是不是很灵活呀!

    同时在实际的开发过程中,一般来说,一个类是一个Java文件,一个接口也是一个Java文件。大家也要在平时就养成这个好习惯呀!

    哈哈,不知道现在你对抽象类和接口的认识是不是又上升了一个高度呢?嘻嘻,我们下篇博客再见了,下篇让我们瞅瞅Java中常用的接口有哪些😉

     每天进步一点点,铁汁们,一起加油😎😎😎

    展开全文
  • java抽象类 继承

    千次阅读 2021-03-08 06:02:32
    关于java抽象类 继承的搜索结果回答抽象类和接口的区别:默认的方法实现抽象类可以有默认的方法实现完全是抽象的。接口根本不存在方法的实现。抽象类中可以有已经实现了的方法,也可以有被abstract修饰的方法(抽象...

    关于

    java抽象类 继承的搜索结果

    回答

    抽象类和接口的区别:默认的方法实现 抽象类可以有默认的方法实现完全是抽象的。接口根本不存在方法的实现。抽象类中可以有已经实现了的方法,也可以有被abstract修饰的方法(抽象方法),因为存在抽象方法,所以该类必须是抽象类。但是接口要求只能包含抽象方法,抽象方法是指没有实现的方法。所以就不能像抽象类那么无赖了,接口就根本不能存在方法的实现。实现 抽象类使用extends关键字来继承抽象类。如果子类不是抽象类的话,它需要提供抽象类中所有声明的方法的实现。子类使用关键字implements来实现接口。它需要提供接口中所有声明的方法的实现。抽象类虽然不能实例化来使用,但是可以被继承,让子类来具体实现父类的所有抽象方法。有点老子没完成的梦想交给儿子来完成,但是如果子类将抽象方法没有全部实现,就必须把自己也修饰成抽象类,交于继承它的子类来完成实现。就相当于,儿子能力不够也没完成老爹的梦想,现在儿子等着再生儿子(被继承),然后让孙子去完成。以此类推,知道没有抽象函数。接口的实现,通过implements关键字。实现该接口的类,必须把接口中的所有方法给实现。不能再推给下一代。和抽象类相比,抽象类是将梦想传给家族,一代一代去完成。那么接口就是掌门人找大师兄来完成帮派的鸿星伟业,这时候就只有一次希望,要么有能力就实现,没能力就不要接。抽象类可以有构造器,而接口不能有构造器这个原因很简单,我们回到双方的定义上来,抽象类再怎么流氓无赖也好,终究是属于类,就天生享有类的所有特性(但是不能实例化),当然包括类的构造方法,也就是构造器。但是接口是所有抽象方法的集合,注意,是集合,不是类。当然没有构造方法一说,更别提什么构造器了。抽象方法可以有public、protected和default这些修饰符 接口方法默认修饰符是public。你不可以使用其它修饰符。抽象类的目的就是被继承,抽象方法就是为了被重写,所以肯定不能用private修饰符,肯定是可以用public的。但是protected和default也是可以的。接口就有且只有一个public修饰。(是不是感觉抽象类像小儿子各种耍无赖,接口就像私生子,说什么只能是什么)抽象类在java语言中所表示的是一种继承关系,一个子类只能存在一个父类,但是可以存在多个接口。java在类的继承上并没有多继承。抽象类属于类,所以可以被继承。但子类只能继承一个父类。java为了实现多继承,使用了接口。一个类可以实现多个接口。继承就好比生了孩子,只能有一个爹,但是这个孩子可以学语文,学数学,学英语等等很多东西,而语文、数学、英语就相当于接口。总的来说,因为java中抽象类只有单继承,接口就可以实现多继承。抽象方法比接口速度要快接口是稍微有点慢的,因为它需要时间去寻找在类中实现的方法。记住抽象方法是小儿子,从小吃的好所以跑的快,接口是私生子,从小日子苦,营养不良。如果你往抽象类中添加新的方法,你可以给它提供默认的实现。因此你不需要改变你现在的代码。 如果你往接口中添加方法,那么你必须改变实现该接口的类。抽象类可以有一些非抽象方法的存在,这些方法被称为默认实现。如果添加一个默认实现方法(不能是抽象方法),就不需要在子类中去实现,所以继承这个抽象类的子类无须改动。但是,接口中只能添加抽象方法,当你添加了抽象方法,实现该接口的类就必须实现这个新添加的方法。因为,定义中说的很清楚,接口的实现必须实现所有的方法。所有,当然包括新添加的方法。

    hiekay

    2019-12-02 01:39:31

    0 浏览量

    回答数 0

    问题

    java怎么继承抽象类

    java怎么继承抽象类...

    云计算小粉

    2019-12-01 19:57:04

    414 浏览量

    回答数 3

    回答

    1、Java为了简化设计和开发,抛弃了多重继承类的理念,因为多重继承类型带来很多潜在问题,比如重名方法和变量问题。2、Java提供了接口的多重继承支持3、接口只是 包含声明,属于部分约束。4、abstract class抽象类,可以包含具体实现,也可以包含没有实现代码的抽象方法,允许后代实现,这个比接口更丰富一些。某些情况下父类可以提前实现一些具体的代码,也可以不实现留着子类实现。更加灵活

    徐雷frank

    2019-12-02 01:49:22

    0 浏览量

    回答数 0

    回答

    toString().你确定你没开玩笑?感谢提醒不全部实现还能叫接口么。。。你自己去写得试试,编译确实可以通过,我在想是不是这样接口更灵活一些只有接口的抽象实现类不用全实现,普通接口的方法都需要实现的总结的好

    引用来自“PythonLee”的评论toString().你确定你没开玩笑?toString确实默认了,现在问题来了,Shape2里面也有抽象的toString,而他的子类应该也会默认实现toString,可是编译器为什么提示我错误而且继承接口的抽象实现类的子类还必须实现抽象父类中没有实现的方法。。。。

    LZ好深意:要知道Circle继承了Object,Object实现了toString().

    至于下面的抽象类Rhomboid是因为java是单继承,可没有直接父类实现toString().

    abstractclassShape2{   publicabstractStringtoString();}classRTmpextendsShape2{   @Override   publicStringtoString(){      returnnull;   }}classRhomboidextendsRTmp{   //这里不报错}我只能说楼主的根据这个例子做出猜测,实在是没经过严格验证的.你为什么不试试其他名称的方法体呢?服了

    引用来自“Cong_Cong”的评论

    LZ好深意:要知道Circle继承了Object,Object实现了toString().

    至于下面的抽象类Rhomboid是因为java是单继承,可没有直接父类实现toString().

    abstractclassShape2{   publicabstractStringtoString();}classRTmpextendsShape2{   @Override   publicStringtoString(){      returnnull;   }}classRhomboidextendsRTmp{   //这里不报错}这种问题...哭了很凑巧,LZ写的例子种,toString方法刚好是java.lang.Object中的,而这家伙是所有类的顶级父类,你换个名字就知道问题在哪了

    爱吃鱼的程序员

    2020-06-14 17:04:49

    0 浏览量

    回答数 0

    回答

    多重继承有很多概念上的麻烦问题,典型的比如菱形问题,要避免这种问题,最简单的办法就是不使用多重继承。在java中使用组合的方式来代替多重继承。抽象类是为了存放公用的函数和变量,接口只有函数定义而没有实现,抽象类则可以有变量,有函数实现。

    yu_hc200

    2019-12-02 01:49:23

    0 浏览量

    回答数 0

    回答

    面向对象的特征主要有以下几个方面:

    抽象:抽象是将一类对象的共同特征总结出来构造类的过程,包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为,并不关注这些行为的细节是什么。

    封装

    封装把一个对象的属性私有化,同时提供一些可以被外界访问的属性的方法,如果属性不想被外界访问,我们大可不必提供方法给外界访问。但是如果一个类没有提供给外界访问的方法,那么这个类也没有什么意义了。

    继承

    继承是使用已存在的类的定义作为基础建立新类的技术,新类的定义可以增加新的数据或新的功能,也可以用父类的功能,但不能选择性地继承父类。通过使用继承我们能够非常方便地复用以前的代码。

    关于继承如下 3 点请记住:

    子类拥有父类非 private 的属性和方法。

    子类可以拥有自己属性和方法,即子类可以对父类进行扩展。

    子类可以用自己的方式实现父类的方法。(以后介绍)。

    多态

    所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定,而是在程序运行期间才确定,即一个引用变量到底会指向哪个类的实例对象,该引用变量发出的方法调用到底是哪个类中实现的方法,必须在由程序运行期间才能决定。

    在Java中有两种形式可以实现多态:继承(多个子类对同一方法的重写)和接口(实现接口并覆盖接口中同一方法)。

    其中Java 面向对象编程三大特性:封装 继承 多态

    封装:隐藏对象的属性和实现细节,仅对外提供公共访问方式,将变化隔离,便于使用,提高复用性和安全性。

    继承:继承是使用已存在的类的定义作为基础建立新类的技术,新类的定义可以增加新的数据或新的功能,也可以用父类的功能,但不能选择性地继承父类。通过使用继承可以提高代码复用性。继承是多态的前提。

    关于继承如下 3 点请记住:

    子类拥有父类非 private 的属性和方法。

    子类可以拥有自己属性和方法,即子类可以对父类进行扩展。

    子类可以用自己的方式实现父类的方法。

    多态性:父类或接口定义的引用变量可以指向子类或具体实现类的实例对象。提高了程序的拓展性。

    在Java中有两种形式可以实现多态:继承(多个子类对同一方法的重写)和接口(实现接口并覆盖接口中同一方法)。

    方法重载(overload)实现的是编译时的多态性(也称为前绑定),而方法重写(override)实现的是运行时的多态性(也称为后绑定)。

    一个引用变量到底会指向哪个类的实例对象,该引用变量发出的方法调用到底是哪个类中实现的方法,必须在由程序运行期间才能决定。运行时的多态是面向对象最精髓的东西,要实现多态需要做两件事:

    方法重写(子类继承父类并重写父类中已有的或抽象的方法); 对象造型(用父类型引用子类型对象,这样同样的引用调用同样的方法就会根据子类对象的不同而表现出不同的行为)。

    问问小秘

    2020-03-27 17:36:33

    0 浏览量

    回答数 0

    回答

    在Java中,OOP是一种与以下概念相关的编程样式: 继承:继承是一个类在其中获取另一类的属性的过程。 封装:Java中的封装是一种将数据和代码打包为单个单元的机制。 抽象:抽象是向用户隐藏实现细节并仅向用户提供功能的方法。 多态:多态是变量,函数或对象采取多种形式的能力。

    YDYK

    2020-04-23 19:37:18

    0 浏览量

    回答数 0

    回答

    接口是JAVA为了实现类似C++里面的多继承的一种妥协方案。比如,有接口A,然后B、C、D都实现了接口A。就类似于B、C、D都继承了抽象类A,都可以调用A中定义过的方法。比如需要对B、C、D的对象做类似的操作,就可以写出类似的代码。甚至可以把类似的代码抽象封装成函数,类等等。传递参数的时候,可以把类型写成A,那么B、C、D类的对象就都可以传递进来。各种。总之,接口不是为了规范产生的,它的好处也不是什么规范,而是尽量抽象,减少重复的代码。(说的装逼一点,叫更加符合面向对象的思想blabla……)(另外,不规范都是程序员的问题,接口并不能拯救世界。)实现类似的效果,只有两种方案:方案1:B、C、D都继承于A。方案2:B、C、D都实现A的接口。但是很明显,JAVA不支持多继承……于是只能用方案2,实现多个接口……所以你懂的,接口是很必要的。但是用了函数和类,可以为你减少重复的代码啊。你在考虑用继承或者接口的前提,一定是要“ B,C,D具有相同或者类似的行为,可以整合到一起 ”。接口可以让你的B、C、D类的对象都可以当做同一个类型(A接口)的参数到处传递,做相同的操作。(也就是说,比如B继承Y,又实现了Z,那么B既可以当做Y类型的参数,又可以当做Z类型的参数)

    蛮大人123

    2019-12-02 01:51:10

    0 浏览量

    回答数 0

    问题

    java中到底为什么要用到抽象类?

    比如有个类A,把它设置成abstract是为了不让它实例化,只能表示一个抽象的或者不具体的无法实例化的概念,但是就算不在这个A的前面加abstract照样可以实现很多类的继承,那我真的不太理解设置抽象类的意义到底在哪里,请各位不吝赐教!...

    蛮大人123

    2019-12-01 20:24:53

    1279 浏览量

    回答数 1

    回答

    Java中内部类主要分为成员内部类、局部内部类(嵌套在方法和作用域内)、匿名内部类(没构造方法)、静态内部类(static修饰的类,不能使用任何外围类的非static成员变量和方法, 不依赖外围类)

    使用内部类最吸引人的原因是:每个内部类都能独立地继承一个(接口的)实现,所以无论外围类是否已经继承了某个(接口的)实现,对于内部类都没有影响。

    因为Java不支持多继承,支持实现多个接口。但有时候会存在一些使用接口很难解决的问题,这个时候我们可以利用内部类提供的、可以继承多个具体的或者抽象的类的能力来解决这些程序设计问题。可以这样说,接口只是解决了部分问题,而内部类使得多重继承的解决方案变得更加完整。

    游客bnlxddh3fwntw

    2020-04-10 13:20:38

    0 浏览量

    回答数 0

    回答

    "枚举类可以实现一个或多个接口,使用enum定义的枚举类默认继承了java.lang.Enum类,而不是继承Object类。其中java.lang.Enum类实现了java.lang.Serializable和java.lang. Comparable两个接口。 使用enum定义、非抽象的枚举类默认会使用final修饰,因此枚举类不能派生子类。 枚举类的构造器只能使用private访问控制符,如果省略了构造器的访问控制符,则默认使用private修饰;如果强制指定访问控制符,则只能指定private修饰符。 枚举类的所有实例必须在枚举类的第一行显式列出,否则这个枚举类永远都不能产生实例。列出这些实例时,系统会自动添加public static final修饰,无须程序员显式添加。"

    星尘linger

    2020-04-07 13:24:42

    0 浏览量

    回答数 0

    回答

    enum和class、interface的地位一样

    使用enum定义的枚举类默认继承了java.lang.Enum,而不是继承Object类。枚举类可以实现一个或多个接口。

    枚举类的所有实例都必须放在第一行展示,不需使用new 关键字,不需显式调用构造器。自动添加public static final修饰。

    使用enum定义、非抽象的枚举类默认使用final修饰,不可以被继承。

    枚举类的构造器只能是私有的。

    游客lz7tjhznmiyda

    2019-12-02 01:03:52

    0 浏览量

    回答数 0

    回答

    面向对象有三个特征:封装、继承、多态。

    其中继承和实现都体现了传递性。而且明确定义如下:

    继承:如果多个类的某个部分的功能相同,那么可以抽象出一个类出来,把他们的相同部分都放到父类里,让他们都继承这个类。

    实现:如果多个类处理的目标是一样的,但是处理的方法方式不同,那么就定义一个接口,也就是一个标准,让他们的实现这个接口,各自实现自己具体的处理方法来处理那个目标

    所以,继承的根本原因是因为要复用,而实现的根本原因是需要定义一个标准。

    在Java中,继承使用extends关键字实现,而实现通过implements关键字。

    Java中支持一个类同时实现多个借口,但是不支持同时继承多个类。

    简单点说,就是同样是一台汽车,既可以是电动车,也可以是汽油车,也可以是油电混合的,只要实现不同的标准就行了,但是一台车只能属于一个品牌,一个厂商。

    class Car extends Benz implements GasolineCar, ElectroCar{

    }

    在接口中只能定义全局常量(static final)和无实现的方法(Java 8以后可以有defult方法);而在继承中可以定义属性方法,变量,常量等。

    montos

    2020-06-01 15:50:19

    0 浏览量

    回答数 0

    问题

    JAVA中继承那些事情

    访问权限

    Java 中有三个访问权限修饰符:private、protected 以及 public,如果不加访问修饰符,表示包级可见。

    可以对类或类中的成员(字段和方法࿰...

    montos

    2020-05-18 21:16:07

    4 浏览量

    回答数 1

    问题

    Java基础测试题2 | 基础不能都忘掉

    一、填空题

    1、Java中通过____关键字实现继承。

    2、一个类只能继承________个父类,但能实现____个接口。

    3、当子类中定义的方法与父类方法同名且参数类型及个数、返回值类型相同时,称子类方法...

    游客pklijor6gytpx

    2019-12-01 22:04:25

    575 浏览量

    回答数 0

    问题

    (JAVA)一个类没有直接实现接口,为什么可以这样为父接口实例化呢??报错

    @tcxu 你好,想跟你请教个问题:

    package jiu;

    interface A { // 定义一个接口     String INFO = "Hello World ."...

    爱吃鱼的程序员

    2020-06-06 09:57:24

    0 浏览量

    回答数 1

    问题

    【精品问答】100+ Java和JavaSE常用技术点

    为大家整理了 Java和JavaSE常用技术点,可以应对面试。供大家学习交流参考:

    运行时实现多态需要的三个必要条件?

    访问修饰符public、private、protected、以及不写...

    游客pklijor6gytpx

    2020-03-29 23:26:40

    1148 浏览量

    回答数 1

    回答

    首先我觉得像spring这样的庞大的开源框架的设计理念,并不会完全遵守,一些常用的准则,肯定有自己独到之处,java中不支持继承多个抽象类,却支持接口的继承和扩展,这样,对于一个接口有若干继承接口,在java中就是很正常的事情,就像spring中beanfactory有很多的继承接口,这些接口大多数面向不同的环境,不同的使用场景,就相当于把spring核心容器接口提供的功能,通过定义不同接口的方式来做了汇总归类,降低了使用接口的复杂度,我所知道的spring中有相当部分的属于接口方法,但是却不适合向普通用户公开,这样,通过一个子接口就隐藏了这部分接口代码,同时又符合面向接口的设计。

    长安归故里.

    2020-01-07 21:11:14

    0 浏览量

    回答数 0

    回答

    Java集合容器主要有以下几类:1,内置容器:数组2,list容器:Vetor,Stack,ArrayList,LinkedList,CopyOnWriteArrayList(1.5),AttributeList(1.5),RoleList(1.5),RoleUnresolvedList(1.5),ConcurrentLinkedQueue(1.5),ArrayBlockingQueue(1.5),LinkedBlockingQueue(1.5),PriorityQueue(1.5),PriorityBlockingQueue(1.5),SynchronousQueue(1.5)3,set容器:HashSet(1.2),LinkedHashSet(1.4),TreeSet(1.2),CopyOnWriteArraySet(1.5),EnumSet(1.5),JobStateReasons。4,map容器:Hashtable,HashMap(1.2),TreeMap(1.2),LinkedHashMap(1.4),WeakHashMap(1.2),IdentityHashMap(1.4),ConcurrentMap(1.5),concurrentHashMap(1.5)。注意:Vector,Stack,Hashtable是Java1.2前的容器。虽然在Java2之前,Java是没有完整的集合框架的。它只有一些简单的可以自扩展的容器类。但是在Java2后他们还是被融入到了集合框架的,不过只是历史遗留而已。它们和1.2前应该还是有些变化的,虽然本质没什么变化。Set接口继承于Collection,但不允许重复,使用自己内部的一个排列机制。List接口继承Collection,允许重复,以元素安插的次序来放置元素,不会重新排列。Map接口是一组成对的键-值对象,即所持有的是key-value pairs。Map中不能有重复的key。拥有自己的内部排列机制。一、Java1.2之前的容器类库其实在Java2之前,Java是没有完整的集合框架的。它只有一些简单的可以自扩展的容器类,比如Vector,Stack,Hashtable等。Java1容器类库设计的一个重大失误是竟然没有对容器进行排序的工具。比如你想让Vector容器中的对象按字典顺序进行排序,你就要自己实现。1.1、Vectorjava.util.Vector中包含的元素可以通过一个整型的索引值取得,它的大小可以在添加或移除元素时自动增加或缩小。Vector的操作很简单,通过addElement()加入一个对象,用elementAt()取出它,还可以查询当前所保存的对象的个数size();另外还有一个Enumeration类提供了连续操作Vector中元素的方法,这可以通过Vector中的elements()方法来获取一个Enumeration类的对象,可以用一个While循环来遍历其中的元素。用hasMoreElements()检查其中是否还有更多的元素。用nextElement()获得下一个元素。Enumeration的用意在于使你能完全不用理会你要遍历的容器的基础结构,只关注你的遍历方法,这也就使得遍历方法的重用成为可能。由于这种思想的强大功能,所以在Java2中被保留下来,不过具体实现,方法名和内部算法都改变了,这就是Java2中的Iterator以及ListIterator类。然而Enumeration的功能却十分有限,比如只能朝一个方向进行,只能读取而不能更改等。更多内容请参考《Vector》1.2、Stackjava.util.Stack最常用的操作便是压入和弹出,最后压入的元素最先被弹出。它遵循后进先出(LIFO)原则。在Java中Stack的的用法也很简单,有push()压入一个元素,用pop()弹出一个元素。更多内容请参考《Stack容器》1.3、HashtableHashtable与Java2中的Map类似,可以看成一种关联或映射数组,可以将两个毫无关系的对象相关联。它的基本目标是实现两个对象之间进行关联。更多内容请参考《Hashtable》二、Java2中的容器类库自Java1.2之后Java版本统称为Java2,Java2中的容器类库才可以说是一种真正意义上的集合框架的实现。基本完全重新设计,但是又对Java1中的一些容器类库在新的设计上进行了保留,这主要是为了向下兼容的目的,当用 Java2开发程序时,应尽量避免使用它们,Java2的集合框架已经完全可以满足你的需求。在Java1中容器类库是同步化的,而 Java2中的容器类库都是非同步化,这可能是对执行效率进行考虑的结果。Java2中的集合框架提供了一套设计优良的接口和类,使程序员操作成批的数据或对象元素极为方便。这些接口和类有很多对抽象数据类型操作的API,而这是我们常用的且在数据结构中熟知的。例如Maps,Sets,Lists,Arrays等。并且Java用面向对象的设计对这些数据结构和算法进行了封装,这就极大的减化了程序员编程时的负担。程序员也可以以这个集合框架为基础,定义更高级别的数据抽象,比如栈、队列和线程安全的集合等,从而满足自己的需要。Java2的集合框架,抽其核心,主要有三类:List(包括List,Queue,BlockingQueue)、Set和Map。List和Set继承了Collection,而Map则独成一体。初看上去可能会对Map独成一体感到不解,它为什么不也继承Collection呢?但是这种设计是合理的。一个Map提供了通过Key对Map中存储的Value进行访问,也就是说它操作的都是成对的对象元素,比如put()和get()方法,而这是一个Set或List 所不就具备的。当然在需要时,你可以由keySet()方法或values()方法从一个Map中得到键的Set集或值的Collection集。集合框架中还有两个很实用的公用类:Collections和Arrays。Collections提供了对一个Collection容器进行诸如排序、复制、查找和填充等一些非常有用的方法, Arrays则是对一个数组进行类似的操作。2.1、CollectionCollection接口提供了一组操作成批对象的方法。(它只是个接口)它提供了基本操作如添加、删除。它也支持查询操作如是否为空isEmpty()方法等。为了支持对Collection进行独立操作,Java的集合框架给出了一个Iterator,它使得你可以泛型操作一个Collection,而不需知道这个 Collection的具体实现类型是什么。它的功能与Java1中的Enumeration类似,只是更易掌握和使用,功能也更强大。在建立集合框架时,Sun的开发团队考虑到需要提供一些灵活的接口,用来操作成批的元素,又为了设计的简便,就把那些对集合进行可选操作的方法与基本方法放到了一起。因为一个接口的实现者必须提供对接口中定义的所有方法的实现,这就需要一种途径让调用者知道它正在调用 的可选方法当前不支持。最后开发团队选择使用一种信号,也即抛出一种不支持操作例外(UnsupportedOperationException),如果你在使用一个Collection中遇到一个上述的例外,那就意味着你的操作失败,比如你对一个只读Collection添加一个元素时,你就会得到一个不支持操作例外。在你实现一个集合接口时,你可以很容易的在你不想让用户使用的方法中抛出UnsupportOperationException来告诉使用者这个方法当前没有实现,UnsupportOperationException是RuntimeException的一个扩展。另外Java2的容器类库还有一种Fail fast的机制。比如你正在用一个Iterator遍历一个容器中的对象,这时另外一个线程或进程对那个容器进行了修改,那么再用next()方法时可能会有灾难性的后果,而这是你不愿看到的,这时就会引发一个ConcurrentModificationException例外。这就是 fail-fast。

    51干警网

    2019-12-02 01:42:48

    0 浏览量

    回答数 0

    回答

    你自己也说了,类X没有直接实现接口A和B,但是类X实现的接口D已经继承了接口A和B。

    A a = x; 这一行,并没有发生实例化。实例化的含义是创建对象,这一行并没有创建对象。这一行实际做的是,让引用a指向引用x所指向的对象。对象并没有增加。

    因为类X实现了接口D,而接口D已经继承了接口A和B,所以这一行不会报错。

    任意一个类 M  成功实现了某个接口 N1 或 N2,就可以将 接口 N1,或 接口N2  当成 类 M 的父类看待。进而,子类 M 的对象 m,自然也就是 N1 或 N2 类型的 实例 (或 引用 referene)。这叫向上转型 upcasting。比如,父类 Person 的子类 Student 的对象是 李明, 李明既是学生 Student 类型 (的引用),也是 人 Person 类型 (的引用)。

    在 楼主的案例 里,类 C 要同时实现 接口 A 和 B,但 它不但未能完成要求定义的抽象方法的方法体,而且自身又添加了一个抽象方法。因此,类 C 要冠以 关键词 abstract。

    在 楼主的案例 里,接口 D 同时继承 接口 A 和 B。

    最后,在 楼主的案例 里,类 X 不但成功继承了 类 C, 同时还 实现了接口 D,也就是同时实现了接口 A 和 B。

    这样一来,在 楼主的案例 里,类 X 就可以看作是 接口 A、B、类 C、以及 D 的子类 (subclass/derived_class),类 X 的对象/实体,自然也就可以当做是  接口 A、B、类 C、以及 D 的类型的引用:a、b、c、d ( 这种转变成为 向上转型 upcasting )。用这些引用,自然可以调用相关的方法。

    总之,就楼主的案例而言,虽然 类 class X 没有直接实现接口 interface A 和 interface B ,但是它成功继承了 实现 接口 interface A 和 interface B  的抽象类 abstract C。由此,类 class X 便是其父类 C,以及其父接口   interface A 和 interface B  的子类。于是,类 class X 的 实体/对象 x, 就可以向上转型为 其父类、父接口类型的引用, 即楼主所说的 "为父接口实例化"。

    参考:

    在java 中,什么叫向上转型

    爱吃鱼的程序员

    2020-06-06 09:57:41

    0 浏览量

    回答数 0

    问题

    【精品问答】Java基础测试题 2 答案 | 看你会多少

    一、填空题

    1、Java中通过extends关键字实现继承。

    2、一个类只能继承一个父类,但能实现多个接口。

    3、当子类中定义的方法与父类方法同名且参数类型及个数、返回值类型相同时,称子类方法覆写父类方法&...

    游客pklijor6gytpx

    2019-12-01 22:04:54

    334 浏览量

    回答数 0

    回答

    一、OOP三大基本特性 OOP

    面向对象程序设计(Object Oriented Programming)作为一种新方法,其本质是以建立模型体现出来的抽象思维过程和面向对象的方法。模型是用来反映现实世界中事物特征的。任何一个模型都不可能反映客观事物的一切具体特征,只能对事物特征和变化规律的一种抽象,且在它所涉及的范围内更普遍、更集中、更深刻地描述客体的特征。通过建立模型而达到的抽象是人们对客体认识的深化。 封装

    封装,也就是把客观事物封装成抽象的类,并且类可以把自己的属性和方法只让可信的类操作,对不可信的进行信息隐藏。 继承

    继承是指这样一种能力,它可以使用现有的类的所有功能,并在无需重新编写原来类的情况下对这些功能进行扩展。 多态

    多态指一个类实例的相同方法在不同情形有不同的表现形式。具体来说就是不同实现类对公共接口有不同的实现方式,但这些操作可以通过相同的方式(公共接口)予以调用。 二、OOD七大原则

    面向对象设计(OOD)有七大原则,它们互相补充 开-闭原则

    Open-Close Principle(OCP),即开-闭原则。开,指的是对扩展开放,即要支持方便地扩展;闭,指的是对修改关闭,即要严格限制对已有内容的修改。开-闭原则是最抽象也是最重要的OOD原则。简单工厂模式、工厂方法模式、抽象工厂模式中都提到了如何通过良好的设计遵循开-闭原则。 里氏替换原则

    Liskov Substitution Principle(LSP),即里氏替换原则。该原则规定“子类必须能够替换其父类,否则不应当设计为其子类”。换句话说,父类出现的地方,都应该能由其子类代替。所以,子类只能去扩展基类,而不是隐藏或者覆盖基类。 依赖倒置原则

    Dependence Inversion Principle(DIP),依赖倒置原则。它讲的是“设计和实现要依赖于抽象而非具体”。一方面抽象化更符合人的思维习惯;另一方面,根据里氏替换原则,可以很容易将原来的抽象替换为扩展后的具体,这样可以很好的支持开-闭原则。 接口隔离原则

    Interface Segration Principle(ISP),接口隔离原则,“将大的接口打散成多个小的独立的接口”。由于Java类支持实现多个接口,可以很容易的让类具有多种接口的特征,同时每个类可以选择性地只实现目标接口。 单一职责原则

    Single Responsibility Principle(SRP),单一职责原则。它讲的是,不要存在多于一个导致类变更的原因,是高内聚低耦合的一个体现。 迪米特法则/最少知道原则

    Law of Demeter or Least Knowledge Principle(LoD or LKP),迪米特法则或最少知道原则。它讲的是“一个对象就尽可能少的去了解其它对象”,从而实现松耦合。如果一个类的职责过多,由于多个职责耦合在了一起,任何一个职责的变更都可能引起其它职责的问题,严重影响了代码的可维护性和可重用性。 合成/聚合复用原则

    Composite/Aggregate Reuse Principle(CARP / CRP),合成/聚合复用原则。如果新对象的某些功能在别的已经创建好的对象里面已经实现,那么应当尽量使用别的对象提供的功能,使之成为新对象的一部分,而不要再重新创建。新对象可通过向这些对象的委派达到复用已有功能的效果。简而言之,要尽量使用合成/聚合,而非使用继承。

    景凌凯

    2020-03-19 23:49:30

    0 浏览量

    回答数 0

    回答

    Java提供了一套实现了Collection接口的标准集合类。其中一些是具体类,这些类可以直接拿来使用,而另外一些是抽象类,提供了接口的部分实现。

    标准集合类汇总于下表:

    序号类描述1AbstractCollection 实现了大部分的集合接口。2AbstractList 继承于AbstractCollection 并且实现了大部分List接口。3AbstractSequentialList 继承于 AbstractList ,提供了对数据元素的链式访问而不是随机访问。4LinkedList 该类实现了List接口,允许有null(空)元素。主要用于创建链表数据结构,该类没有同步方法,如果多个线程同时访问一个List,则必须自己实现访问同步,解决方法就是在创建List时候构造一个同步的List。例如:List list=Collections.synchronizedList(newLinkedList(...));LinkedList 查找效率低。5ArrayList 该类也是实现了List的接口,实现了可变大小的数组,随机访问和遍历元素时,提供更好的性能。该类也是非同步的,在多线程的情况下不要使用。ArrayList 增长当前长度的50%,插入删除效率低。6AbstractSet 继承于AbstractCollection 并且实现了大部分Set接口。7HashSet 该类实现了Set接口,不允许出现重复元素,不保证集合中元素的顺序,允许包含值为null的元素,但最多只能一个。8LinkedHashSet 具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。9TreeSet 该类实现了Set接口,可以实现排序等功能。10AbstractMap 实现了大部分的Map接口。11HashMap HashMap 是一个散列表,它存储的内容是键值对(key-value)映射。 该类实现了Map接口,根据键的HashCode值存储数据,具有很快的访问速度,最多允许一条记录的键为null,不支持线程同步。12TreeMap 继承了AbstractMap,并且使用一颗树。13WeakHashMap 继承AbstractMap类,使用弱密钥的哈希表。14LinkedHashMap 继承于HashMap,使用元素的自然顺序对元素进行排序.15IdentityHashMap 继承AbstractMap类,比较文档时使用引用相等。

    huc_逆天

    2021-01-08 14:25:56

    0 浏览量

    回答数 0

    回答

    Java 语言定义了一些异常类在 java.lang 标准包中。

    标准运行时异常类的子类是最常见的异常类。由于 java.lang 包是默认加载到所有的 Java 程序的,所以大部分从运行时异常类继承而来的异常都可以直接使用。

    Java 根据各个类库也定义了一些其他的异常,下面的表中列出了 Java 的非检查性异常。

    异常描述ArithmeticException当出现异常的运算条件时,抛出此异常。例如,一个整数"除以零"时,抛出此类的一个实例。ArrayIndexOutOfBoundsException用非法索引访问数组时抛出的异常。如果索引为负或大于等于数组大小,则该索引为非法索引。ArrayStoreException试图将错误类型的对象存储到一个对象数组时抛出的异常。ClassCastException当试图将对象强制转换为不是实例的子类时,抛出该异常。IllegalArgumentException抛出的异常表明向方法传递了一个不合法或不正确的参数。IllegalMonitorStateException抛出的异常表明某一线程已经试图等待对象的监视器,或者试图通知其他正在等待对象的监视器而本身没有指定监视器的线程。IllegalStateException在非法或不适当的时间调用方法时产生的信号。换句话说,即 Java 环境或 Java 应用程序没有处于请求操作所要求的适当状态下。IllegalThreadStateException线程没有处于请求操作所要求的适当状态时抛出的异常。IndexOutOfBoundsException指示某排序索引(例如对数组、字符串或向量的排序)超出范围时抛出。NegativeArraySizeException如果应用程序试图创建大小为负的数组,则抛出该异常。NullPointerException当应用程序试图在需要对象的地方使用 null 时,抛出该异常NumberFormatException当应用程序试图将字符串转换成一种数值类型,但该字符串不能转换为适当格式时,抛出该异常。SecurityException由安全管理器抛出的异常,指示存在安全侵犯。StringIndexOutOfBoundsException此异常由 String 方法抛出,指示索引或者为负,或者超出字符串的大小。UnsupportedOperationException当不支持请求的操作时,抛出该异常。

    下面的表中列出了 Java 定义在 java.lang 包中的检查性异常类。

    异常描述ClassNotFoundException应用程序试图加载类时,找不到相应的类,抛出该异常。CloneNotSupportedException当调用 Object 类中的 clone 方法克隆对象,但该对象的类无法实现 Cloneable 接口时,抛出该异常。IllegalAccessException拒绝访问一个类的时候,抛出该异常。InstantiationException当试图使用 Class 类中的 newInstance 方法创建一个类的实例,而指定的类对象因为是一个接口或是一个抽象类而无法实例化时,抛出该异常。InterruptedException一个线程被另一个线程中断,抛出该异常。NoSuchFieldException请求的变量不存在NoSuchMethodException请求的方法不存在

    huc_逆天

    2021-01-08 14:08:25

    0 浏览量

    回答数 0

    问题

    Java基础

    面向对象有那三大特征

    类由什么组成

    "什么运算符的作用是根据对象的类型分配内存空间。当对象拥有内存空间时,会自动调用类中的构造方法 为对象实例化。"

    使用____修饰的类成员称为私有成员。私有成员只...

    游客pklijor6gytpx

    2019-12-01 22:02:53

    69 浏览量

    回答数 1

    问题

    Java技术1000问(3)【精品问答】

    为了方便Java开发者快速找到相关技术问题和答案,开发者社区策划了Java技术1000问内容,包含最基础的Java语言概述、数据类型和运算符、面向对象等维度内容。

    我们会以每天至少50条的速度,增...

    问问小秘

    2020-06-02 14:27:10

    11463 浏览量

    回答数 3

    问题

    当具体的JPA实体类与其通用超类位于不同的包中时,问题加载应用程序

    最近,我正在重组和重构代码,其中一项任务是将类归类到逻辑组/程序包中。由于我在泛型中使用了很多继承/子类,因此我通常将父类留在原处,并将其子类移到单独的子包中。

    下面是目录ÿ...

    几许相思几点泪

    2019-12-22 18:29:45

    21 浏览量

    回答数 1

    回答

    异常是程序中的一些错误,但并不是所有的错误都是异常,并且错误有时候是可以避免的。

    比如说,你的代码少了一个分号,那么运行出来结果是提示是错误 java.lang.Error;如果你用System.out.println(11/0),那么你是因为你用0做了除数,会抛出 java.lang.ArithmeticException 的异常。

    异常发生的原因有很多,通常包含以下几大类:

    用户输入了非法数据。 要打开的文件不存在。 网络通信时连接中断,或者JVM内存溢出。 这些异常有的是因为用户错误引起,有的是程序错误引起的,还有其它一些是因为物理错误引起的。- 要理解Java异常处理是如何工作的,你需要掌握以下三种类型的异常:

    检查性异常:最具代表的检查性异常是用户错误或问题引起的异常,这是程序员无法预见的。例如要打开一个不存在文件时,一个异常就发生了,这些异常在编译时不能被简单地忽略。 运行时异常: 运行时异常是可能被程序员避免的异常。与检查性异常相反,运行时异常可以在编译时被忽略。 错误: 错误不是异常,而是脱离程序员控制的问题。错误在代码中通常被忽略。例如,当栈溢出时,一个错误就发生了,它们在编译也检查不到的。 Exception 类的层次 所有的异常类是从 java.lang.Exception 类继承的子类。

    Exception 类是 Throwable 类的子类。除了Exception类外,Throwable还有一个子类Error 。

    Java 程序通常不捕获错误。错误一般发生在严重故障时,它们在Java程序处理的范畴之外。

    Error 用来指示运行时环境发生的错误。

    例如,JVM 内存溢出。一般地,程序不会从错误中恢复。

    异常类有两个主要的子类:IOException 类和 RuntimeException 类。

    在 Java 内置类中(接下来会说明),有大部分常用检查性和非检查性异常。

    Java 内置异常类 Java 语言定义了一些异常类在 java.lang 标准包中。

    标准运行时异常类的子类是最常见的异常类。由于 java.lang 包是默认加载到所有的 Java 程序的,所以大部分从运行时异常类继承而来的异常都可以直接使用。

    Java 根据各个类库也定义了一些其他的异常,下面的表中列出了 Java 的非检查性异常。

    异常 描述 ArithmeticException 当出现异常的运算条件时,抛出此异常。例如,一个整数"除以零"时,抛出此类的一个实例。 ArrayIndexOutOfBoundsException 用非法索引访问数组时抛出的异常。如果索引为负或大于等于数组大小,则该索引为非法索引。 ArrayStoreException 试图将错误类型的对象存储到一个对象数组时抛出的异常。 ClassCastException 当试图将对象强制转换为不是实例的子类时,抛出该异常。 IllegalArgumentException 抛出的异常表明向方法传递了一个不合法或不正确的参数。 IllegalMonitorStateException 抛出的异常表明某一线程已经试图等待对象的监视器,或者试图通知其他正在等待对象的监视器而本身没有指定监视器的线程。 IllegalStateException 在非法或不适当的时间调用方法时产生的信号。换句话说,即 Java 环境或 Java 应用程序没有处于请求操作所要求的适当状态下。 IllegalThreadStateException 线程没有处于请求操作所要求的适当状态时抛出的异常。 IndexOutOfBoundsException 指示某排序索引(例如对数组、字符串或向量的排序)超出范围时抛出。 NegativeArraySizeException 如果应用程序试图创建大小为负的数组,则抛出该异常。 NullPointerException 当应用程序试图在需要对象的地方使用 null 时,抛出该异常 NumberFormatException 当应用程序试图将字符串转换成一种数值类型,但该字符串不能转换为适当格式时,抛出该异常。 SecurityException 由安全管理器抛出的异常,指示存在安全侵犯。 StringIndexOutOfBoundsException 此异常由 String 方法抛出,指示索引或者为负,或者超出字符串的大小。 UnsupportedOperationException 当不支持请求的操作时,抛出该异常。 下面的表中列出了 Java 定义在 java.lang 包中的检查性异常类。

    异常 描述 ClassNotFoundException 应用程序试图加载类时,找不到相应的类,抛出该异常。 CloneNotSupportedException 当调用 Object 类中的 clone 方法克隆对象,但该对象的类无法实现 Cloneable 接口时,抛出该异常。 IllegalAccessException 拒绝访问一个类的时候,抛出该异常。 InstantiationException 当试图使用 Class 类中的 newInstance 方法创建一个类的实例,而指定的类对象因为是一个接口或是一个抽象类而无法实例化时,抛出该异常。 InterruptedException 一个线程被另一个线程中断,抛出该异常。 NoSuchFieldException 请求的变量不存在 NoSuchMethodException 请求的方法不存在 异常方法 下面的列表是 Throwable 类的主要方法:

    序号 方法及说明 1 public String getMessage() 返回关于发生的异常的详细信息。这个消息在Throwable 类的构造函数中初始化了。 2 public Throwable getCause() 返回一个Throwable 对象代表异常原因。 3 public String toString() 使用getMessage()的结果返回类的串级名字。 4 public void printStackTrace() 打印toString()结果和栈层次到System.err,即错误输出流。 5 public StackTraceElement [] getStackTrace() 返回一个包含堆栈层次的数组。下标为0的元素代表栈顶,最后一个元素代表方法调用堆栈的栈底。 6 public Throwable fillInStackTrace() 用当前的调用栈层次填充Throwable 对象栈层次,添加到栈层次任何先前信息中。 捕获异常 使用 try 和 catch 关键字可以捕获异常。try/catch 代码块放在异常可能发生的地方。

    try/catch代码块中的代码称为保护代码,使用 try/catch 的语法如下:

    try { // 程序代码 }catch(ExceptionName e1) { //Catch 块 } Catch 语句包含要捕获异常类型的声明。当保护代码块中发生一个异常时,try 后面的 catch 块就会被检查。

    如果发生的异常包含在 catch 块中,异常会被传递到该 catch 块,这和传递一个参数到方法是一样。

    实例 下面的例子中声明有两个元素的一个数组,当代码试图访问数组的第三个元素的时候就会抛出一个异常。

    ExcepTest.java 文件代码: // 文件名 : ExcepTest.java import java.io.*; public class ExcepTest{

    public static void main(String args[]){ try{ int a[] = new int[2]; System.out.println("Access element three :" + a[3]); }catch(ArrayIndexOutOfBoundsException e){ System.out.println("Exception thrown :" + e); } System.out.println("Out of the block"); } } 以上代码编译运行输出结果如下:

    Exception thrown :java.lang.ArrayIndexOutOfBoundsException: 3 Out of the block 多重捕获块 一个 try 代码块后面跟随多个 catch 代码块的情况就叫多重捕获。

    多重捕获块的语法如下所示:

    try{ // 程序代码 }catch(异常类型1 异常的变量名1){ // 程序代码 }catch(异常类型2 异常的变量名2){ // 程序代码 }catch(异常类型3 异常的变量名3){ // 程序代码 } 上面的代码段包含了 3 个 catch块。

    可以在 try 语句后面添加任意数量的 catch 块。

    如果保护代码中发生异常,异常被抛给第一个 catch 块。

    如果抛出异常的数据类型与 ExceptionType1 匹配,它在这里就会被捕获。

    如果不匹配,它会被传递给第二个 catch 块。

    如此,直到异常被捕获或者通过所有的 catch 块。

    实例 该实例展示了怎么使用多重 try/catch。

    try { file = new FileInputStream(fileName); x = (byte) file.read(); } catch(FileNotFoundException f) { // Not valid! f.printStackTrace(); return -1; } catch(IOException i) { i.printStackTrace(); return -1; } throws/throw 关键字: 如果一个方法没有捕获到一个检查性异常,那么该方法必须使用 throws 关键字来声明。throws 关键字放在方法签名的尾部。

    也可以使用 throw 关键字抛出一个异常,无论它是新实例化的还是刚捕获到的。

    下面方法的声明抛出一个 RemoteException 异常:

    import java.io.*; public class className { public void deposit(double amount) throws RemoteException { // Method implementation throw new RemoteException(); } //Remainder of class definition } 一个方法可以声明抛出多个异常,多个异常之间用逗号隔开。

    例如,下面的方法声明抛出 RemoteException 和 InsufficientFundsException:

    import java.io.*; public class className { public void withdraw(double amount) throws RemoteException, InsufficientFundsException { // Method implementation } //Remainder of class definition } finally关键字 finally 关键字用来创建在 try 代码块后面执行的代码块。

    无论是否发生异常,finally 代码块中的代码总会被执行。

    在 finally 代码块中,可以运行清理类型等收尾善后性质的语句。

    finally 代码块出现在 catch 代码块最后,语法如下:

    try{ // 程序代码 }catch(异常类型1 异常的变量名1){ // 程序代码 }catch(异常类型2 异常的变量名2){ // 程序代码 }finally{ // 程序代码 } 实例 ExcepTest.java 文件代码: public class ExcepTest{ public static void main(String args[]){ int a[] = new int[2]; try{ System.out.println("Access element three :" + a[3]); }catch(ArrayIndexOutOfBoundsException e){ System.out.println("Exception thrown :" + e); } finally{ a[0] = 6; System.out.println("First element value: " +a[0]); System.out.println("The finally statement is executed"); } } } 以上实例编译运行结果如下:

    Exception thrown :java.lang.ArrayIndexOutOfBoundsException: 3 First element value: 6 The finally statement is executed 注意下面事项:

    catch 不能独立于 try 存在。 在 try/catch 后面添加 finally 块并非强制性要求的。 try 代码后不能既没 catch 块也没 finally 块。 try, catch, finally 块之间不能添加任何代码。 声明自定义异常 在 Java 中你可以自定义异常。编写自己的异常类时需要记住下面的几点。 所有异常都必须是 Throwable 的子类。 如果希望写一个检查性异常类,则需要继承 Exception 类。 如果你想写一个运行时异常类,那么需要继承 RuntimeException 类。 可以像下面这样定义自己的异常类:

    class MyException extends Exception{ } 只继承Exception 类来创建的异常类是检查性异常类。

    下面的 InsufficientFundsException 类是用户定义的异常类,它继承自 Exception。

    一个异常类和其它任何类一样,包含有变量和方法。

    实例 以下实例是一个银行账户的模拟,通过银行卡的号码完成识别,可以进行存钱和取钱的操作。

    InsufficientFundsException.java 文件代码: // 文件名InsufficientFundsException.java import java.io.*;

    //自定义异常类,继承Exception类 public class InsufficientFundsException extends Exception { //此处的amount用来储存当出现异常(取出钱多于余额时)所缺乏的钱 private double amount; public InsufficientFundsException(double amount) { this.amount = amount; } public double getAmount() { return amount; } } 为了展示如何使用我们自定义的异常类,

    在下面的 CheckingAccount 类中包含一个 withdraw() 方法抛出一个 InsufficientFundsException 异常。

    CheckingAccount.java 文件代码: // 文件名称 CheckingAccount.java import java.io.*;

    //此类模拟银行账户 public class CheckingAccount { //balance为余额,number为卡号 private double balance; private int number; public CheckingAccount(int number) { this.number = number; } //方法:存钱 public void deposit(double amount) { balance += amount; } //方法:取钱 public void withdraw(double amount) throws InsufficientFundsException { if(amount <= balance) { balance -= amount; } else { double needs = amount - balance; throw new InsufficientFundsException(needs); } } //方法:返回余额 public double getBalance() { return balance; } //方法:返回卡号 public int getNumber() { return number; } } 下面的 BankDemo 程序示范了如何调用 CheckingAccount 类的 deposit() 和 withdraw() 方法。

    BankDemo.java 文件代码: //文件名称 BankDemo.java public class BankDemo { public static void main(String [] args) { CheckingAccount c = new CheckingAccount(101); System.out.println("Depositing $500..."); c.deposit(500.00); try { System.out.println("\nWithdrawing $100..."); c.withdraw(100.00); System.out.println("\nWithdrawing $600..."); c.withdraw(600.00); }catch(InsufficientFundsException e) { System.out.println("Sorry, but you are short $" + e.getAmount()); e.printStackTrace(); } } } 编译上面三个文件,并运行程序 BankDemo,得到结果如下所示:

    Depositing $500...

    Withdrawing $100...

    Withdrawing $600... Sorry, but you are short $200.0 InsufficientFundsException at CheckingAccount.withdraw(CheckingAccount.java:25) at BankDemo.main(BankDemo.java:13) 通用异常 在Java中定义了两种类型的异常和错误。

    JVM(Java虚拟机) 异常:由 JVM 抛出的异常或错误。例如:NullPointerException 类,ArrayIndexOutOfBoundsException 类,ClassCastException 类。 程序级异常:由程序或者API程序抛出的异常。例如 IllegalArgumentException 类,IllegalStateException 类。

    游客2q7uranxketok

    2021-02-07 20:08:10

    0 浏览量

    回答数 0

    问题

    【精品问答】Java实战200例(附源码)

    Java实战200例(附源码)

    1.编写一个Java程序,用if-else语句判断某年份是否为闰年

    2. 编写一个Java程序在屏幕上输出1!+2!+...

    珍宝珠

    2020-02-14 11:55:46

    16104 浏览量

    回答数 10

    问题

    java二叉树模板抽象化

    我有两个二叉树类,分别管理着不同的数据

    class bt1{

    //自身业务逻辑

    String s;

    public String getS(){

    return "godness " + s;

    }

    //二叉树逻辑

    bt1 left;

    bt1 r...

    蛮大人123

    2019-12-01 19:39:48

    1166 浏览量

    回答数 1

    展开全文
  • 抽象类和接口

    千次阅读 2020-11-24 19:38:35
    抽象类 ​ 概述 ​ 父类当中的方法,被他的子类们重写,子类的各自实现又不一样。那么父类的方法声明和方法体,只有声明还有意义,而方法体内容则没有存在的意义。我们把这种没有方法体内容的方法称为抽象方法。...

    抽象类

    ​ 概述

    ​ 父类当中的方法,被他的子类们重写,子类的各自实现又不一样。那么父类的方法声明和方法体,只有声明还有意义,而方法体内容则没有存在的意义。我们把这种没有方法体内容的方法称为抽象方法。Java语言规定,如果一个类包含了抽象的方法。那么该类就是一个抽象类

    定义:

    ​ 抽象方法:没有方法体的方法

    ​ 抽象类:包含抽象方法的类

    abstract关键字的使用格式

    ​ 抽象方法

    ​ 使用abstract关键字修饰成员方法,该方法就成了抽象方法,抽象方法只包含一个方法名,而没有方法体。

    ​ 定义格式:

    修饰符   abstract 返回值类型  方法名(参数列表);
    

    示例代码:

    public abstract void run();
    // 吃饭的抽象方法
    public abstract void eat();
    // 跳跃的抽象方法
    public abstract void jump(); 
    
    抽象类

    ​ 如果一个类包含了抽象方法,那么该类就是一个抽象类。

    定义格式:

    修饰符 abstract class ClassName {}
    

    示例代码:

    public abstract class Animal {
        // 奔跑的抽象方法
        public abstract void run();
    }
    

    抽象的使用

    继承抽象类的子类必须重写父类所有的抽象方法。否则,该子类也必须声明为一个抽象类。

    注意事项

    关于抽象类的使用,需要注意的事项:

    1. 抽象类不能创建对象,如果创建对象,编译无法通过。只能创建其非抽象子类的对象。
    2. 抽象类中,可以有构造方法,是供子类创建对象时,初始化父类成员使用的。
    3. 抽象类中,不一定包含抽象方法,但是有抽象方法的类必定是抽象类。
    4. 抽象类的子类,必须重写父类中的所有的抽象方法,否则编译无法通过,除非该子类也是抽象类。

    接口

    概述

    ​ 接口,是Java语言中一种引用类型,是方法的集合,如果说类的内部封装了成员变量、构造方法和成员方法,那么接口的内部主要就是【封装了方法】,包含了抽象方法(JDK1.7及以前),默认方法和静态的方法(JDK1.8),私有方法(JDK1.9)

    ​ 接口的定义,它与类的定义很相似,但是使用interface关键字,他也会被编译生成class文件,但一定要明确他并不是类,而是另外一种引用数据类型。

    引用数据类型:类、数组、接口。

    接口的使用,不能直接创建对象,但是可以被实现(implements关键字,类似于被继承),一个实现接口的类(可以看做是接口的子类),需要重写接口中的所有的抽象方法,创建该类对象,就可以调用方法了。

    接口的定义格式:

    public interface 接口名称{
        // 抽象方法为主
        // 默认方法
        // 常量
        // 静态方法
        // 私有方法(JDK1.9)
    }
    

    含有抽象方法

    抽象方法:使用abstract关键字修饰,没有方法体内容,该方法主要是供子类使用的

    public interface InterfaceName{
        public abstract
    }
    

    含有默认方法和静态方法

    默认方法:使用default关键字修饰的方法,不可省略,供子类调用或者子类重写。

    静态方法:使用static关键字修饰的方法,供接口直接使用。

    含有私有方法和私有静态的方法

    私有方法:使用private关键字,供接口中的默认方法或者静态方法调用。

    代码如下:

    public interface InterfaceName{
        private void method(){
            // 方法体内容。
        }
    }
    

    基本的实现

    实现的概述

    类与接口的关系,为实现关系,即类实现接口,该类可以称为接口的实现类,也可以称为

    接口的子类,(实现的动作类似于继承,格式相仿,只是关键字不同,实现使用implements关键字)

    非抽象类实现接口:

    1.必须重写接口当中的所有的抽象方法

    2.继承了接口的当中的默认方法,既可以直接调用,也可以重写

    实现格式:

    public class 实现类 implements 接口名称{
        // 重写接口当中的所有的抽象方法
        // 重写接口当中的默认方法
    }
    

    抽象方法的使用:

    必须全部实现:

    代码如下: 定义一个接口:

    public interface Biological{// 生物
        // 定义一个吃东西的功能
        public abstract void eat();
        // 定义一个休息的功能
        public abstract void sleep();
    }
    // 定义一个实现类
    public class Animal implements Biological{
        @Override
        public void eat(){
            System.out.println("吃东西");
        }
        @Override
        public void sleep(){
            System.out.println("睡觉");
        }
    }
    
    // 定义测试类
    public class InterfaceDemo01{
        public static void main(String[] args){
            // 创建子类对象
            Animal ani = new Animal();
            // 调用重写之后的方法
            ani.eat();
            ani.sleep();
        }
    }
    // 输出结果:
    // 吃东西
    // 睡觉
    
    

    默认方法的使用

    可以继承,可以重写,二选一,但是只能通过实现类的对象来调用

    1.继承默认方法,代码如下

    public interface Biological{
      public default void fly(){
        System.out.println("天上飞");
    }
    }
    // 定义实现类
    public class Animal implements Biological{
        // 继承 什么也不写,直接调用
    }
    // 定义测试类
    public class InterfaceDemo02{
        
      public static void main(String[] args){
          // 创建子类对象
          Animal ani = new Animal();
          // 调用默认方法
          ani.fly();
      }
    }
    // 输出结果:天上飞
    

    2.重写默认方法,代码如下:

    public interface Biological{
      public default void fly(){
        System.out.println("天上飞");
    }
    }
    // 定义实现类
    public class Animal implements Biological{
     //重写
     @Override
        public void fly(){
            System.out.println("自由自在的飞");
        }
    }
    
    public class InterfaceDemo03{
        
      public static void main(String[] args){
          // 创建子类对象
          Animal ani = new Animal();
          // 调用默认方法
          ani.fly();
      }
    }
    // 输出结果:自由自在的飞
    

    静态方法的使用

    静态的一般都是和类.class文件相关,只能使用【接口名】来调用,不可以通过实现类的类名或者是实现类的对象来调用。代码如下:

    public interface Biological{
      public static void run(){
        System.out.println("跑起来。。");
    }
    }
    // 定义实现类
    public class Animal implements Biological{
     // 无法重写静态方法
    }
    
    // 定义测试类
    public class InterfaceDemo04{
      public static void main(String[] args){
          // 调用静态方法
         Biological.fly();
      }
    }
    // 输出结果:跑起来
    
    

    私有方法的使用

    私有方法: 只有默认方法可以调用

    私有静态方法: 默认方法和静态方法都可以调用

    如果一个接口中有多个默认方法,并且方法中有重复的内容,那么可以抽取出来,封装到私有方法中,

    供默认方法去调用。从设计的角度考虑,私有的方法是对默认的方法和静态的方法的一种辅助。

    // 定义一个接口
    public interface Biological{
        private void run1(){
            System.out.println("跑起来。。");
        }
        private default void funMethod01(){
            //System.out.println("跑起来。。");
            run1();
        }
        private default void funMethod02(){
            //System.out.println("跑起来。。");
            run1();
        }
    }
    

    接口的多实现

    在继承体系中,一个类只能直接继承一个父类,而对于接口来说,一个类可以实现多个接口,这叫做接

    口的【多实现】。并且,一个类能直接继承一个父类的同时还可以实现多个接口。

    实现格式:

    public class ClassName extends 父类 implements 接口名1,接口名2,...{
        //重写接口中的所有的抽象方法
        //重写接口中的默认方法(可选)
        //抽象方法重名
    }
    

    抽象方法

    接口中,有多个抽象方法,实现类必须重写所有的抽象方法,如果抽象方法名有重名的,只需要重写一

    次即可,代码如下:

    // 定义多个接口
    public interface Animal{
        public abstract void eat();
        public abstract void run();
    }
    public interface Human{
        public abstract void eat();
        public abstract void run();
    }
    // 继承实现类
    public class People implements Animal,Human{
        @Override
        public void eat(){
            System.out.println("吃东西!");
        }
        @Override
        public void run(){
            System.out.println("健身。。");
        }
    }
    

    默认方法

    接口中,有多个默认方法时,实现类都可继承使用,如果默认方法有重名的,【必须重写一次】代码如下:

    public interface A{
        public default void methodA(){}
        public default void method(){}
    }
    public interface B{
        public default void methodB(){}
        public default void method(){}
    }
    // 定义实现类
    public class C implements A,B{
        @Override
        public void method(){
            System.out.println("method方法被重写。。。");
        }
    }
    

    静态方法

    接口中,如果存在同名的静态方法并不会冲突,原因是只能通过各自的接口名访问静态方法。

    优先级的问题

    当一个类,既继承了一个父类,又同时实现类多个接口,父类中的成员方法与接口当中的默认方法

    重名,子类就近选择父类的成员方法。

    代码如下:

    public interface A{
        public default void methodA(){
            System.out.println("AAAAAAAA");
        }
    }
    // 定义父类
    public class D{
        public void methodA(){
            System.out.println("DDDDDDDD");
        }
    }
    // 定义子类
    public class E extends D implements A{
        // 未重写methodA()
    }
    // 定义测试类
    public class TestInterfaceDemo06{
        public static void main(String[] args){
            // 创建子类对象E
            E e = new E();
            e.methodA();
        }
    }
    //输出结果:DDDDDDDD
    

    接口的多继承【了解】

    一个接口能继承另一个或者多个接口,这和类之间的继承比较相似。接口的继承使用extends关键字,子接口继承父接口的方法,如果父接口中的默认方法有重名方法,那么子接口需要重写一次。代码如下:

    public interface A{
    public default void method(){
        System.out.println("AAAAAAAAAA");
    }
    }
    public interface B{
        public default void method(){
             System.out.println("BBBBBBBBBB");
        }
    }
    // 定义子接口
    public interface C extends A,B{
        @Override
        public default void method(){
            System.out.println("CCCCCCCCCC");
        }
    }
    

    备注:子接口重写默认方法,default保留。

    其他成员特点:

    接口中,无法定义成员变量,但是可以定义常量,因为值不可变,默认使用public static final 修饰的

    接口中,没有构造方法,不能创建对象

    接口当中,没有静态代码块

    接口的好处:

    设定了规则

    降低耦合性【高内聚,低耦合】

    扩展原有类的功能

    接口与抽象类的区别:

    相同点:

    • 都包含抽象方法,其子类都必须重写这些抽象方法
    • 都不能直接实例化对象
    • 都位于继承的顶端,用于被其他类实现或者继承

    区别 :

    • 抽象类里面可以包含普通成员方法,接口不能包含普通成员方法
    • 一个类只能直接继承一个父类(可以是抽象类),一个类也可以实现多个接口
    • 类与类之间只能时单继承关系,接口与接口之间可以多继承
    • 抽象类可以定义普通的成员变量和常量,接口只能定义常量 public static final 修饰的
    展开全文
  • Java 抽象类和接口

    千次阅读 热门讨论 2021-11-14 16:09:56
    文章目录一、抽象类1.抽象类1.1抽象类的定义1.2抽象方法的定义方式1.3抽象类的定义方式2.抽象类和实例类的区别3.抽象类示例4.抽象类的特征二、接口1.接口1.1接口的定义1.1定义一个接口1.2 接口的使用1.3接口的注意...
  • Java抽象类 详解

    万次阅读 多人点赞 2016-10-05 00:06:35
    一、抽象类的基本概念普通类是一个完善的功能类,可以直接产生实例化对象,并且在普通类中可以包含有构造方法、普通方法、static方法、常量和变量等内容。而抽象类是指在普通类的结构里面增加抽象方法的组成部分。...
  • Java-抽象类

    千次阅读 2021-02-26 09:29:41
    抽象类含有抽象方法的类就是抽象类1) 抽象方法:该方法有返回值,有参数,就是没有方法体,该方法没有方法实现2) 抽象方法的格式:abstract 返回值类型 方法名(参数列表);3) 抽象类需要靠子类来重写抽象方法,以...
  • Java抽象方法和抽象类

    千次阅读 2022-04-22 15:41:00
    1、抽象方法 如果父类的方法本身不需要实现任何功能,仅仅是为了定义方法签名,目的是让子类去...因为这个抽象方法本身是无法执行的,所以Person无法被实例化。并且编译器会报错无法编译Person,因为它包含抽...
  • 【Java语法】包 继承 多态 抽象类 接口

    千次阅读 多人点赞 2022-03-20 14:17:40
    如果某个成员不包含 public 和 private 关键字, 此时这个成员可以在包内部的其他使用, 但是不能在包外部的使用. 二、继承 继承 对共性的抽取,使用extends关键字进行处理,可以对代码重复使用 语
  • 抽象类是否可实现(implements)接口?抽象类是否可继承具体类?抽象类中是否可以有静态的main方法? 上面这个题目我们来慢慢的剖析一下。先从基本的概念说起。 一、接口 官方解释:Java接口是一系列方法的声明,是一些...
  • 抽象类+抽象方法

    千次阅读 2021-01-09 15:56:30
    对于这样的场景,我们可以将动物类,设计为抽象类抽象类不能被实例化对象,只是提供了所有的子类的共有的部分,为了给所有的子类定义公共属性 abstract class Animal{ String name; int age; public void eat(){} ...
  • 你知道java当中的普通类和抽象类之间有什么区别吗?这两者的不同之处究竟是什么呢?下面就和小编一起来详细的了解一下吧。一、抽象类和普通类区别抽象类和普通类的区别我们做了以下7点简单的总结,相信看了的朋友应该...
  • JAVA——抽象类

    千次阅读 2021-03-09 00:47:50
    一、抽象类的概念包含一个抽象方法的类就是抽象类,其本质是对多个普通类中相同的部分的抽象。二、抽象类的特点1.抽象方法和抽象类使用 abstract 修饰;2.有一个抽象方法的类必须是抽象类;3.抽象类中一定有抽象方法...
  • python中的抽象类

    千次阅读 2021-06-09 08:57:07
    python中的抽象类 1.首先知道python中的抽象类其实就是一种代码规范,和前面两篇文章python中的单继承和python中的多继承说的都是一个道理归根到底都是为了代码规范,同样也是从Java中继承的思想,抽象类一般都是单...
  • Java中抽象类和接口的区别

    万次阅读 多人点赞 2019-02-07 14:10:07
    在Java中,可以通过两种形式来体现OOP的抽象:接口和抽象类。这两者有太多相似的地方,又有太多不同的地方。很多人在初学的时候会以为它们可以随意互换使用,但是实际则不然。今天我们就一起来学习一下Java中的接口...
  • Java——抽象类

    千次阅读 2022-01-04 11:48:57
    目录Java——抽象类一、抽象类的基本概念二、抽象类的使用原则举例抽象类的使用原则:三、抽象类的使用限制1、抽象类中有构造方法吗?2、抽象类可以被final修饰吗?3、抽象类可以被static修饰吗?4、可以直接调用...
  • 你知道java当中抽象类的作用是什么吗?有什么作用?下面和小编一起来详细的了解一下具体的作用,以及看看抽象类作用的例子吧!一、java抽象类的作用java抽象类的作用具体的可以分成以下的三点:1、抽象类通常都是用来...
  • java抽象类详解

    千次阅读 2021-02-25 18:11:57
    前言在没讲抽象类之前 我们先来看看 final关键字final 修饰符 可以修饰 类、属性、方法修饰类时 表示该类不能被继承 其他特征 跟普通的类一样修饰 属性时 表示 改属性不能改变 并且 必须赋初始值修饰方法时 表示该...
  • 抽象类和接口的区别以及抽象类和接口的使用场景

    万次阅读 多人点赞 2019-05-30 18:15:44
    一、抽象类 在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就可以称之为抽象类。 1.抽象方法...
  • java学习笔记(12-继承、抽象类

    千次阅读 2021-03-15 17:45:41
    1.继承关键字extendsjava中继承特点:在Java中,只支持单继承,不允许多继承,也就是说一个只能有一个直接父类多个可以继承一个父类在Java中,多层继承是可以的,即一个的父类可以再去继承另外的父类,例如C...
  • 抽象类实现某个接口

    千次阅读 2021-11-26 10:15:36
    /** * created by wlx on 2021/11/26 ...抽象类没有实现接口的方法 public abstract class Test implements Itest{ } 子类需实现接口的全部方法,否则报错 public class Testapp extends Test{ @Overri...
  • Java抽象类和抽象方法归纳总结

    千次阅读 2020-06-11 12:26:24
    这篇文章从不同角度归纳介绍了抽象类的知识点及其注意事项。文中引用的具体例子在这里:抽象类的一个例子 Triangle类是继承自抽象类GeometriObject的具体子类 GeometriObject中包含两个抽象方法:getPerimeter,...
  • java抽象类经典实例分享

    千次阅读 2021-02-12 11:07:34
    在这之前有给大家详细的介绍过java抽象类,相信很多人应该都比较了解了,那么下面就要继续来给大家分享一个java抽象类的实例。题目:不同几何图形的面积计算公式是不一样的,可是,它们具有的特性是一样的,都具有...
  • 什么是抽象类?怎么定义?

    千次阅读 2021-09-01 09:47:26
    什么是抽象类?怎么定义?这是属于java技术里面的一个知识点,本期教程就是围绕这个问题做的相关介绍,当定义一个类时,常常需要定义一些成员方法描述类的行为特征,但有时这些方法的实现方式是无法确定的。例如,在...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,464,720
精华内容 585,888
关键字:

抽象类

友情链接: Ex7_submission.zip