Java基础|抽象类/接口/内部类 java-ee|intellij|idea|java

抽象类
- 抽象类和抽象方法的关系
- 抽象类的作用
- 问题
接口
- 接口的定义
- 接口和抽象类的区别
内部类
- 成员内部类
- 局部内部类

抽象类抽象类和抽象方法的关系如果你想设计这样一个类，该类包含一个特别的成员方法，该方法的具体实现由它的子类确定，那么你可以在父类中声明该方法为抽象方法，一个方法体去掉，然后被abstract修饰，那么这个方法就会变成一个抽象方法

文章图片
一个类中如果有方法是抽象方法，那么这个类就也要变成一个抽象类，一个抽象类中可以有0-n个抽象方法。

文章图片

抽象类可以被其他类继承，一个类继承一个抽象类，那么这个类可以变成抽象类。

文章图片

一般子类不会加abstract修饰，一般会让子类重写父类中的抽象方法

文章图片

子类继承抽象类，就必须重写全部的抽象方法，子类如果没有重写父类全部的抽象方法，那么子类也可以变成一个抽象类。

文章图片

注意：抽象类不可以创建对象

文章图片

正确方法：

文章图片

抽象类的作用在抽象类中定义抽象方法，目的是为子类提供一个通用的模板，子类可以在模板的基础上进行开发，先重写父类的抽象方法，然后可以扩展子类自己的内容。抽象类的设计避免了子类设计的随意性，通过抽象类，子类设计变得更加严格，进行某种程度上的限制，使子类更加的通用。
抽象类就相当于我们的ppt模板，我们可以在模板上添加（重写）我们自己的内容，还可以扩展一些额外的东西。

文章图片

问题

抽象类不能创建对象，那么抽象类中是否有构造器？
抽象类中一定有构造器。构造器的作用是给子类初始化对象的时候要先super调用父类的构造器。
抽象类是否可以被final修饰？
不能被final修饰，因为抽象类设计的初衷就是给子类继承用的。而final修饰的类就不能被继承了，就不存在继承，就没有子类。

总结

文章图片

接口接口的定义接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。
接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。
除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。
接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。
【Java基础|抽象类/接口/内部类】接口声明：interface

[访问修饰符] interface 接口名 [extends 父接口1,父接口2,...]{ //常量定义 //方法定义 }

接口和类是同一层次的概念，在接口中的没有构造器
接口中的内容：

常量：固定修饰符：public static final
抽象方法：固定修饰符：public abstract
被public default/static修饰的非抽象方法(JDK1.8之后新增的)，default修饰符必须要加上，否则出错，实现类中要是想重写接口中的非抽象方法，那么default修饰符必须不能加，否则出错。static修饰静态方法不能重写

public interface TestInterface { //常量 public static final int NUM=10; //抽象方法 public abstract void f1(); //public default修饰的非抽象方法 public default void f2(){ System.out.println("这是f2方法！！！"); } //public static修饰的静态非抽象方法 public static void f3(){ System.out.println("这是f3方法！！！"); } }

类和接口的关系：实现关系，类实现接口，一旦实现一个接口，那么实现类就要重写接口中的全部抽象方法，如果没有全部重写抽象方法，那么这个类可以变成一个抽象类。

//实现类就要重写接口中的全部抽象方法 public class TestCode implements TestInterface{ @Override //重写接口中所有抽象方法 } //如果没有全部重写抽象方法，那么这个类可以变成一个抽象类 public abstract class TestCode implements TestInterface{ @Override //重写接口中我们需要的抽象方法 }

java只有单继承，但有多实现：一个类只能继承一个父类，但是可以实现多个接口。

//多实现 public class TestCode implements TestInterface1,TestInterface2...{ @Override //重写抽象方法 } //继承加实现 public class TestCode extends ClassA implements TestInterface1,TestInterface2...{ @Override //重写抽象方法 }

接口实现类创建

public class Test { public static void main(String[] args) { //接口不能实例化对象 TestInterface ti=new TestInterface(); //错误 //接口指向实现类-->多态 TestInterface ti=new TestCode(); //也可以直接创建该类的实例 TestCode tc=new TestCode(); } }

接口和抽象类的区别

文章图片

问题
为什么要在接口中加入非抽象方法？？？
如果接口中只能定义抽象方法的话，那么我要是修改接口中的内容，那么对实现类的影响太大了，所有实现类都会受到影响。现在在接口中加入非抽象方法，对实现类没有影响，想调用就去调用即可。
内部类类的组成：属性，方法，构造器，代码块（普通块，静态块，构造块，同步块），内部类

public class TestOuter{ //属性 int number; //构造器 public TestOuter(){} public TestOuter(int number){ this.number=number; } //方法 public void f(){ System.out.println("这是一个方法！！！"); //普通块 { System.out.println("这是一个普通块！！！"); } } //构造块 { System.out.println("这是构造块！！！"); } //静态块 static{ System.out.println("这是静态块！！！"); } }

内部类：成员内部类和局部内部类
成员内部类成员内部类（静态的和非静态的）

里面有属性，方法，构造器等。
修饰符：private、default、protect、public、final、abstract
内部类可以访问外部类的内容
静态内部类中只能访问外部类被static修饰的属性方法
外部类想要访问内部类的东西，需要创建内部类的对象然后进行调用

public class TestOuter{ int number; //自身的属性、方法 public void fun(){} //非静态成员内部类 public class A{ //属性、方法... String name; public void f(){ fun(); //内部类可以访问外部类的内容 } } //静态成员内部类 static class B{ public void method(){ //静态内部类中只能访问外部类被static修饰的属性方法 } }//外部类想要访问内部类的东西，需要创建内部类的对象然后进行调用 A a=new A(); a.f(); public static void main(String[] args){ //创建外部类对象 TestOuter t=new TestOuter(); //创建非静态的成员内部类 TestOuter t=new TestOuter(); TestOuter.A a=t.new A(); //创建静态成员内部类 TestOuter.B b=new TestOuter.B(); } }

局部内部类

在局部内部类中被访问到的变量必须是被final修饰的
如果类B在整个项目中只使用一次，那么就没有必要单独创建一个B类，使用内部类就可以了
匿名内部类

public class TestOuter{ String number; public void method1(){ //局部内部类 final int num=10; //在局部内部类中被访问到的变量必须是被final修饰的 class A{ public void a(){ System.out.println(num); } } } //如果类B在整个项目中只使用一次，那么就没有必要单独创建一个B类，使用内部类就可以了 public Comparable method2(){ class B implements Comparable{ @Override public int CompareTo(Object o){ return 100; } } return new B(); } //匿名内部类 public Comparable method3(){ //3.匿名内部类 return new Comparable(){ @Override public int compareTo(Object o) { return 200; } }; } //匿名内部类扩展 public void test(){ Comparable com = new Comparable(){ @Override public int compareTo(Object o) { return 200; } }; System.out.println(com.compareTo("abc")); } }