精华内容
下载资源
问答
  • 大家面试的时候肯定被问过java 接口、抽象类具体类、内部、匿名内部的区别及它们之间的关系。那么下面我就来整理下它们之间的关系。

    大家面试的时候肯定被问过java 接口、抽象类、类、内部类、匿名内部类的区别及它们之间的关系。那么下面我就来整理下它们之间的关系。(主要是总结了下网上的资料,不是自己原创的。)总结的不好,请勿喷。^_^

    java 接口:
     使用interface来定义一个接口。接口定义同类的定义类似,也是分为接口的声明和接口体,其中接口体由常量定义和方法定义两部分组成。定义接口的基本格式如下:

    [修饰符] interface 接口名 [extends 父接口名列表]{

    [public] [static] [final] 常量;
    [public] [abstract] 方法;
    }
    修饰符:可选,用于指定接口的访问权限,可选值为public。如果省略则使用默认的访问权限。
    接口名:必选参数,用于指定接口的名称,接口名必须是合法的Java标识符。一般情况下,要求首字母大写。(个人习惯:在接口类名前先写一个I_后面跟着接口名称)
    extends 父接口名列表:可选参数,用于指定要定义的接口继承于哪个父接口。当使用extends关键字时,父接口名为必选参数。
    方法:接口中的方法只有定义而没有被实现。

    接口中可以定义变量和方法,但是一般人不会在接口中定义变量,因为在接口中定义的变量会被隐式的定义为public static final变量(并且只能是public static final变量,用private修饰会报编译错误),而方法会被隐式地指定为public abstract方法且只能是public abstract方法(用其他关键字,比如private、protected、static、 final等修饰会报编译错误)。说java接口中的方法必须是抽象方法。如果接口中存在非抽象方法,编译器会编译不过去,就会报错。并且接口中所有的方法不能有具体的实现。说java接口中的方法必须是抽象方法。如果接口中存在非抽象方法,编译器会编译不过去,就会报错。并且接口允许任何类去实现它,一个类如果实现一个接口,那么这个类就要把这个借口中的所有方法都实现了。

    所以说java接口中的方法都是极度抽象的类型,它比抽象类更加严格的“抽象”。

    其实java中的接口是为了解决java中单继承而来的,大家都知道,java中一个类只能有继承一个父类,不像C++中可以多继承,一个孩子可以有多个爸爸。java严格按照我们生活中的人与人的关系,一个孩子只能有一个爸爸,但是可以有多个干爹(现在的干爹都不靠谱啊,原因你懂的。),一个孩子可以继承父亲的所有遗产,但是也可以拥有多个干爹的遗产,前提是他的干爹愿意把遗产给他。(这里指的是别的接口中的方法)。

    java 抽象类:
    下面是java抽象类的定义语法。
    public abstract class Demo01 {
    
    	public abstract void addUser();//抽象方法
    	
    }
    java抽象类必须要以abstract  来进行修饰,抽象类可以继承抽象类。一个类中存在一个抽象方法,那么这个类必须要定义成抽象类。java中抽象类的访问控制修饰符默认是public类型的,抽象类中的抽象方法(其前有abstract修饰)不能用private、static、synchronized、native访问修饰符修饰。因为,抽象方法没有方法体,是用来被继承的,所以不能用private修饰;static修饰的方法可以通过类名来访问该方法(即该方法的方法体),抽象方法用static修饰没有意义;使用synchronized关键字是为该方法加一个锁。。而如果该关键字修饰的方法是static方法。则使用的锁就是class变量的锁。如果是修饰类方法。则用this变量锁。但是抽象类不能实例化对象,因为该方法不是在该抽象类中实现的。是在其子类实现的。所以,锁应该归其子类所有。所以,抽象方法也就不能用synchronized关键字修饰了;native这个东西本身就和abstract冲突,他们都是方法的声明,只是一个把方法实现移交给子类,另一个是移交给本地操作系统。如果同时出现,就相当于即把实现移交给子类,又把实现移交给本地操作系统,那到底谁来实现具体方法呢?  总之:抽象类是提取具体类的公因式。
    java 内部类:
    java内部类一般使用不是很多,但是其实也很好理解。就是一个类中再次定义了一个类。可以理解为在一个大的厂房里面又盖了个小的厂房。大厂房有它自己的构造组成。小厂房也是有小厂房的构造组成的。内部类破坏了良好的代码结构,但是我们平时还是需要用到的,因为内部类可以随意使用外部类的属性和方法。
    下面是内部类访问外部类的示例及内部类的基本格式:
    package test;
    
    public class test {
    	private String name = "小熊猫";
    	
    	
    	class in {
    		private String name = "丢丢";
    		
    		public void sal(){
    			String name = "小熊猫丢丢";
    			
    			System.out.println("局部变量name:"+name);
    			System.out.println("内部类变量name:"+this.name);
    			System.out.println("外部类变量name:"+test.this.name);
    			
    		}
    		
    	}
    	
    	public static class ma {
    		public static void main(String[] args) {
    			test.in in = new test().new in();
    			in.sal();
    			
    		}
    	}
    
    }

    其实java内部类也是一个类,与其他类不同的是内部类是类中类,它的作用范围只能在这个类中。

    java 匿名内部类:
    匿名内部类的定义语法如下:

    new 父类构造器(参数列表)|实现接口()    
        {    
         //匿名内部类的类体部分    
        } 
    虽然看上去很简单,但是还有一些注意事项需要我们注意的:
    1:使用匿名内部类必须实现一个接口或者继承一个类,但是鱼和熊掌不可兼得,至于是继承类还是实现接口需要根据业务要求去走了。
    2:匿名内部类中不可以定义构造函数。
    3:匿名内部类中不可以有任何静态方法和静态成员变量(这个是因为静态方法或者静态成员变量在加载的时候会直接加载,而普通的成员变量或方法需要在类加载的时候才会去       加载)
    4:匿名内部类也是局部内部类,所以局部内部类的限制对匿名内部类同样有效。
    5:匿名内部类不能是抽象的,它必须要实现继承的类或者实现接口中所有的抽象方法。


    关于java类的一些类就先写到这了,下面会陆续写一些关于多线程与高并发的一些文档,如有一些不对的地方欢迎大家指出,大家共同学习共同进步。

    展开全文
  • Java笔试面试-抽象类与接口

    万次阅读 多人点赞 2019-09-15 22:29:50
      在面向对象的概念中,所有的对象都是通过来描绘的,但是反过来,并不是所有的都是用来描绘对象的,如果一个中没有包含足够的信息来描绘一个具体的对象,这样的就是抽象类。简单来说,使用关键字 ...

    抽象类

    定义:
      在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类。简单来说,使用关键字 abstract 修饰的类就叫做抽象类。
    使用:

    abstract class AbstractAnimal {
        public AbstractAnimal() {
            System.out.println("Init AbstractAnimal.");
        }
        static String name = "AbstractAnimal";
        public abstract void eat();
        public void run() {
            System.out.println("AbstractAnimal Run.");
        }
    }
    class Animal extends AbstractAnimal {
        public static void main(String[] args) {
            AbstractAnimal animal = new Animal();
            animal.run();
            System.out.println(animal.name);
            animal.eat();
        }
      // 必须重写抽象父类方法
        @Override
        public void eat() {
            System.out.println("Animal Eat.");
        }
    }
    

    执行的结果:

    Init AbstractAnimal.
    AbstractAnimal Run.
    AbstractAnimal
    Animal Eat.
    

    抽象方法:
      使用 abstract 关键字修饰的方法叫做抽象方法,抽象方法仅有声明没有方法体。如下代码:

    public abstract void m();
    

    抽象类的特性:

    • 抽象类不能被初始化
    • 抽象类可以有构造方法
    • 抽象类的子类如果为普通类,则必须重写抽象类中的所有抽象方法
    • 抽象类中的方法可以是抽象方法或普通方法
    • 一个类中如果包含了一个抽象方法,这个类必须是抽象类
    • 子类中的抽象方法不能与父类中的抽象方法同名
    • 抽象方法不能为 private、static、final 等关键字修饰
    • 抽象类中可以包含普通成员变量,访问类型可以任意指定,也可以使用静态变量(static)

    接口

    定义:
      接口(interface)是抽象类的延伸,它允许一个类可以实现多个接口,弥补了抽象类不能多继承的缺陷,接口是对类的描述,使用 interface 关键字来声明。
    使用:

    interface IAnimal {
        void run();
    }
    class AnimalImpl implements IAnimal {
        public static void main(String[] args) {
            IAnimal animal = new AnimalImpl();
            animal.run();
        }
        @Override
        public void run() {
            System.out.println("AnimalImpl Run.");
        }
    }
    

    相关面试题

    1.抽象类中能不能包含方法体?
    答:抽象类中可以包含方法体。抽象类的构成也可以完全是包含方法体的普通方法,只不过这样并不是抽象类最优的使用方式。

    题目解析:包含了方法体的抽象类示例代码如下:

    abstract class AbstractAnimal {
        public void run() {
            System.out.println("AbstractAnimal Run.");
        }
    }
    class Animal extends AbstractAnimal {
        public static void main(String[] args) {
            AbstractAnimal animal = new Animal();
            animal.run();
        }
    }
    

    执行结果:
    AbstractAnimal Run.

    2.抽象类能不能被实例化?为什么?
    答:抽象类不能被实例化,因为抽象类和接口的设计就是用来规定子类行为特征的,就是让其他类来继承,是多态思想的一种设计体现,所以强制规定抽象类不能被实例化。

    3.抽象方法可以被 private 修饰吗?为什么?
    答:抽象方法不能使用 private 修饰,因为抽象方法就是要子类继承重写的,如果设置 private 则子类不能重写此抽象方法,这与抽象方法的设计理念相违背,所以不能被 private 修饰。

    4.添加以下哪个选项不会引起编译器报错?

    abstract class AbstractAnimal {
        static String animalName = "AbstractAnimal";
          // 添加代码处
    }
    

    A:protected abstract void eat();
    B: void eat();
    C:abstract void eat(){};
    D:animalName += “Cat”;

    答:A

    题目解析:选项 B 普通方法必须有方法体;选项 C 抽象方法不能有方法体;选项 D 变量赋值操作必须在方法内。

    5.以下关于抽象类和抽象方法说法正确的是?
    A:抽象类中的方法必须全部为抽象方法
    B: 抽象类中必须包含一个抽象方法
    C:抽象类中不能包含普通方法
    D:抽象类中的方法可以全部为普通方法(包含方法体)

    答:D

    题目解析:抽象类中可以没有方法或者全部为普通方法,都是允许的,如下代码所示:

    abstract class AbstractAnimal {
        public void run() {
            System.out.println("AbstractAnimal Run.");
        }
    }
    class Animal extends AbstractAnimal {
        public static void main(String[] args) {
            AbstractAnimal animal = new Animal();
            animal.run();
        }
    }
    
    

    程序执行的结果为:

    AbstractAnimal Run.
    

    6.接口和普通类有什么关系?
    答:在 Java 语言设计中,接口不是类,而是对类的一组需求描述,这些类必须要遵循接口描述的统一格式进行定义。

    7.接口能不能有方法体?
    答:JDK 8 之前接口不能有方法体,JDK 8 之后新增了 static 方法和 default 方法,可以包含方法体。

    8.执行以下代码会输出什么结果?

    interface IAnimal {
        static String animalName = "Animal Name";
    }
    class AnimalImpl implements IAnimal {
        static String animalName = new String("Animal Name");
        public static void main(String[] args) {
            System.out.println(IAnimal.animalName == animalName);
        }
    }
    

    答:执行的结果为 false。

    题目解析:子类使用 new String… 重新创建了变量 animalName,又因为使用 == 进行内存地址比较,所以结果就是 false。

    9.抽象类和接口有什么区别?
    答:抽象类和接口的区别,主要分为以下几个部分。

    • 默认方法
    • 抽象类可以有默认方法的实现
    • JDK 8 之前接口不能有默认方法的实现,JDK 8 之后接口可以有默认方法的实现
    • 继承方式
    • 子类使用 extends 关键字来继承抽象类
    • 子类使用 implements 关键字类实现接口
    • 构造器
    • 抽象类可以有构造器
    • 接口不能有构造器
    • 方法访问修饰符
    • 抽象方法可以用 public / protected / default 等修饰符
    • 接口默认是 public 访问修饰符,并且不能使用其他修饰符
    • 多继承
    • 一个子类只能继承一个抽象类
    • 一个子类可以实现多个接口

    10.以下抽象方法描述正确的是?
    A:抽象方法可以是静态(static)的
    B:抽象方法可同时是本地方法(native)
    C:抽象方法可以被 synchronized 修饰
    D:以上都不是

    答:D

    题目解析:抽象方法需要被子类重写,而静态方法是无法被重写的,因此抽象方法不能被静态(static)修饰;本地方法是由本地代码实现的方法,而抽象方法没有实现,所以抽象方法不能同时是本地方法;synchronized 和方法的实现细节有关,而抽象方法不涉及实现细节,因此抽象方法不能被 synchronized 修饰。

    展开全文
  • Java:接口和抽象类,傻傻不清楚?

    千次阅读 多人点赞 2019-04-26 07:28:15
    再来聊聊接口和抽象类


    再来聊聊接口和抽象类。

    01、抽象类和接口的区别

    来看网络上对接口的一番解释:

    接口(英文:Interface),在 Java 编程语言中是一个抽象类型,是抽象方法的集合。一个类通过继承接口的方式,从而来继承接口的抽象方法。

    兄弟们,你们怎么看,这段解释把我绕得晕乎乎的,好像喝过一斤二锅头。到底是解释抽象类呢还是接口呢?傻傻分不清楚。

    搞不清楚要用抽象类还是接口,就先来看看两者之间的区别。来,抽象类和接口,你俩过来比比身高。

    1. 抽象类中的方法可以有方法体,能实现方法具体要实现的功能,但是接口中的方法不行,没有方法体。
    2. 抽象类中的成员变量可以是各种类型的,而接口中的成员变量只能是 public static final 类型的,并且是隐式的,缺省的。
    3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法),而抽象类是可以有静态代码块和静态方法的。
    4. 一个类只能继承一个抽象类,而一个类却可以实现多个接口。

    02、进一步剖析接口和抽象类

    好像知道了两者之间的区别,但印象还是有些模糊。没关系,我们进一步深入。

    抽象类

    抽象类体现了数据抽象的思想(不然呢),是实现多态的一种机制。抽象类定义了一组抽象的方法,至于这组抽象方法的具体表现形式由子类来继承实现。

    抽象类就是用来继承的,否则它就没有存在的任何意义。举个例子,我们来定义一个抽象的作者类。

    abstract class Author {
    	abstract void write ();
    	
    	public void sleep () {
    		System.out.println("吃饭睡觉打豆豆");
    	}
    }
    

    作为一名作者,本职工作就是搞写作的,其他时间就吃饭睡觉打豆豆;但至于能写出什么样的作品,就要看是哪一个作者了。比如说,沉默王二能写出的作品一定是幽默风趣的。

    public class Wanger extends Author {
    
    	@Override
    	void write() {
    		System.out.println("沉默王二的作品《Web 全栈开发进阶之路》,读起来轻松惬意");
    	}
    	
    }
    

    注意到了没?抽象类是可以有自己的方法的,但继承它的子类可以忽视。

    接口

    接口是一种比抽象类更加抽象的“类”,毕竟是用关键字 interface 声明的,不是用 class

    接口只是一种形式,就好像一纸契约,自身不能做任何事情。但只要某个类实现了这个接口,就必须按照这纸契约来办事:接口里提到的方法必须全部实现,少一个都不行(抽象类的子类可以忽视非抽象方法)。举个例子,我们来定义一个北航出版合同的接口。

    interface ContractBeihang {
    	void scriptBeihang();
    }
    

    一旦作者签订了合同,那么就必须定期完成一定量的书稿。

    public class Wanger extends Author implements ContractBeihang {
    
    	@Override
    	void write() {
    		System.out.println("作品《Web 全栈开发进阶之路》,读起来轻松惬意的技术书");
    	}
    
    	@Override
    	public void scriptBeihang() {
    		System.out.println("一年内完成书稿啊,不然要交违约金的哦。");
    	}
    	
    }
    

    接口是抽象类的补充,Java 为了保证数据的安全性不允许多重继承,也就是说一个类同时只允许继承一个父类(为什么呢?请搜索关键字“菱形问题”)。

    但是接口不同,一个类可以同时实现多个接口,这些接口之间可以没有多大的关系(弥补了抽象类不能多重继承的缺陷)。比如说,沉默王二不仅签了北航出版社的合同,还和 51CTO 签了付费课程的合同。

    public class Wanger extends Author implements ContractBeihang, Contract51 {
    
    	@Override
    	void write() {
    		System.out.println("作品《Web 全栈开发进阶之路》,读起来轻松惬意的技术书");
    	}
    
    	@Override
    	public void scriptBeihang() {
    		System.out.println("一年内完成书稿啊,不然要交违约金的哦。");
    	}
    
    	@Override
    	public void script51() {
    		System.out.println("王老师,先把 Java 云盘的大纲整理出来。");
    	}
    	
    }
    

    03、接口和抽象类之间的差别

    通过上面举的例子,是不是对接口和抽象类有比较清晰的认知了?如果还没有,来来来,我们再来比较一下接口和抽象类之间的差别。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PyHUoyLM-1573712761900)(http://www.itwanger.com/assets/images/2019/11/java-interface-abstract-1.png)]

    究竟什么时候使用接口,什么时候使用抽象类呢?

    1、抽象类表示了一种“is-a”的关系,而接口表示的是“like-a”的关系。也就是说,如果 B 类是 A(沉默王二是一个作者),则 A 应该用抽象类。如果 B 类只是和 A 有某种关系,则 A 应该用接口。

    2、 如果要拥有自己的成员变量和非抽象方法,则用抽象类。接口只能存在静态的不可变的成员变量(不过一般都不在接口中定义成员变量)。

    3、为接口添加任何方法(抽象的),相应的所有实现了这个接口的类,也必须实现新增的方法,否则会出现编译错误。对于抽象类,如果添加了非抽象方法,其子类却可以坐享其成,完全不必担心编译会出问题。

    4、抽象类和接口有很大的相似性,请谨慎判断。Java 从1.8版本开始,尝试向接口中引入了默认方法和静态方法,以此来减少抽象类和接口之间的差异。换句话说,两者之间越来越难区分了。

    04、接口的实际应用

    在实际的开发应用当中,抽象类我用得不多(这可真是大实话);接口我倒是用得蛮多的,就像下面这样子:

    public interface CityMapper {
    
    	@Select("select * from city")
    	List<City> getCitys();
    
    }
    

    @Insert@Update@Delete@Select 被称为 Mybatis 的注射器注解。

    是不是突然感觉有点懵?之前还在谈接口和抽象类,怎么一下子跳跃到 Mybatis 上面了呢?还有什么映射器注解?

    嗯,这就对了。所有的理论知识都要应用于实践,否则也就没有了存在价值。在我的实践应用当中,接口用得最多的就是 MybatisMapper 接口。

    MyBatis 是一款优秀的持久层框架,它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解(就是你在前面见到的增删改查四大注解)来配置和映射原生类型、接口和 Java 的 POJO(Plain Old Java Objects,普通老式 Java 对象)为数据库中的记录。

    当我们配置好了 MyBatis 环境后,可以直接通过以下语句来调用注射器接口。

    @Service
    public class CityService {
    	@Autowired
    	private CityMapper cityMapper;
    
    	public void init() {
    			List<City> citys = cityMapper.getCitys();
    		}
    	}
    }
    

    在注射器接口中,也只会存在那些与数据库查询相关的抽象方法,就像你看到的 List<City> getCitys();。一个注射器接口 + 注射器注解就可以增删改查数据库,是不是感觉很神奇?

    05、总结

    这篇文章的目的是帮助更多的读者了解和掌握抽象类、接口的特点,以及不同的使用场景。

    上一篇:再谈 Java 的继承和超类 Object

    下一篇:Java 生成二维码分享海报

    谢谢大家的阅读,原创不易,喜欢就随手点个赞👍,这将是我最强的写作动力。如果觉得文章对你有点帮助,还挺有趣,就关注一下我的公众号「沉默王二」。

    展开全文
  • 文章目录抽象方法和抽象类抽象方法抽象类抽象类的概念以及使用为什么需要抽象类接口接口的概念接口的使用接口与抽象类的区别使用一个人的例子更直观的了解下接口:内部内部的概念内部的作用内部的分类成员...

    抽象方法和抽象类

    抽象方法

    使用abstract修饰的方法,没有方法体,只有声明。定义的是一种规范,就是告诉子类必须要给抽象方法提供具体的实现(子类也可以部分实现或完全不实现父类的所有抽象方法,但此时子类必须声明为抽象类)。

    抽象类

    抽象类的概念以及使用

    1. 定义了抽象方法的类必须被声明为抽象类,不过抽象类可以没有抽象方法。
    2. 抽象类可以包含属性、方法、构造方法。但是构造方法不能用来new实例,只能用来被子类调用。
    3. 抽象类只能用来被继承,不能使用new关键字创建对象。
    4. 子类必须要给抽象方法提供具体的实现,子类也可以部分实现或完全不实现父类的所有抽象方法,但此时子类必须声明为抽象类。

    为什么需要抽象类

    1. 抽象方法和抽象类看起来像是多余的,对于抽象方法,不知道如何实现,定义一个空的方法体不就好了,抽象类不能创建对象,看起来只是添加一个限制条件。
    2. 在Java中引入抽象方法和抽象类,是一种规范体现,对于某些类和方法的使用,能引导使用者正确的使用它们。
      (1)使用抽象方法而不是使用非空方法体,子类就知道它必须实现该方法,而不能忽略,忽略的话编译器就会报错。
      (2)使用抽象类,类的使用者创建对象的时候,就知道要使用某个具体子类,而不可能使用不完整的抽象类。

    用一个植物的例子更直观的明白抽象类以及抽象方法的使用:

    public class AbstractTest {
        public static void main(String[] args) {
            Flower flower=new Flower();
            flower.plant();
            flower.growsIn();
            Aqua_plant aqua_plant=new Aqua_plant();
            aqua_plant.plant();
            aqua_plant.growsIn();
        }
    }
    
    abstract class Plant{
        //普通方法
        public void plant(){
            System.out.println("都是植物");
        }
        //抽象方法
        public abstract void growsIn();
    }
    
    class Flower extends Plant{
        @Override
        public void growsIn() {
            System.out.println("花生在土里。");
        }
    }
    
    class Aqua_plant extends Plant{
        @Override
        public void growsIn() {
            System.out.println("水草生在水里。");
        }
    }
    

    接口

    接口的概念

    接口就是比“抽象类”还“抽象”的“抽象类”,可以更加规范的对子类进行约束。全面地专业地实现了:规范和具体实现的分离。

    接口的使用

    声明格式:

    [访问修饰符]  interface 接口名   [extends  父接口1,父接口2]  {
    	常量定义;
    	方法定义;
        (静态方法定义;)
    }
    
    1. 访问修饰符:只能是public或默认。
    2. 接口名:和类名采用相同命名机制。
    3. extends:接口可以多继承。
    4. 常量:接口中的属性只能是常量,总是:public static final 修饰。不写也是。
    5. 方法:接口中的方法只能是:public abstract。 省略的话,也是public abstract。
    6. JDK1.8之后,接口可以包含普通的静态方法

    子类使用方法:

    1. 子类通过implements来实现接口中的规范,一个类可以实现多个接口。
    2. 接口不能创建实例,但是可用于声明引用变量类型。
    3. 一个类实现了接口,必须实现接口中所有的方法,并且这些方法只能是public的。
    4. JDK1.7之前,接口中只能包含静态常量、抽象方法,不能有普通属性、构造方法、普通方法,JDK1.8后,接口可以包含普通的静态方法。

    接口与抽象类的区别

    接口和抽象类中都包含了抽象类,但是接口和抽象类有以下几种区别:

    1. 接口是多继承的,而类是单继承。
    2. 一个类可以实现任意多个接口,但最多只能作为一个抽象类的子类。
    3. 一个抽象类可以有若干个抽象方法(但到少要有一个),而接口的所有方法都是抽象的,无论是否将它的方法显示地声明为抽象的。
    4. 一个抽象类可以声明实例变量,其子类可以继承这些实例变量。而一个接口不能声明实例变量,不过接口可以声明static final修饰域。
    5. 抽象类可以有构造方法,而接口不能,但是两者都不能直接实例化,都必须通过其他类的实现才能使用。
    6. 抽象类的可见性修饰符可以是public、protected、private或无修饰符(表示包内可见);而接口的可见性修饰符只能是 public,或无修饰符(包内可见)。
    7. 抽象类的方法的可见性修饰符可是以protected、private,或无(表示包内可见);而一个接口的方法的可见性修饰符只能是 public (JDK1.8之后,接口可以包含普通的静态方法)
    8. 抽象类是从object类派生而来,它继承了object的clone()和equals()方法。
    9. 设计模式讲,继承强调是:is-a;而接口强调的则是has-a。

    使用一个人的例子更直观的了解下接口:

    public class InterfaceTest {
        public static void main(String[] args) {
            People.say();  //调用接口中的静态方法需要通过接口来调用
            Teacher teacher=new Teacher();
            teacher.profession();
            teacher.work();
            Student student=new Student();
            student.profession();
            student.work();
        }
    }
    interface A{
    }
    interface B{
    }
    interface People extends A,B/*接口的多继承*/{
        //定义静态常量
        public static final int a=10;
        /*public static final */boolean flag=true;  //默认也是public static final修饰
        //定义抽象方法
        /*public abstract */void profession();  //默认也是public abstract修饰
        public abstract void work();
        //JDK1.8之后,接口可以包含普通的静态方法
        public static void say(){
            System.out.println("Hello!");
        }
    }
    //子类必须实现接口中所有的抽象方法(静态方法就不需要实现)
    class Teacher implements People,A,B/*子类可以实现多个接口*/ {
        @Override
        public void profession() {
            System.out.print("教师");
        }
        @Override
        public void work() {
            System.out.println("教学");
        }
    }
    class Student implements People{
        @Override
        public void profession() {
            System.out.print("学生");
        }
        @Override
        public void work() {
            System.out.println("学习");
        }
    }
    

    内部类

    内部类的概念

    内部类我们从外面看是非常容易理解的,无非就是在一个类的内部在定义一个类。一般情况,我们把类定义成独立的单元,有些情况下,我们把一个类放在另一个类的内部定义,称为内部类。内部类可以使用public、default、protected 、private以及static修饰,而外部类(我们以前接触的类)只能使用public和default修饰。

    注意事项: 内部类只是一个编译时概念,一旦我们编译成功,就会成为完全不同的两个类。对于一个名为Outer的外部类和其内部定义的名为Inner的内部类。编译完成后会出现Outer.class和Outer$Inner.class两个类的字节码文件。所以内部类是相对独立的一种存在,其成员变量/方法名可以和外部类的相同。

    内部类的作用

    1. 内部类提供了更好的封装。只能让外部类直接访问,不允许同一个包中的其他类直接访问。

    2. 内部类可以直接访问外部类的私有属性,内部类被当成其外部类的成员。 但外部类不能访问内部类的内部属性。

    3. 接口只是解决了多重继承的部分问题,而内部类使得多重继承的解决方案变得更加完整。

    4. 由于内部类提供了更好的封装特性,并且可以很方便的访问外部类的属性。所以,在只为外部类提供服务的情况下可以优先考虑使用内部类。

    5. 使用内部类间接实现多继承:每个内部类都能独立地继承一个类或者实现某些接口,所以无论外部类是否已经继承了某个类或者实现了某些接口,对于内部类没有任何影响。

    内部类的分类

    在Java中内部类主要分为成员内部类(非静态内部类、静态内部类)、匿名内部类、局部内部类。

    成员内部类

    非静态内部类
    1. 外部类里使用非静态内部类和平时使用其他类没什么不同。
    2. 非静态内部类必须寄存在一个外部类对象里。因此,如果有一个非静态内部类对象那么一定存在对应的外部类对象。非静态内部类对象单独属于外部类的某个对象。
    3. 非静态内部类可以直接访问外部类的成员,但是外部类不能直接访问非静态内部类成员。
    4. 非静态内部类不能有静态方法、静态属性和静态初始化块。
    5. 外部类的静态方法、静态代码块不能访问非静态内部类,包括不能使用非静态内部类定义变量、创建实例。
    6. 非静态内部类成员变量的访问方法:A.内部类里方法的局部变量:变量名。B.内部类属性:this.变量名。C.外部类属性:外部类名.this.变量名。
    7. 内部类的访问方法:A.外部类中定义内部类:new 内部类名();B.外部类以外的地方使用非静态内部类:外部类名.内部类名 变量名= new 外部类名().new 内部类名()。
    静态内部类
    1. 当一个静态内部类对象存在,并不一定存在对应的外部类对象。 因此,静态内部类的实例方法不能直接访问外部类的实例方法。
    2. 静态内部类看做外部类的一个静态成员。 因此,外部类的方法中可以通过:静态内部类.名字的方式访问静态内部类的静态成员,通过new 静态内部类()访问静态内部类的实例。在外部类以外的地方使用可以通过外部类名.内部类名 变量名 =new 外部类名.内部类名();来访问。

    匿名内部类

    匿名内部类适用于仅需要使用一次的类。

    • 静态内部类的语法:
    new 父类构造器(实参类表)或实现接口() {
    	//匿名内部类类体
    }
    
    • 注意事项:
    1. 匿名内部类没有访问修饰符。
    2. 匿名内部类没有构造方法。因为它连名字都没有那又何来构造方法呢。

    局部内部类

    局部内部类是定义在方法内部的,作用域只限于本方法。局部内部类的用法和成员内部类的用法一样,但是它只能在定义的方法体中使用,离开了方法体就失效。

    展开全文
  • 抽象类与一般的区别

    千次阅读 2017-07-25 16:12:48
    首先了解一下百度百科对抽象类的定义:抽象类往往用来表征对问题领域进行分析、设计中得出的抽象概念,是对一系列看上去不同,但是本质上相同的具体概念的抽象。 用通俗的语言来说就是,抽象类是不完整的,它是一部...
  • 抽象类具体类是相对的概念。“抽象”是一种存在思想逻辑中的概念,而“具体”是一种可见可触摸的现实对象。简单说,比如“人”比“男人”抽象一点,“动物”又比“人”更抽象一点,而“生物”又比“动物”更抽象。...
  • Java 剖析抽象类

    千次阅读 2018-07-25 19:57:54
    抽象类只是在普通的基础上扩充了一些抽象方法... 由于抽象方法没有具体的方法实现,所以其抽象类是不能直接实例化的,使用抽象类的唯一途径是使用它的实现子类。  抽象类使用原则: 所有抽象类必须有其实现...
  • 在java中有个比较6的,为什么说它很6呢?继承该必须实现该中所有的方法,这个抽象类。 定义抽象类: 访问控制符 abstract 类名{ 访问控制符 [abstract] 返回值...抽象类可以没有抽象方法。抽象方法只有声
  • 一、抽象类 定义:在普通的基础上扩充了一些抽象方法 。 1. 抽象方法:只声明而未实现...抽象类中没有具体实现,因此抽象类不能直接实例化对象 abstract class Person{ private String name;//姓名属性 ...
  • 什么是抽象类?什么是抽象方法?

    千次阅读 2019-03-06 21:09:42
    抽象类抽象类就是不能使用new方法进行实例化的,即没有具体实例对象的抽象类有点类似于“模板”的作用,目的是根据其格式来创建和修改新的,对象不能由抽象类直接创建,只可以通过抽象类派生出新的子类,再...
  • 总结了一下java中抽象方法、抽象类和接口,防止大家傻傻不清楚~概念性的东西都有点绕,请读者一定看清每个字词,认真体会。 抽象方法和抽象类 抽象方法仅有声明而没有函数体,必须使用abstract关键词限定。...
  • 抽象类

    2007-08-05 23:19:00
    并不是所有的都是用来描绘对象的,如果一个中没有包含足够的信息来描绘一个具体的对象,这样的就是抽象类抽象类往往用来表征我们在对问题领域进行分析、设计中得出的抽象概念,是对一系列看上去不同,但是...
  • 抽象类与接口

    热门讨论 2014-04-28 21:24:07
    一、抽象类 在面向对象的概念中,所有的对象都是...举个例子,“水果”是个抽象类,指可以食用的植物果实和种子,有水分和糖,但世界上不存在“水果”这个实实在在的东西,它只是一个定义。“苹果”、“香蕉”、
  • 一、抽象类抽象方法的定义 抽象类:只在普通的基础上扩充了一些抽象...抽象类中包含抽象方法,抽象方法不包含方法体,即抽象类中没有具体实现,所以抽象类中不能直接产生实例化对象 举例:创建一个简单的抽象...
  • 抽象类 接口 匿名的区别

    千次阅读 2015-07-29 15:28:11
    1 抽象类  当编写一个时,常常会为该定义一些方法,这些方法用以描述该的行为方式,那么这些方法都有具体的方法体。但在某些情况下,某个父类并不需要实现,因为它只需要当做一个模板,而具体的实现,...
  • 抽象类顾名思义就是一个抽象,那么我们从本质上来看就可以得出:抽象类本质上其实还是一个.只不过他和我们一般的有所区别.既然抽象类还是一个那么就好办了,我们就只需要了解什么是抽象的概念就行了. 抽象的...
  • 接口与抽象类

    千次阅读 2014-10-09 22:40:35
    抽象类描述了一系列"东西"的本质。 接口描述一系列"东西"应该具有的功能,或者说接口就是一组契约。
  • java的抽象类抽象方法(注意查看如何调用抽象类中的非抽象方法)  2013-09-02 00:09:53| 分类: 默认分类 |举报 ...对象不能由抽象类直接创建,只可以通过抽象类派生出新的子类,再由其子类来创建
  • java抽象类和接口有什么意义

    千次阅读 2021-02-04 16:53:06
    为什么接口和抽象类不能实例化,为什么接口可以多个实现而抽象类只能单继承,特别是java8之后,抽象类和接口里面都可以写代码后,就更加不清了,今天重新整理一下。 什么是抽象类(abstract class) 使用abstract...
  • 抽象类和接口区别

    千次阅读 热门讨论 2014-12-14 11:27:22
    1·属性定义: ... 抽象类必须有抽象方法,也可有非抽象方法,在费抽象方法中可有具体实现代码。但是接口中只是空的方法体,没有具体实现。 public abstract class Animal { protected string a;//普通
  • 抽象类中可能包含抽象成员(方法,属性)这些都是共性的【可以为空,可以没有抽象成员,可以抽象成员】 抽象类不能创建对象【不能实例化,不能New】可以被继承!可以创建数组 定义: 调用: 1.2、语义(了解...
  • 抽象类+接口+内部作业题

    千次阅读 2018-06-28 17:21:28
    抽象类+接口+内部作业题一、 选择题1.Person和Test的代码如下所示,则代码中的错误语句是( c )。(选择一项) public class Person {public String name;public Person(String name) {this.name = ...
  • 抽象类可以抽象方法,也可以没有抽象方法,但是有抽象方法存在的必须是抽象类。 如果一个普通作为父类,那么他的子类会重写父类中的方法;但是如果一个抽象类中的抽象方法被子实现,那么该子类是实现父类...
  • Java 抽象类 接口 继承 实现

    千次阅读 2016-07-23 17:21:14
    接口和抽象类的概念不一样。...人可以吃东西,狗也可以吃东西,你可以把“吃东西”定义成一个接口,然后让这些去实现它(实现多个接口,实现多个动作). 所以,在高级语言上,一个只能继承一个抽象类,jav
  • 抽象类和接口

    千次阅读 2019-12-07 09:56:05
    Object、多态 回顾 1 方法传参 返回值 方法传参采用传值 : 基本类型传递的数据本身,引用类型传递的是地址 返回值:基本类型返回数据本身,引用类型返回地址。 2 封装 :隐藏的实现细节,保证程序安全。 2...
  • 设计模式三:抽象类

    2019-04-19 10:56:44
    在java语言里, 类分为两种:一种是抽象类,一种是具体类具体类可以实例化,抽象类可以实例化。 一个抽象类仅提供一个类型的部分实现。 一个抽象类不能被实例化,那么一个抽象类被设计出来,一定是被用来...
  • php抽象类和接口的区别

    万次阅读 2018-04-04 12:49:04
    php抽象类和接口的区别 tags:抽象类 接口 抽象类和接口 php 引言:这是一个面试经常被问到的问题,也是一个...任何一个,如果它里面至少有一个方法是被声明为抽象的,那么这个就必须被声明为抽象的。(...
  • Java中为什么要使用抽象类

    千次阅读 2016-07-14 16:33:59
    抽象类 抽象类与接口紧密...2)抽象类当中可以存在非抽象的方法,可接口不能且它里面的方法只是一个声明必须用public来修饰没有具体实现的方法。3)抽象类中的成员变量可以被不同的修饰符来修饰,可接口中的成员变量
  • Java笔记抽象类和接口

    2018-05-02 17:19:17
    主要针对Java当中易混淆的抽象类和接口做详细描述,同时清楚Java书写的行文规范,从而对抽象类和接口有更加具体的了解

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 381,507
精华内容 152,602
关键字:

抽象具体可以分为哪些类