abstractabstract介绍:可以用于修饰：类（抽象类）、方法（抽象方法）
abstract修饰类：
①此类不能实例化（也就是不能创建这个类的对象)
②虽然自己不能实例化，但是子类会调用父类的构造器，所以抽象类中一定有构造器
abstract修饰方法①抽象方法只有方法的声明没有方法体，所在的类一定是抽象类。因为如果类不是抽象的，那这个类就可以造对象，可以造对象就可以调用。反之抽象类中可以没有抽象方法。
② 若子类重写了子类重写了父类所有的抽象方法才能实例化，如果没有全部重写，那么子类也是抽象类，也需要用abstract修饰。
③abstract不能用来修饰私有方法、静态方法、final关键字修饰的方法、final关键字修饰的类。
final明确不能继承，但abstract需要子类继承所以不能用,因为如果两个方法都是static，不认为两个方法是重写或者覆盖，所以abstract用来修饰静态方法，就无法重写。
抽象的应用
模板方法设计模式。在软件开发中实现一个算法时，整体步骤很固定、通用，这些步骤在父类中写好，某些易变的和不确定的部分可以抽象出来给子类实现。
抽象类的匿名子类对象public static void main(string[] args){ //匿名对象 eat(new son()); //非匿名类的非匿名对象 son john=new son(); eat(john); //匿名子类对象 father f=new father(){//抽象类造对象必须要重写方法，了解看得懂就ok了。 @override public void work() { } @override public void info(father i) { } };}//普通方法public static void eat(father f){ system.out.println("吃饭");}//父类public abstract static class father{ string name; int age; public abstract void work();//抽象方法不能有方法体 public abstract void info(father i);}//子类public class son extends father{//继承 string name; int age; @override public void work(){ system.out.println("上学"); } @override public void info(father i) { system.out.println("name:"+i.name+" age:"+i.age); }}//接口的匿名对象非匿名的对象可以被多次调用，匿名的对象只能使用一次computer com=new computer();//创建了接口的非匿名实现类（子类）的非匿名对象，类和对象都是有名的flash flash = new flash();//2.创建了接口的非匿名实现类的匿名对象，对象匿名了com.transferdata(new printer());//3创建了接口的匿名实现类的非匿名对象,就是类是匿名的，就不知道是接口中的哪个实现类，所以 需要重写方法进行说明usb phone = new usb{ public void start(){ ... }};//4.创建了接口的匿名实现类的匿名对象com.transferdata(new usb(){ public void start(){ ... } });
final关键字final修饰类：此类不能被其他类所继承，比如：string、system、stringbuffer
final修饰方法：此方法不能再被重写，比如：object类中的getclass()
static final用来修饰属性：全局常量
final修饰变量：此时的变量就称为是一个常量
final修饰属性：可以考虑赋值的位置：显式初始化，代码块中初始化、构造器中初始化
final修饰局部变量：尤其是用final修饰形参时，表明此形参是一个常量，当调用此方法时，给常量形参赋实参，一旦赋值就只能在方法体内使用此形参，但不能重新赋值
接口接口使用interface来定义，和类是并列关系
接口的定义以及接口中的成员：
接口相关规则1.接口中所有方法都是抽象的。
2.即使没有显式的将接口中的成员用public标示，也是public访问类型的
3.接口中变量默认用 public static final标示，所以接口中定义的变量就是全 局静态常量。
4.可以定义一个新接口，用extends去继承一个已有的接口
5.可以定义一个类，用implements去实现一个接口中所有方法。
6.可以定义一个抽象类，用implements去实现一个接口中部分方法。
接口的特性1.接口不可以被实例化
2.实现类必须实现接口的所有方法
3.实现类可以实现多个接口
4.接口中的变量都是静态常量
如果类覆盖了接口中所有的抽象方法，则可以创造实例；如果类没有覆盖接口中所有的抽象方法，则该类仍为抽象类。java类可以实现多个接口——弥补了单继承性的缺陷
class aa extends bb implements cc,dd,ee
接口和接口之间可以继承，且可以多继承。接口的使用体现了多态性。接口是一种规范，面向接口编程。
抽象类和接口的异同相同点：不能实例化，都可以包含抽象方法
不同点：
1. 把抽象类和接口（java7、java8)的定义、内部结构解释说明
2. 类：单继承性，接口：多继承性。
抽象类与接口的练习
abstract class door { //开门 public abstract void opendoor(); //关门 public abstract void closedoor();} interface lock { public static final int num = 200; //开锁 public abstract void openlock(); //上锁 public abstract void closelock();}class lockdoor extends door implements lock { public void opendoor() { system.out.println("开门"); } public void closedoor() { system.out.println("关门"); } public void openlock() { system.out.println("开锁"); } public void closelock() { system.out.println("上锁"); } }public class testlockdoor { public static void main(string[] args) { lockdoor lockdoor = new lockdoor(); lockdoor.openlock(); lockdoor.opendoor(); lockdoor.closedoor(); lockdoor.closelock(); }}
接口的应用
两种设计模式
- 代理模式
代理设计就是为其他对象提供一张代理以控制对这个对象的访问
应用场景：安全代理、远程代理、延迟加载
分类：静态代理、动态代理
- 工厂模式
实现创建者和调用者的分离
interface a{ int x=0;}class b{ int x=1;}class c extends b implements a{ public void px(){ system.out.println(x); } public static void main(string[] args){ new c().px(); }}//问题：编译期不知道是要输出哪个xsystem.out.println(super.x);//这个调用的是父类中的system.out.println(a.x);//这个调用的是接口中的
java8中接口新特性
jdk8：除了全局常量和抽象方法，还可以定义静态方法和默认方法（default关键字修饰）
public interface comparea{ public static void method1(){ //静态方法 system.out.println("comparea:北京"); } public default void method2(){ //默认方法 system.out.println("comparea:上海"); } }
接口中定义的静态方法只能通过接口来调用，接口.方法。
通过实现类的对象，可以调用接口中的默认方法，对象.方法。
如果实现类重写了接口中的默认方法，调用时仍然调用的是重写以后的方法
如果子类（或实现类）继承的父类和实现的接口中声明了同名同参数的方法，子类在没有重写此方法的情况下调用的是父类中的方法——类优先原则
如果实现类实现了多个接口，而这个多个接口中定义了同名同参数的默认方法，在实现类没有重写方法的情况下会报”接口冲突“错误，此时需要重写。
如何在子类（或者实现类）调用父类、接口中被重写的方法？ 接口.super.方法。
内部类需要关注的问题：如何实例化成员内部类的对象：外部类person，静态内部类brain，非静态内部类lungs，静态成员内部类：new 外部类.内部类()
person.brain brain=new person.brain();
非静态成员内部类：先造对象，对象.new 内部类()
person p=new person();p.lungs lungs=p.new lungs();
如何在成员内部类中区分调用外部类的结构
形参直接调，所在类的用this.结构，外部类的用外部类.this.结构
成员内部类和局部内部类在编译以后都会生成字节码文件
成员内部类：外部类.内部类名.class
局部内部类：外部类.数字 内部类名.class
在局部内部类的方法中，如果调用局部内部类所在的方法中的局部变量，该局部变量必须用final关键字修饰(java8之后可以不写出来，但仍然还是final的)
public void person(){ int num=10; class aa{//局部内部类 public void show(){//局部内部类的方法 num=20;//试图修改会报错 system.out.println(num);//调用局部内部类所在的方法中的局部变量 } }}
开发中局部内部类的使用
常用的局部内部类：
//方式一public comparable getcompareble(){ class mycomparable implements comparable{//局部内部类 public int compareto(object o){ return 0; } } return new mycomparable();}//方式二public comparable getcompareble(){ return new comparable(){ public int compareto(object o){ return 0; } };}
java允许将一个类a声明在另一个类b中，a为内部类，b为外部类
内部类的分类：成员内部类、局部内部类（方法内，代码块内，构造器内）
成员内部类
作为外部类的成员：可以调用外部类的结构，可以被static修饰
作为一个类：可以定义属性、方法、构造器，可以用final、abstract修饰，可以被继承
this.name//内部类的属性
person.this.name//外部类的属性
以上就是如何掌握java抽象类与接口？的详细内容。