来喽！Java抽象类，接口，内部类
Java学习中，整理一些知识点，希望大神多多指教！
一、抽象类概述： 用来描述抽象类
1、被abstract抽象类修饰
2、有抽象方法的类一定是抽象类（有抽象方法的类，必须被定义为抽象类）；但抽象类中不一定有抽象方法
3、可以有构造方法，但无法去创建对象，它的构造方法是供子类初始化父类数据用的
4、抽象类可以被继承
a、子类必须重写抽象类中所有的抽象方法
b、抽象类可以继承抽象类，并且不需要实现父类中的抽象方法
public class AbstractDemo {
public static void main(String[] args) {
Pets pets = new Dog();//Pets 构造方法
pets.method();//Abstract Pets Method()
pets.eat();
}
}
abstract class Cat extends Pets{
}
abstract class Pets{
//抽象方法
public abstract void eat();
public abstract void voice();
//非抽象方法
public void method() {
System.out.println("Abstract Pets Method()");
}
public Pets(){
System.out.println("Pets 构造方法");
}
}
class Dog extends Pets{
@Override
public void eat() {
//alt+insert
System.out.println("eat");
}
@Override
public void voice() {
System.out.println("voice");
}
}
二、接口
概述： 一个类所具有的方法的特征集合，是一种逻辑上的抽象
1、接口需要使用关键字interface
interface 接口名{ }
2、扩充功能
使用关键字implements
class 类名 implements
3、实现接口的标准类
4、接口中只能有抽象的方法，并且每个方法默认都是被public abstract修饰
5、接口不能被实例化，但是可以通过多态的方式实例化
6、一个类可以实现多个接口
public class InterFaceDemo {
public static void main(String[] args) {
//通过多态实例化
ComputerExtend ce = new Computer();
ce.printMethod();//我可以打印了
ce.design();//我可以设计了
ComputerPlay cp = new Computer();
cp.gamePad();//我可以打游戏了
}
}
//接口
interface ComputerPlay{
public abstract void gamePad();//游戏手柄
}
//接口
interface ComputerExtend{
public abstract void printMethod();//打印功能
public abstract void design();//设计功能
}
class Computer implements ComputerExtend,ComputerPlay{
@Override
public void printMethod() {
System.out.println("我可以打印了");
}
@Override
public void design() {
System.out.println("我可以设计了");
}
@Override
public void gamePad() {
System.out.println("我可以打游戏了");
}
}
三、内部类
概述： 把类定义在其他类的内部，这个类被称为内部类
访问特点：
1、内部类可以直接访问外部类里面的方法，包括私有的
2、外部类要访问内部类的成员,需要先创建内部类的对象
public class InnerDemo {
public static void main(String[] args) {
Outer outer = new Outer();
outer.function2();//30 20
}
}
//外部类
class Outer{
private int num2 = 20;
//外部类成员方法
public void function(){
//外部类访问内部类
Inner inner = new Inner();
inner.showInfo();
}
public void function2(){
function();
}
//内部类
class Inner{
//成员变量
int num = 30;
//成员方法
private void showInfo(){
System.out.println(num);
System.out.println(num2);
}
}
}
内部类的分类：
1、成员内部类：声明在成员位置的类
2、局部内部类
创建成员内部类对象：
静态：外部类.内部类 对象名 = new 外部类.内部类（）；
非静态：外部类名.内部类名 对象名 = new 外部类名().new 内部类名();
局部内部类:
1、可以访问外部类的成员，包括私有的
2、访问局部内部类需要在在成员方法作用域内创建对象
public class InnerDemo2 {
public static void main(String[] args) {
Outer2.Inner2 inner2 = new Outer2().new Inner2();
inner2.showInfo();//30
System.out.println(inner2.num2);//20
Outer2 outer2 = new Outer2();
outer2.method();//30
}
}
class Outer2{
//成员变量
public int num = 30;
//成员内部类
class Inner2{
public int num2 = 20;
public void showInfo(){
System.out.println(num);
}
}
//成员方法
public void method(){
//局部变量
int num3 = 40;
//局部内部类
class Inner3{
public void showInfo2(){
System.out.println(num);
}
}
//在成员方法作用域内创建对象
Inner3 inner3 = new Inner3();
inner3.showInfo2();
}
}
注： 因为局部变量类 与 局部变量生命周期冲突的原因，所以需要借助final关键字来解决这个冲突，即局部变量默认被final修饰
匿名内部类：
概述：内部类的简化写法
前提：存在一个类(抽象类) 或 接口
格式：new 类名 或 接口名(){重写方法};
本质：是一个继承子类 或 实现了接口的子类（实现类）匿名对象
public class InnerDemo5 {
public static void main(String[] args) {
Outer6 outer6 = new Outer6();
outer6.method();//1 2
}
}
interface Inter{
public abstract void showInfo();
public abstract void showInfo2();
}
class Outer6{
//匿名内部类
public void method(){
//用多态实现
Inter inter = new Inter() {
@Override
public void showInfo() {
System.out.println("1");
}
@Override
public void showInfo2() {
System.out.println("2");
}
};
inter.showInfo();
inter.showInfo2();
}
}
作者：Java-Java
