(一)内部类

内部类的基本概念

• 当一个类的定义出现在另外一个类的类体中时，那么这个类叫做内部类（Inner），而这个内部类所在的类叫做外部类（Outer）。
• 类中的内容：成员变量、成员方法、构造方法、静态成员、构造块和静态代码块、内部类

实际作用

• 当一个类存在的价值仅仅是为某一个类单独服务时，那么就可以将这个类定义为所服务类中的内部类，这样可以隐藏该类的实现细节并且可以方便的访问外部类的私有成员而不再需要提供公有的get和set方法

内部类的分类

• 普通内部类 - 直接将一个类的定义放在另外一个类的类体中。

• 静态内部类 - 使用static关键字修饰的内部类，隶属于类层级。

• 局部内部类 - 直接将一个类的定义放在方法体的内部时。

• 匿名内部类 - 就是指没有名字的内部类

(1)普通（成员）内部类的格式

访问修饰符 class 外部类的类名 {

​ 访问修饰符 class 内部类的类名 {

​ 内部类的类体;

​ }

}

普通内部类的使用方式

• 普通内部类和普通类一样可以定义成员变量、成员方法以及构造方法等。
• 普通内部类和普通类一样可以使用final或者abstract关键字修饰。
• 普通内部类还可以使用private或protected关键字进行修饰。
• 普通内部类需要使用外部类对象来创建对象。
• 如果内部类访问外部类中与本类内部同名的成员变量或方法时，需要使用this关键字

/*** 编程实现普通内部类的定义和使用       -  文档注释*/
public class NormalOuter {private int cnt = 1;// 定义普通内部类，隶属于外部类的成员，并且是对象层级/*private*/public /*final*/ class NormalInner {private int ia = 2;private int cnt = 3;public NormalInner() {System.out.println("普通内部类的构造方法体执行到了！");}public void show() {System.out.println("变量cnt的数值为：" + cnt); // 3  就近原则System.out.println("ia = " + ia); // 2}public void show2(int cnt) {System.out.println("形参变量cnt = " + cnt);  // 局部优先原则  4System.out.println("内部类中cnt = " + this.cnt); // 3System.out.println("外部类中cnt = " + NormalOuter.this.cnt); // 1}}
}

public class NormalOuterTest {public static void main(String[] args) {// 1.声明NormalOuter类型的引用指向该类型的对象NormalOuter no = new NormalOuter();// 2.声明NormalOuter类中内部类的引用指向内部类的对象NormalOuter.NormalInner ni = no.new NormalInner();// 调用内部类中的show方法ni.show();System.out.println("---------------------------------------------");ni.show2(4);}
}

普通内部类的构造方法体执行到了！
外部类中变量cnt的数值为：3

ia = 2

形参变量cnt = 4
内部类中cnt = 3
外部类中cnt = 1

(2)静态内部类的格式

访问修饰符 class 外部类的类名 {

​ 访问修饰符 static class 内部类的类名 {

​ 内部类的类体;

​ }

}

静态内部类的使用方式

• 静态内部类不能直接访问外部类的非静态成员。
• 静态内部类可以直接创建对象。
• 如果静态内部类访问外部类中与本类内同名的成员变量或方法时，需要使用类名.的方式访问

/*** 实现静态内部类的定义和使用*/
public class StaticOuter {private int cnt = 1;        // 隶属于对象层级private static int snt = 2; // 隶属于类层级public /*static*/ void show() {System.out.println("外部类的show方法就是这里！");}/*** 定义静态内部类   有static关键字修饰隶属于类层级*/public static class StaticInner {private int ia = 3;private static int snt = 4;public StaticInner() {System.out.println("静态内部类的构造方法哦！");}public void show() {System.out.println("ia = " + ia); // 3System.out.println("外部类中的snt = " + snt); // 2//System.out.println("外部类的cnt = " + cnt); // Error:静态上下文中不能访问非静态的成员，因此此时可能还没有创建对象}public void show2(int snt) {  // 就近原则System.out.println("snt = " + snt); // 5System.out.println("内部类中的成员snt = " + StaticInner.snt); // 4System.out.println("外部类中的成员snt = " + StaticOuter.snt); // 2//StaticOuter.show();new StaticOuter().show();}}
}

public class StaticOuterTest {public static void main(String[] args) {// 1.声明StaticInner类型的引用指向该类型的对象StaticOuter.StaticInner si = new StaticOuter.StaticInner();// 2.调用show方法进行测试si.show();System.out.println("---------------------------------------------");si.show2(5);}
}

静态内部类的构造方法哦！
ia = 3

外部类中的snt = 4

snt = 5
内部类中的成员snt = 4
外部类中的成员snt = 2
外部类的show方法就是这里！

(3)局部（方法）内部类的格式

访问修饰符 class 外部类的类名 {

​ 访问修饰符 返回值类型 成员方法名（形参列表） {

​ class 内部类的类名 {

​ 内部类的类体;

​ }

​ }

}

局部内部类的使用方式

• 局部内部类只能在该方法的内部可以使用。
• 局部内部类可以在方法体内部直接创建对象。
• 局部内部类不能使用访问控制符和static关键字修饰符。
• 局部内部类可以使用外部方法的局部变量，但是必须是final的。由局部内部类和局部变量的声明周期不同所致。

/*** 编程实现局部内部类的定义和使用*/
public class AreaOuter {private int cnt = 1;public void show() {// 定义一个局部变量进行测试，从Java8开始默认理解为final关键字修饰的变量// 虽然可以省略final关键字，但建议还是加上final int ic = 4;// 定义局部内部类，只在当前方法体的内部好使    拷贝一份class AreaInner {private int ia = 2;public AreaInner() {System.out.println("局部内部类的构造方法！");}public void test() {int ib = 3;System.out.println("ia = " + ia); // 2System.out.println("cnt = " + cnt); // 1//ic = 5;  ErrorSystem.out.println("ic = " + ic); // 4}}// 声明局部内部类的引用指向局部内部类的对象AreaInner ai = new AreaInner();ai.test();}}

public class AreaOuterTest {public static void main(String[] args) {// 1.声明外部类类型的引用指向外部类的对象AreaOuter ao = new AreaOuter();// 2.通过show方法的调用实现局部内容类的定义和使用ao.show();}
}

局部内部类的构造方法！
ia = 2
cnt = 1
ic = 4

(4)匿名内部类的语法格式

接口/父类类型 引用变量名 = new 接口/父类类型() { 方法的重写 } 参考回调模式

(二)回调模式的概念

• 回调模式是指——>如果一个方法的参数是接口类型，则在调用该方法时，需要创建并传递一个实现此接口类型的对象；而该方法在运行时会调用到参数对象中所实现的方法（接口中定义的）。

public interface AnonymousInterface {// 自定义抽象方法public abstract void show();
}

public class AnonymousInterfaceImpl implements AnonymousInterface {@Overridepublic void show() {System.out.println("这里是接口的实现类！");}
}

public class AnonymousInterfaceTest {// 假设已有下面的方法，请问如何调用下面的方法？// AnonymousInterface ai = new AnonymousInterfaceImpl();// 接口类型的引用指向实现类型的对象，形成了多态public static void test(AnonymousInterface ai) {// 编译阶段调用父类版本，运行调用实现类重写的版本ai.show();}public static void main(String[] args) {//AnonymousInterfaceTest.test(new AnonymousInterface()); // Error:接口不能实例化AnonymousInterfaceTest.test(new AnonymousInterfaceImpl());System.out.println("---------------------------------------------------------------");// 使用匿名内部类的语法格式来得到接口类型的引用，格式为：接口/父类类型 引用变量名 = new 接口/父类类型() { 方法的重写 };AnonymousInterface ait = new AnonymousInterface() {@Overridepublic void show() {System.out.println("匿名内部类就是这么玩的，虽然你很抽象！");}};// 从Java8开始提出新特性lamda表达式可以简化上述代码，格式为：(参数列表) -> {方法体}AnonymousInterface ait2 = () -> System.out.println("lamda表达式原来是如此简单！");AnonymousInterfaceTest.test(ait2);}
}

这里是接口的实现类！

lamda表达式原来是如此简单！

(三)开发经验分享

• 当接口/类类型的引用作为方法的形参时，实参的传递方式有两种：
  • 自定义类实现接口/继承类并重写方法，然后创建该类对象作为实参传递；
  • 使用上述匿名内部类的语法格式得到接口/类类型的引用即可；

(四)枚举

枚举的基本概念

• 一年中的所有季节：春季、夏季、秋季、冬季。
• 所有的性别：男、女。
• 键盘上的所有方向按键：向上、向下、向左、向右。
• 在日常生活中这些事物的取值只有明确的几个固定值，此时描述这些事物的所有值都可以一一列举出来，而这个列举出来的类型就叫做枚举类型。

枚举的定义

• 使用public static final表示的常量描述较为繁琐，使用enum关键字来定义枚举类型取代常量，枚举类型是从Java5开始增加的一种引用数据类型。
• 枚举值就是当前类的类型，也就是指向本类的对象，默认使用public static final关键字共同修饰，因此采用枚举类型.的方式调用。
• 枚举类可以自定义构造方法，但是构造方法的修饰符必须是private，默认也是私有的

/*** 编程实现所有方向的枚举，所有的方向：向上、向下、向左、向右*/
public class Direction {private final String desc; // 用于描述方向字符串的成员变量// 2.声明本类类型的引用指向本类类型的对象public static final Direction UP = new Direction("向上");public static final Direction DOWN = new Direction("向下");public static final Direction LEFT = new Direction("向左");public static final Direction RIGHT = new Direction("向右");// 通过构造方法实现成员变量的初始化，更加灵活// 1.私有化构造方法，此时该构造方法只能在本类的内部使用private Direction(String desc) {this.desc = desc;}// 通过公有的get方法可以在本类的外部访问该类成员变量的数值public String getDesc() {return desc;}
}

public class DirectionTest {public static void main(String[] args) {/*// 1.声明Direction类型的引用指向该类型的对象并打印特征Direction d1 = new Direction("向上");System.out.println("获取到的字符串是：" + d1.getDesc()); // 向上Direction d2 = new Direction("向下");System.out.println("获取到的字符串是：" + d2.getDesc()); // 向下Direction d3 = new Direction("向左");System.out.println("获取到的字符串是：" + d3.getDesc()); // 向左Direction d4 = new Direction("向右");System.out.println("获取到的字符串是：" + d4.getDesc()); // 向右System.out.println("-------------------------------------");Direction d5 = new Direction("向前");System.out.println("获取到的字符串是：" + d5.getDesc()); // 向前*///Direction.UP = 2; Error:类型不匹配//Direction d2 = null;//Direction.UP = d2; Error: final关键字修饰Direction d1 = Direction.UP;System.out.println("获取到的方向是：" + d1.getDesc()); // 向上System.out.println("-------------------------------------");// 使用一下Java5开始的枚举类型DirectionEnum de = DirectionEnum.DOWN;System.out.println("获取到的方向是：" + de.getDesc()); // 向下}
}

获取到的方向是：向上

获取到的方向是：向下

Enum类的概念和方法

所有的枚举类都继承自java.lang.Enum类，常用方法如下：

/*** 编程实现所有方向的枚举，所有的方向：向上、向下、向左、向右   枚举类型要求所有枚举值必须放在枚举类型的最前面*/
public enum DirectionEnum implements DirectionInterface {// 2.声明本类类型的引用指向本类类型的对象// 匿名内部类的语法格式：接口/父类类型 引用变量名 = new 接口/父类类型() { 方法的重写 };// public static final Direction UP = new Direction("向上") { 方法的重写 };UP("向上") {@Overridepublic void show() {System.out.println("贪吃蛇向上移动了一下！");}}, DOWN("向下") {@Overridepublic void show() {System.out.println("贪吃蛇向下移动了一下！");}}, LEFT("向左") {@Overridepublic void show() {System.out.println("左移了一下！");}}, RIGHT("向右") {@Overridepublic void show() {System.out.println("右移了一下！");}};private final String desc; // 用于描述方向字符串的成员变量// 通过构造方法实现成员变量的初始化，更加灵活// 1.私有化构造方法，此时该构造方法只能在本类的内部使用private DirectionEnum(String desc) { this.desc = desc; }// 通过公有的get方法可以在本类的外部访问该类成员变量的数值public String getDesc() {return desc;}// 整个枚举类型只重写一次，所有对象调用同一个/* @Overridepublic void show() {System.out.println("现在可以实现接口中抽象方法的重写了！");}*/
}

/*** 编程实现方向枚举类的测试，调用从Enum类中继承下来的方法*/
public class DirectionEnumTest {public static void main(String[] args) {// 1.获取DirectionEnum类型中所有的枚举对象DirectionEnum[] arr = DirectionEnum.values();// 2.打印每个枚举对象在枚举类型中的名称和索引位置for (int i = 0; i < arr.length; i++) {System.out.println("获取到的枚举对象名称是：" + arr[i].toString());System.out.println("获取到的枚举对象对应的索引位置是：" + arr[i].ordinal()); // 和数组一样下标从0开始}System.out.println("---------------------------------------------------------------");// 3.根据参数指定的字符串得到枚举类型的对象，也就是将字符串转换为对象//DirectionEnum de = DirectionEnum.valueOf("向下"); // 编译ok，运行发生IllegalArgumentException非法参数异常DirectionEnum de = DirectionEnum.valueOf("DOWN");//DirectionEnum de = DirectionEnum.valueOf("UP LEFT"); // 要求字符串名称必须在枚举对象中存在//System.out.println("转换出来的枚举对象名称是：" + de.toString());System.out.println("转换出来的枚举对象名称是：" + de); // 当打印引用变量时，会自动调用toString方法System.out.println("---------------------------------------------------------------");// 4.使用获取到的枚举对象与枚举类中已有的对象比较先后顺序for(int i = 0; i < arr.length; i++) {// 当调用对象在参数对象之后时，获取到的比较结果为 正数// 当调用对象在参数对象相同位置时，则获取到的比较结果为 零// 当调用对象在参数对象之前时，则获取到的比较结果为 负数System.out.println("调用对象与数组中对象比较的先后顺序结果是：" + de.compareTo(arr[i]));}System.out.println("---------------------------------------------------------------");// 5.使用数组中每个DirectionEnum对象都去调用show方法测试for (int i = 0; i < arr.length; i++) {arr[i].show();}}
}

获取到的枚举对象名称是：UP
获取到的枚举对象对应的索引位置是：0
获取到的枚举对象名称是：DOWN
获取到的枚举对象对应的索引位置是：1
获取到的枚举对象名称是：LEFT
获取到的枚举对象对应的索引位置是：2
获取到的枚举对象名称是：RIGHT

获取到的枚举对象对应的索引位置是：3

转换出来的枚举对象名称是：DOWN

调用对象与数组中对象比较的先后顺序结果是：1
调用对象与数组中对象比较的先后顺序结果是：0
调用对象与数组中对象比较的先后顺序结果是：-1

调用对象与数组中对象比较的先后顺序结果是：-2

贪吃蛇向上移动了一下！
贪吃蛇向下移动了一下！
左移了一下！
右移了一下！

使用枚举的优势

public class DirectionUseTest {// 自定义静态方法实现根据参数指定的字符串内容来打印具体的方向信息public static void test1(String str) {switch (str) {case "向上":System.out.println("抬头望明月！"); break;case "向下":System.out.println("低头思故乡！"); break;case "向左":System.out.println("左牵黄"); break;case "向右":System.out.println("右擎苍"); break;default:System.out.println("没有这样的方向哦！");}}// 自定义静态方法实现根据参数指定的枚举类型来打印具体的方向信息public static void test2(DirectionEnum de) {switch (de) {case UP:System.out.println("抬头望明月！"); break;case DOWN:System.out.println("低头思故乡！"); break;case LEFT:System.out.println("左牵黄"); break;case RIGHT:System.out.println("右擎苍"); break;default:System.out.println("没有这样的方法哦！");}}public static void main(String[] args) {DirectionUseTest.test1(Direction.UP.getDesc());DirectionUseTest.test1("今天是个好日子！");System.out.println("--------------------------------------------");DirectionUseTest.test2(DirectionEnum.DOWN);//DirectionUseTest.test2("今天是个好日子！"); Error:类型不匹配，减少了出错的可能性}
}

没有这样的方向哦！

低头思故乡！

枚举类实现接口的方式

• 枚举类实现接口后需要重写抽象方法，而重写方法的方式有两种：重写一个，或者每个对象都重写。(参考：Enum类的概念和方法 中有代码讲解)

public interface DirectionInterface {// 自定义抽象方法public abstract void show();
}

(五)注解

注解的基本概念

• 注解（Annotation）又叫标注，是从Java5开始增加的一种引用数据类型。
• 注解本质上就是代码中的特殊标记，通过这些标记可以在编译、类加载、以及运行时执行指定的处理。

注解的语法格式

访问修饰符 @interface 注解名称 {

​ 注解成员;

}

• 自定义注解自动继承java.lang.annotation.Annotation接口。
• 通过@注解名称的方式可以修饰包、类、 成员方法、成员变量、构造方法、参数、局部变量的声明等。

注解的使用方式

• 注解体中只有成员变量没有成员方法，而注解的成员变量以“无形参的方法”形式来声明，其方法名定义了该成员变量的名字，其返回值定义了该成员变量的类型。
• 如果注解只有一个参数成员，建议使用参数名为value，而类型只能是八种基本数据类型、String类型、Class类型、enum类型及Annotation类型。

// 若一个注解中没有任何的成员，则这样的注解叫做标记注解/标识注解
public @interface MyAnnotation {//public Direction value(); // 声明一个String类型的成员变量，名字为value   类型有要求public String value() default "123"; // 声明一个String类型的成员变量，名字为valuepublic String value2();
}

// 表示将标签MyAnnotation贴在Person类的代码中，使用注解时采用 成员参数名 = 成员参数值, ...
//@MyAnnotation(value = "hello", value2 = "world")
@MyAnnotation(value2 = "world")
public class Person {/*** name是用于描述姓名的成员变量*/@MyAnnotation(value2 = "1")private String name;/*** age是用于描述年龄的成员变量*/private int age;/*** 编程实现无参构造方法*/@MyAnnotation(value2 = "2")public Person() {}/*** 编程实现有参构造方法* @param name* @param age*/public Person(@MyAnnotation(value2 = "4") String name, int age) {this.name = name;this.age = age;}/*** 自定义成员方法实现特征的获取和修改* @return*/@MyAnnotation(value2 = "3")public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}
}

元注解的概念

• 元注解是可以注解到注解上的注解，或者说元注解是一种基本注解，但是它能够应用到其它的注解上面。
• 元注解主要有 @Retention、@Documented、@Target、@Inherited、 @Repeatable

元注解@Retention

• @Retention 应用到一个注解上用于说明该注解的的生命周期，取值如下：
• RetentionPolicy.SOURCE 注解只在源码阶段保留，在编译器进行编译时它将被丢弃忽视。
• RetentionPolicy.CLASS 注解只被保留到编译进行的时候，它并不会被加载到 JVM 中，默认方式。
• RetentionPolicy.RUNTIME 注解可以保留到程序运行的时候，它会被加载进入到 JVM 中，所以在程序运行时可以获取到它们。

import java.lang.annotation.*;//@Retention(RetentionPolicy.SOURCE)     // 表示下面的注解在源代码中有效
//@Retention(RetentionPolicy.CLASS)      // 表示下面的注解在字节码文件中有效，默认方式
@Retention(RetentionPolicy.RUNTIME)      // 表示下面的注解在运行时有效
public @interface MyAnnotation {//public Direction value(); // 声明一个String类型的成员变量，名字为value   类型有要求public String value() default "123"; // 声明一个String类型的成员变量，名字为valuepublic String value2();
}

元注解@Documented

• 使用javadoc工具可以从程序源代码中抽取类、方法、成员等注释形成一个和源代码配套的API帮助文档，而该工具抽取时默认不包括注解内容
• @Documented用于指定被该注解将被javadoc工具提取成文档。
• 定义为@Documented的注解必须设置Retention值为RUNTIME。

import java.lang.annotation.*;@Retention(RetentionPolicy.RUNTIME)      // 表示下面的注解在运行时有效，定义为@Documented的注解必须设置Retention值为RUNTIME。
@Documented                              // 表示下面的注解信息可以被javadoc工具提取到API文档中，很少使用
// 表示下面的注解可以用于类型、构造方法、成员变量、成员方法、参数 的修饰
public @interface MyAnnotation {//public Direction value(); // 声明一个String类型的成员变量，名字为value   类型有要求public String value() default "123"; // 声明一个String类型的成员变量，名字为valuepublic String value2();
}

idea将 注解使用方式 中的Person类提取为API文档

元注解@Target

@Target用于指定被修饰的注解只能用于哪些元素的修饰，取值如下：

import java.lang.annotation.ElementType;
import java.lang.annotation.Target;// 表示下面的注解可以用于类型、构造方法、成员变量、成员方法、参数 的修饰
@Target({ElementType.TYPE, ElementType.CONSTRUCTOR, ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER})
public @interface MyAnnotation {//public Direction value(); // 声明一个String类型的成员变量，名字为value   类型有要求public String value() default "123"; // 声明一个String类型的成员变量，名字为valuepublic String value2();
}

元注解@Inherited

• @Inherited并不是说注解本身可以继承，而是说如果一个超类被该注解标记过的注解进行注解时，如果子类没有被任何注解应用时，则子类就继承超类的注解。

import java.lang.annotation.Inherited;@Inherited  // 表示下面的注解所修饰的类中的注解使用可以被子类继承
public @interface MyAnnotation {//public Direction value(); // 声明一个String类型的成员变量，名字为value   类型有要求public String value() default "123"; // 声明一个String类型的成员变量，名字为valuepublic String value2();
}

// 也就是可以继承Person类的注解
public class Student extends Person {}

person类就是 注解使用方式 中的Person

元注解@Repeatable

• @Repeatable表示自然可重复的含义，从Java8开始增加的新特性。
• 从Java8开始对元注解@Target的参数类型ElementType枚举值增加了两个：
• 其中ElementType.TYPE_PARAMETER 表示该注解能写在类型变量的声明语句中，如：泛型。
• 其中ElementType.TYPE_USE 表示该注解能写在使用类型的任何语句中。

java8之前

/*** 自定义注解里面可以描述多种角色* 无论java8之前或者之后都依赖于这个接口*/
public @interface ManTypes {ManType[] value();
}

//@ManTypes({@ManType(value = "职工"), @ManType(value = "超人")})  // 在Java8以前处理多个注解的方式
public class Man {}

java8之后

import java.lang.annotation.ElementType;
import java.lang.annotation.Target;/*** 自定义注解里面可以描述多种角色* 无论java8之前或者之后都依赖于这个接口*/
@Target(ElementType.TYPE_USE) //实现下面的注解在哪都可以使用
public @interface ManTypes {ManType[] value();
}

import java.lang.annotation.ElementType;
import java.lang.annotation.Repeatable;
import java.lang.annotation.Target;/*** 自定义注解用于描述任务的角色*/
@Repeatable(value = ManTypes.class)
@Target(ElementType.TYPE_USE) //因为ManTypes注解接口中的 @Target(ElementType.TYPE_USE)只局限于它自己而我们又需要多次重复使用ManType注解，所有ManType注解接口也需要@Target(ElementType.TYPE_USE) 并且每一个注解接口都要有对应的使用场景，否则就没有意义
public @interface ManType {String value() default "";
}

@ManType(value = "职工")
@ManType(value = "超人") //相当于两个@ManType注解都放在了ManTypes的注解值中
public class Man {public static void main(String[] args) {int ia = 97;char c1 = (@ManType char) ia;}
}

常见的预制注解

• 预制注解就是Java语言自身提供的注解，具体如下：
  
• 常用的预制注解如下：
  

public class Man {@Deprecated // 表示该方法已经过时，不建议使用public void show() {System.out.println("这个方法马上过时了！");}
}

public class ManTest {public static void main(String[] args) {Man man = new Man();man.show();}
}

这个方法马上过时了！

多态和特殊类 --＞特殊类相关推荐

1. python如何使用多态_在python 3中，如何将多态应用于类

   介绍 多态性是为不同的基础形式(例如,数据类型或类)利用同一接口的能力.这允许函数在不同时间使用不同类型的实体. 对于Python中的面向对象编程,这意味着可以用与属于特定类的特定对象相同的方式来使用 ...

2. JavaSE——面向对象高级（继承、final关键字、抽象类与接口、多态、Object类、内部类、包装类、可变参数）

   第3节 面向对象高级 一.继承 1.1 概述和使用 继承是java面向对象编程技术的一块基石,因为它允许创建分等级层次的类.继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法 ...

3. java中多态案例工厂类,Java中构造器内部的多态方法的行为实例分析

   本文实例讲述了Java中构造器内部的多态方法的行为操作.分享给大家供大家参考,具体如下: 这篇文章主要讨论的是,若在一个构造器中调用正在构造的对象的某个动态绑定的方法时会出现的情况.在此之前,我们需要 ...

4. 2019-9-17【Javase】object、final、实现关系、抽象类、接口、多态、UML类图

   文章目录 Object类 1.equals() hashCode():hash算法 toString(): 一.final 修饰: 类 ,方法,变量: 类: 此类不能被继承: 方法:不能被重写: 变量 ...

5. 【C++】多态问题：基类调用子类的protected或者private函数

   1.问题描述 如果在基类中虚函数是public,子类中重载时标记为protected或者private函数,是否还能访问这个函数? 答案是: 基类指针指向子类时,可以访问,并且访问的是子类重载后的函数 ...

6. 读书笔记_Effective_C++_条款七：为多态基类声明virtual析构函数

   严格来说,多态分为编译时多态和运行时多态,编译时多态是函数的重载,而运行时多态则是迟绑定技术,即根据基类指针或引用的实际指向来决定采取何种行动,一般来说,多态特指运行时多态.下面我们来举有关C++多态 ...

7. C++基础知识 —— 内存分区模型、引用、函数重载、类和继承、this指针、友元、多态、文件操作

      参考 黑马程序员 C++课程笔记,个人理解及整理  可以使用 在线编译c++代码 来简单验证.学习代码 目录 C++核心编程 1. 内存分区模型 1.1 程序运行前 1.2 程序运行后 1.3 ...

8. java自学 part2 数组 类和对象 包 继承 多态 抽象类 接口

   数组:arr 获取数组的长度:arr.length 数组转字符串: Arrays.toString(arr) 数组的拷贝: Arrays.copyOf(arr,arr.length) 数组的排序:Ar ...

9. 笔记②：牛客校招冲刺集训营---C++工程师（面向对象（友元、运算符重载、继承、多态） -- 内存管理 -- 名称空间、模板（类模板/函数模板） -- STL）

   0618 C++工程师 第5章 高频考点与真题精讲 5.1 指针 & 5.2 函数 5.3 面向对象(和5.4.5.5共三次直播课) 5.3.1 - 5.3.11 5.3.12-14 友元 友 ...

10. c++类和对象---多态

    1.多态的基本概念 多态是c++面向对象的三大特性之一 多态分为两类: 1.静态多态:函数重载和运算符重载属于静态多态,复用函数名 2.动态多态:派生类和虚函数实现运行时多态 静态多态和动态多态的区别 ...

最新文章

1. python apktool_Python使用ApkTool和子进程反编译APK
2. OPatch cannot find a valid oraInst.loc file to locate Central Inventory
3. android闹钟例子,自己软件中调用android系统闹钟
4. 《系统集成项目管理工程师》必背100个知识点-92信息系统的特点
5. 【PAT甲级 BigInteger】1019 General Palindromic Number (20 分) Java版 7/7通过
6. Swift--基本运算符
7. for 与 while 区别？
8. react 全选反选_js中怎么将createElement出来的复选框实现全选，全不选，反选效果？...
9. 如何 Get 机器学习必备的算法技能？ | 技术头条
10. 如何安装matlab？官网下载详细教程
11. java 504错误怎么解决_前端报504错误如何定位
12. Windows更新后双系统引导消失manjaro启动项丢失修复
13. Vulcan 团队信息
14. sklearn中shuffle的用法
15. Warning One or more files are in a conflicted state.
16. VMI管理常见的业务场景（一）
17. 【转】Java中斜杠和反斜杠的替换
18. 高频功率放大器输出为什么会有高次谐波
19. 微信小程序开发入门（连载）—— 开发前的准备工作
20. linux中默认文件666和目录777的权限关系

热门文章

1. Android应用开发-小巫CSDN博客客户端总结篇
2. spring boot 上传视频demo
3. 网站的PV是什么意思
4. 【JZOJ3339】wyl8899和法法塔的游戏【暴力】
5. 关于Adams仿真过程中问题的解决记录
6. 01[自制油猴插件]去掉烦人的外链提醒
7. 电子银行卡的优势分析
8. 立体匹配(Stereo Matching)
9. excel怎么设置密码？加密文件这么做！
10. Mahalanobis（马哈拉诺比斯）距离