持续创作，加速成长！这是我参与「掘金日新计划 · 6 月更文挑战」的第23天，点击查看活动详情
1.Java内部类细节演示
- Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类
- 内部类的分类：成员内部类（静态、非静态）和 局部内部类(方法内、代码块内、构造器内)
- 成员内部类：
-
一方面，作为外部类的成员：
- 调用外部类的结构
- 可以被static修饰
- 可以被4种不同的权限修饰
-
另一方面，作为一个类：
- 类内可以定义属性、方法、构造器等
- 可以被final修饰，表示此类不能被继承。言外之意，不使用final，就可以被继承
- 可以被abstract修饰
-
/**
* @Author: YuShiwen
* @Date: 2020/11/19 10:21 AM
* @Version: 1.0
*/
public class InnerClass {
public static void main(String[] args) {
//创建静态的成员内部类实例:
Student.Maths maths = new Student.Maths();
maths.appraise();
//创建非静态的成员内部类实例:
//错误示范：
//Student.Physics physics = new Student.Physics();
//需要先创建外部类对象
Student student = new Student();
Student.Physics physics = student.new Physics();
physics.appraise();
physics.namesake(18);
}
}
class Student{
String name = "Mr.Yu";
int age = 21;
public void drink(){
System.out.println("口渴了，喝水！");
}
//静态成员内部类：
static class Maths{
String teacher = "Mr.Wu";
int score;
public void appraise(){
System.out.println("该学生成绩优秀，学习刻苦认真！");
//静态成员中，不能调用非静态属性或方法
//drink();
//System.out.println(name);
}
}
//非静态成员内部类
public final class Physics{
String teacher = "Mr.Li";
int age = 48;
int score;
public void appraise(){
System.out.println("该学生成绩优秀，学习刻苦认真！");
drink();
System.out.println(name);
}
//内部类方法的形参、内部类的属性、外部类的属性同名情况
public void namesake(int age){
//内部类方法的形参
System.out.println(age);
//内部类的属性
System.out.println(this.age);
//外部类的属性
System.out.println(Student.this.age);
}
}
//以下都为局部内部类演示
//方法中声明局部内部类
public void localInnerClassDisplay(){
//局部内部类
class LocalInnerClass{
}
}
//代码块中声明局部内部类
{
//局部内部类
class LocalInnerClass{
}
}
//构造器中声明局部内部类
public Student(){
//局部内部类
class LocalInnerClass{
}
}
}
输出结果：
该学生成绩优秀，学习刻苦认真！
该学生成绩优秀，学习刻苦认真！
口渴了，喝水！
Mr.Yu
18
48
21
Process finished with exit code 0
- 局部内部类作用演示：
interface Person{
void eat();
void drink();
}
public class LocalInnerClass {
//返回一个实现了Person接口的类的对象
//方式一：
public Person getPerson1(){
//1.先创建一个实现了Comparable接口的类:局部内部类
class Student implements Person{
@Override
public void eat() {
System.out.println("吃饭！");
}
@Override
public void drink() {
System.out.println("喝牛奶！");
}
}
//2.返回局部内部类对象
return new Student();
}
//返回一个实现了Person接口的类的对象
//方式二：
public Person getPerson2(){
//直接返回一个匿名局部内部类的匿名对象
return new Person(){
@Override
public void eat() {
System.out.println("吃牛肉！");
}
@Override
public void drink() {
System.out.println("喝饮料！");
}
};
}
}
class MainTest{
public static void main(String[] args) {
LocalInnerClass localInnerClass = new LocalInnerClass();
Person person1 = localInnerClass.getPerson1();
Person person2 = localInnerClass.getPerson2();
person1.eat();
person1.drink();
person2.eat();
person2.drink();
}
}
运行结果：
吃饭！
喝牛奶！
吃牛肉！
喝饮料！
Process finished with exit code 0
2.Java中父类和接口或接口和接口中出现同名属性或同名同参数方法时，如何区分
1.父类和接口中出现同名属性
/**
* @Author: YuShiwen
* @Date: 2020/11/19 12:35 PM
* @Version: 1.0
*/
interface InterfaceA{
int number = 0;
}
class SuperClass{
int number = 1;
}
public class ClassA extends SuperClass implements InterfaceA{
public void printNumber(){
//如果子类没有定义同名的属性，number是不明确的，编译不通过。
//System.out.println(number);
//通过super.调用父类中的属性number
System.out.println(super.number);
//通过接口名.调用接口中的属性number
System.out.println(InterfaceA.number);
}
public static void main(String[] args) {
new ClassA().printNumber();
}
}
输出结果：
1
0
Process finished with exit code 0
2.父类和接口中出现同名方法
我们这里只讨论接口中的静态方法和默认方法，不讨论接口中的抽象方法， 因为接口中的抽象方法实现类(子类)需要重写，所以调用的是子类重写的方法，这里不讨论接口中的抽象方法
/**
* @Author: YuShiwen
* @Date: 2020/11/19 12:49 PM
* @Version: 1.0
*/
interface InterfaceMethod{
//静态方法
public static void hobby(){
System.out.println("我喜欢健身！");
}
//默认方法
public default void drink(){
System.out.println("口渴了，喝饮料！");
}
public default void eat(){
System.out.println("吃汉堡！");
}
}
class ClassMethod{
public void hobby(){
System.out.println("我喜欢跑步！");
}
public void drink(){
System.out.println("口渴了，喝水！");
}
public void eat(){
System.out.println("吃饭！");
}
}
public class ClassB extends ClassMethod implements InterfaceMethod{
public void eat(){
System.out.println("吃牛排！");
}
public void printMethod(){
//不存在指定不明确情况，如果子类没有重写覆盖该方法，直接是父类中的方法；
// 因为接口中定义的静态方法，只能通过接口来调用。
hobby();//也可以写成super.hobby();
//接口中定义的静态方法，只能通过接口来调用。
InterfaceMethod.hobby();
//如果子类(或实现类)继承的父类和实现的接口中声明了同名同参数的默认方法，
//那么子类在没有重写此方法的情况下，默认调用的是父类中的同名同参数的方法。
//类优先原则
drink();
//接口中的方法
InterfaceMethod.super.drink();
//子类有重写此方法的情况
//子类
eat();
//父类
super.eat();
//调用接口中的默认方法
InterfaceMethod.super.eat();
}
public static void main(String[] args) {
new ClassB().printMethod();
}
}
输出结果：
我喜欢跑步！
我喜欢健身！
口渴了，喝水！
口渴了，喝饮料！
吃牛排！
吃饭！
吃汉堡！
Process finished with exit code 0
3.接口和接口中出现同名属性
/**
* @Author: YuShiwen
* @Date: 2020/11/19 1:19 PM
* @Version: 1.0
*/
interface InterfacePropertyA{
public static final int number = 0;
}
interface InterfacePropertyB{
int number = 1;
}
public class ClassC implements InterfacePropertyA,InterfacePropertyB{
public static void main(String[] args) {
ClassC classC = new ClassC();
//如果子类没有定义同名的属性，classC.number指定不明确
//System.out.println(classC.number);
System.out.println(InterfacePropertyA.number);
System.out.println(InterfacePropertyB.number);
}
}
输出结果：
0
1
Process finished with exit code 0
4.接口和接口中出现同名方法
首先接口中定义的静态方法，只能通过接口来调用，出现同名同参数静态方法只需要用接口进行调用即可。 其次接口中的抽象方法，没有方法体，需要实现类重写，调用时肯定是实现类中重写的方法。 如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，那么在实现类没有重写此方法的情况下，报错。接口冲突。这就需要我们必须在实现类中重写此方法。
