文章目录
- Java基础
- 九、面向对象编程(高级)
- 类变量和类方法
- 类变量的内存布局
- 类变量基本介绍
- 类方法基本介绍
- 理解main语法说明
- 代码块
- 单例设计模式
- 什么是单例模式
- 饿汉式
- 懒汉式
- final关键字
- 抽象类
- 抽象类最佳实践 --- 模板设计模式
- 接口
- 基本介绍
- 接口应用场景
- 注意事项和实现细节
- 实现接口和继承类
- 接口的多态特性
- 内部类
- 基本介绍
- 局部内部类
- 匿名内部类
- 成员内部类
- 静态内部类
Java基础
九、面向对象编程(高级)
类变量和类方法
入门案例:设计一个int count 表示总人数,我们在创建一个小孩时,就把count 加1,并且count 是所有对象共享的
package com.Chapter03.static_;
public class ChildGame {
public static void main(String[] args) {
Child child1 = new Child("小明");
child1.count++;
Child child2 = new Child("小红");
child2.count++;
Child child3 = new Child("小王");
child3.count++;
//类变量可以通过类名来访问
System.out.println("共有"+Child.count+" 小孩加入了游戏....");
//下面的代码输出
System.out.println("child1.count="+child1.count); //3
System.out.println("child2.count="+child2.count); //3
System.out.println("child3.count="+child3.count); //3
}
}
class Child{
private String name;
//定义一个类变量count,是一个类变量(静态变量)static静态
//该变量最大的特点就是会被child类的所有的对象实例共享
public static int count = 0;
public Child(String name) {
this.name = name;
}
public void join(){
System.out.println(name+" 加入了游戏...");
}
}
类变量的内存布局
不管static变量在哪里,基本共识是:
- static变量是同一个类所有对象共享
- static类变量,在类加载的时候就生成了
类变量基本介绍
类变量也叫静态变量/静态属性,是该类的所有对象共享的变量,任何一个类的对象去访问它时,取到的值都是相同的值,同样任何一个该类的对象去修改它时,修改的也是同一个变量
定义类变量:
访问修饰符 static 数据类型 变量名;
static 访问修饰符 数据类型 变量名;
访问类变量: 类名.类变量名
或者 对象名.类变量名
(静态变量的访问修饰符的访问权限和范围和普通属性是一样的)
package com.hspedu.static_;
public class VisitStatic {
public static void main(String[] args) {
//类名.类变量名
//说明:类变量是随着类的加载而创建,所以即使没有创建对象实例也可以访问
System.out.println(A.name);
A a = new A();
//通过对象名.类变量名
System.out.println("a.name=" + a.name);
}
}
class A {
//类变量
//类变量的访问,必须遵守相关的访问权限.
public static String name = "Java学习";
//普通属性/普通成员变量/非静态属性/非静态成员变量/实例变量
private int num = 10;
}
使用细节:
1)什么时候需要用类变量
- 当我们需要让某个类的所有对象都共享一个变量时,就可以考虑使用类变量(静态变量)
2)类变量与实例变量(普通属性)区别
- 类变量是该类的所有对象共享的,而实例变量是每个对象独享的
3)加上static称为类变量或静态变量,否则称为实例变量/普通变量/非静态变量
4)类变量可以通过类名.类变量名或者对象名.类变量名来访问,但Java设计者推荐使用类名.类变量名方式访问(前提是满足访问修饰符的访问权限和范围)
5)实例变量不能通过类名.类变量名方式访问
6)类变量是在类加载时就初始化了,也就是说,即使你没有创建对象,只要类加载了,就可以使用类变量了
7)类变量的生命周期是随类的加载开始,随着类消亡而毁灭
package com.hspedu.static_;
public class StaticDetail {
public static void main(String[] args) {
B b = new B();
//System.out.println(B.n1);
System.out.println(B.n2);
//静态变量是类加载的时候,就创建了,所以我们没有创建对象实例
//也可以通过类名.类变量名来访问
System.out.println(C.address);
}
}
class B {
public int n1 = 100;
public static int n2 = 200;
}
class C {
public static String address = "北京";
}
类方法基本介绍
类方法也叫静态方法
形式: 访问修饰符 static 数据返回类型 方法名(){}
static 访问修饰符 数据返回类型 方法名(){}
类方法的调用:
使用方式:类名.类方法名 或者对象名.类方法名(前提是满足修饰符的访问权限和范围)
package com.Chapter03.static_;
public class StaticMethod {
public static void main(String[] args) {
//创建了2个学生对象,交学费
Stu tom = new Stu("tom");
tom.payFee(100);
Stu Job = new Stu("Job");
Job.payFee(200);
//输出当前收到的总学费
Stu.showFee(); //300
}
}
class Stu{
private String name; //普通成员
//定义一个静态变量,来累积学生的学费
private static double fee = 0;
public Stu(String name) {
this.name = name;
}
//说明:
//1.当方法使用了static修饰后,该方法就是静态方法
//2.静态方法就可以访问静态属性/变量
public static void payFee(double fee){
Stu.fee += fee; //累计到
}
public static void showFee(){
System.out.println("总学费有:"+Stu.fee);
}
}
类方法经典的使用场景:
- 当方法中不涉及到任何和对象相关的成员,则可以将方法设计成静态方法,提高开发效率
- 如果我们希望不创建实例,也可以调用某个方法(即当做工具来使用),这时,把方法做成静态方法时就比较合适
- 在程序员实际开发,往往会将一些通用的方法,设计成静态方法,这样我们不需要创建对象就可以使用了
注意事项:
1)类方法和普通方法都是随着类的加载而加载,将结构信息存储在方法区
- 类方法中无this的参数
- 普通方法中隐含着this的参数
2)类方法可以通过类名调用,也可以通过对象名调用
3)普通方法和对象有关,需要通过对象名调用,比如对象名.方法名(参数),不能通过类名调用
4)类方法中不允许使用和对象有关的关键字,比如this和super。普通方法可以
5)类方法(静态方法)中只能访问静态变量或静态方法
6)普通成员方法,既可以访问非静态成员(方法),也可以访问静态变量(方法)
小结:静态方法,只能访问静态的成员,非静态的方法,可以访问静态成员和非静态成员(必须遵守访问权限)
理解main语法说明
深入理解main方法:
解释main方法的形式: public static void main(String[] args){}
1)main方法是虚拟机调用
2)java虚拟机需要调用类的main()方法,所以该方法的访问权限必须是public
3)java虚拟机在执行main()方法时不必创建对象,所以该方法必须是static
4)该方法接收String类型的数组参数,该数组中保存执行java命令时传递给所运行的类的参数
5)java执行的程序 参数1 参数2 参数3
public class Hello{
public static void main(String[] args){
//args怎么传入的
for(int i = 0;i < args.length; i++){
System.out.println("第" + (i + 1) +"个参数" + args[i]);
}
}
}
注意事项:
1)在main()方法中,我们可以直接调用main方法所在的类的静态方法或静态属性
2)但是,不能直接访问该类的非静态成员,必须创建该类的一个实例对象后,才能通过这个对象去访问该类中的非静态成员
package com.hspedu.main_;
public class Main01 {
//静态的变量/属性
private static String name = "韩顺平教育";
//非静态的变量/属性
private int n1 = 10000;
//静态方法
public static void hi() {
System.out.println("Main01 的hi 方法");
}
//非静态方法
public void cry() {
System.out.println("Main01 的cry 方法");
}
public static void main(String[] args) {
//可以直接使用name
//1. 静态方法main 可以访问本类的静态成员
System.out.println("name=" + name);
hi();
//2. 静态方法main 不可以访问本类的非静态成员
//System.out.println("n1=" + n1);//错误
//cry();
//3. 静态方法main 要访问本类的非静态成员,需要先创建对象, 再调用即可
Main01 main01 = new Main01();
System.out.println(main01.n1);//ok
main01.cry();
}
}
代码块
基本介绍:
代码块又称为初始化块,属于类中的成员[即是类的一部分],类似于方法,讲逻辑语句封装在方法体中,通过{}包围起来
但和方法不同,没有方法名,没有返回,没有参数,只有方法体,而且不用通过对象或类显示调用,而是加载类时,或创建对象时隐式调用
基于语法:
[修饰符]{
代码
};
注意事项:
1)修饰符可选,要写的话,也只能写static
2)代码块分为两类,使用static修饰的叫静态代码块,没有static修饰的叫普通代码块/非静态代码块
3)逻辑语句可以为任何逻辑语句(输入、输出、方法调用、循环、判断等)
4);号可以协商,也可以省略
好处:
1)相当于另外一种形式的构造器(对构造器的补充机制,可以做初始化的操作)
2)场景:如果多个构造器中都有重复的语句,可以抽取到初始化块中,提高代码的重用性
package com.Chapter03.Codeblock;
public class CodeBlock01 {
public static void main(String[] args) {
Movie movie1 = new Movie("你好");
}
}
class Movie{
private String name;
private double price;
private String director;
//(1)下面的三个构造器都有相同的语句
//(2)这样代码看起来比较冗余
//(3)这时我们可以把相同的语句放入到一个代码块中,即可
//(4)这样当我们不管调用哪个构造器。创建对象,都会首先调用代码块的内容
//(5)代码块的调用优先于构造器
{
System.out.println("电影屏幕打开...");
System.out.println("广告开始...");
System.out.println("电影正是开始...");
}
public Movie(String name) {
this.name = name;
System.out.println("Movie(String name) 被调用...");
// System.out.println("电影屏幕打开...");
// System.out.println("广告开始...");
// System.out.println("电影正是开始...");
}
public Movie(String name, double price) {
this.name = name;
this.price = price;
// System.out.println("电影屏幕打开...");
// System.out.println("广告开始...");
// System.out.println("电影正是开始...");
}
public Movie(String name, double price, String director) {
this.name = name;
this.price = price;
this.director = director;
// System.out.println("电影屏幕打开...");
// System.out.println("广告开始...");
// System.out.println("电影正是开始...");
}
}
注意事项和使用细节:
1)static代码块也叫静态代码块,作用就是对类进行初始化,而且它随着类的加载而执行,并且只会执行一次,如果是普通代码块,每创建一个对象,就执行。
2)类什么时候被加载重点
①创建对象实例时(new)
②创建子类对象实例,父类也会被加载
③使用类的静态成员时(静态属性,静态方法)
3)普通代码块,在创建对象实例时,会被隐式的调用,被创建一次,就会调用一次,如果只是使用类的静态成员时,普通代码块并不会执行
小结:
1)static代码块是类加载时,执行,只会执行一次;
2)普通代码块是在创建对象时调用,创建一次,调用一次
package com.hspedu.codeblock_;
public class CodeBlockDetail01 {
public static void main(String[] args) {
//类被加载的情况举例
//1. 创建对象实例时(new)
// AA aa = new AA();
//2. 创建子类对象实例,父类也会被加载, 而且,父类先被加载,子类后被加载
// AA aa2 = new AA();
//3. 使用类的静态成员时(静态属性,静态方法)
// System.out.println(Cat.n1);
//static 代码块,是在类加载时,执行的,而且只会执行一次.
// DD dd = new DD();
// DD dd1 = new DD();
//普通的代码块,在创建对象实例时,会被隐式的调用。
// 被创建一次,就会调用一次。
// 如果只是使用类的静态成员时,普通代码块并不会执行
System.out.println(DD.n1);//8888, 静态模块块一定会执行
}
}
class DD {
public static int n1 = 8888;//静态属性
//静态代码块
static {
System.out.println("DD 的静态代码1 被执行...");//
}
//普通代码块, 在new 对象时,被调用,而且是每创建一个对象,就调用一次
//可以这样简单的,理解普通代码块是构造器的补充
{
System.out.println("DD 的普通代码块...");
}
}
class Animal {
//静态代码块
static {
System.out.println("Animal 的静态代码1 被执行...");//
}
}
class Cat extends Animal {
public static int n1 = 999;//静态属性
//静态代码块
static {
System.out.println("Cat 的静态代码1 被执行...");//
}
}
class BB {
//静态代码块
static {
System.out.println("BB 的静态代码1 被执行...");//1
}
}
class AA extends BB {
//静态代码块
static {
System.out.println("AA 的静态代码1 被执行...");//2
}
}
4)创建一个对象时,在一个类调用顺序是:
①调用静态代码块和静态属性初始化(注意:静态代码块和静态属性初始化调用的优先级一样,如果有多个静态代码块和多个静态变量初始化,则按它们定义的顺序调用
②调用普通代码块和普通属性的初始化(注意:普通代码块和普通属性初始化,则按定义顺序调用)
③调用构造方法
package com.Chapter03.Codeblock;
public class CodeBlock02 {
public static void main(String[] args) {
A a = new A();
}
}
class A{
//非静态属性的初始化
private int n2 = getN2();
{ //普通代码块
System.out.println("A普通代码块");
}
//静态属性的初始化
private static int n1 = getN1();
static { //静态代码块
System.out.println("A静态代码块01");
}
public static int getN1(){
System.out.println("getN1被调用");
return 100;
}
public int getN2(){ //普通方法/非静态方法
System.out.println("getN2被调用");
return 200;
}
public A(){
System.out.println("A构造器被调用");
}
}
运行结果:
5)构造器的最前面其实隐含了super()和调用普通代码块,静态相关的代码块,属性初始化,在类加载时,就执行完毕,因此是优先于构造器和普通代码块执行的
class A {
public A0) {//构造器
//这里有隐藏的执行要求
//(1) super();//这个知识点,在前面讲解继承的时候
//(2)调用普通代码块的
System.out.println(" ok");
}
6)看一下创建一个子类对象时(继承关系),他们的静态代码块,静态属性初始化,普通代码块,普通属性初始化,构造方法的调用顺序是:
①父类的静态代码块和静态属性(优先级一样,按定义顺序执行)
②子类的静态代码块和静态属性(优先级一样,按定义顺序一样)
③父类的普通代码块和普通属性初始化(优先级一样,按定义顺序执行)
④父类的构造方法
⑤子类的普通代码块和普通属性初始化(优先级一样,按定义顺序执行)
⑥子类的构造方法
package com.Chapter03.Codeblock;
public class CodeBlock03 {
public static void main(String[] args) {
//(1)进行类加载
//1.1先记载父类A02,在加载子类 B02
//(2)创建对象
new B02();
}
}
class A02 { //父类
private static int n1 = getVal01();
static {
System.out.println("A02 的一个静态代码块..");//(2)
}
{
System.out.println("A02 的第一个普通代码块..");//(5)
}
public int n3 = getVal02();//普通属性的初始化
public static int getVal01() {
System.out.println("getVal01");//(1)
return 10;
}
public int getVal02() {
System.out.println("getVal02");//(6)
return 10;
}
public A02() {//构造器
//隐藏
//super()
//普通代码和普通属性的初始化......
System.out.println("A02 的构造器");//(7)
}
}
class B02 extends A02 { //
private static int n3 = getVal03();
static {
System.out.println("B02 的一个静态代码块..");//(4)
}
public int n5 = getVal04();
{
System.out.println("B02 的第一个普通代码块..");//(9)
}
public static int getVal03() {
System.out.println("getVal03");//(3)
return 10;
}
public int getVal04() {
System.out.println("getVal04");//(8)
return 10;
}
//一定要慢慢的去品..
public B02() {//构造器
//隐藏了
//super()
//普通代码块和普通属性的初始化...
System.out.println("B02 的构造器");//(10)
// TODO Auto-generated constructor stub
}
}
7)静态代码块只能直接调用静态成员(静态属性和静态方法),普通代码块可以调用任意成员
class C02 {
private int n1 = 100;
private static int n2 = 200;
private void m1() {
}
private static void m2() {
}
static {
//静态代码块,只能调用静态成员
//System.out.println(n1);错误
System.out.println(n2);//ok
//m1();//错误
m2();
}
{
//普通代码块,可以使用任意成员
System.out.println(n1);
System.out.println(n2);//ok
m1();
m2();
}
}
单例设计模式
什么是设计模式
1)静态方法和属性的经典使用
2)设计模式是在大量的实践中总结和理论化之后的优选的代码结构、编程风格、以及解决问题的思考方式。设计模式就像是经典的棋谱,不同的棋局,我们用不同的棋谱,免去我们自己再思考和摸索
什么是单例模式
单例(单个实例)
1)所谓类的单例设计模式,就是采取一定的方法保证在整个的软件系统中,对某个类只能存在一个对象实例,并且该类只提供一个取得其对象实例的方法
2)单例模式有两种方式:饿汉式和懒汉式
饿汉式
具体步骤:
1)构造器私有化 -->防止直接new
2)类的内部创建对象
3)向外暴露一个静态的公共方法 getInstance
package com.Chapter03.Single_;
public class SingleTon01 {
public static void main(String[] args) {
// GirlFriend xh = new GirlFriend("小红");
// GirlFriend xb = new GirlFriend("小白");
//通过方法可以获取对象
GirlFriend instance = GirlFriend.getInstance();
System.out.println(instance);
GirlFriend instance2 = GirlFriend.getInstance();
System.out.println(instance2);
System.out.println(instance == instance2);//T
}
}
//有一个类,GirlFriend
class GirlFriend{
private String name;
//为了能在静态方法中,返回gf对象,需要将其修饰为static
private static GirlFriend gf = new GirlFriend("Tom");
//如何保障我们只能创建一个GirlFriend对象
//步骤:单例模式-饿汉式
//1.将构造器私有化
//2.在类的内部直接创建
//3.提供一个公共的static方法,返回gf对象
private GirlFriend(String name) {
this.name = name;
}
public static GirlFriend getInstance(){
return gf;
}
@Override
public String toString() {
return "GirlFriend{" +
"name='" + name + '\'' +
'}';
}
}
懒汉式
package com.Chapter03.Single_;
//演示懒汉式的单例模式
public class SingleTon02 {
public static void main(String[] args) {
System.out.println(Cat.n1);
Cat instance = Cat.getInstance();
System.out.println(instance);
}
}
//希望在程序运行过程中,只能创建一个Cat对象
class Cat{
private String name;
public static int n1 = 1000;
private static Cat cat;
//步骤:
//1.仍然构造器私有化
//2.定义一个static静态属性
//3.提高一个public的static方法,可以返回一个Cat对象
//4.懒汉式,只有当用户使用getInstance时,才返回cat对象,后面再次调用时,会返回上次创建的cat对象
public Cat(String name) {
System.out.println("构造器被调用");
this.name = name;
}
public static Cat getInstance(){
if(cat == null) {//如果还没有创建cat对象
cat = new Cat("小可愛");
}
return cat;
}
@Override
public String toString() {
return "Cat{" +
"name='" + name + '\'' +
'}';
}
}
饿汉式与懒汉式区别:
1)二者最主要的区别在于创建对象的时机不同:饿汉式是在类加载就创建了对象实例,而懒汉式是在使用时才创建
2)饿汉式不存在线程安全问题,懒汉式存在线程安全问题
3)饿汉式存在浪费资源问题,因为程序员一个对象实例都没有使用,那么饿汉式创建的对象就浪费了,懒汉式是使用时才创建,就不存在这个问题
final关键字
基本介绍
在某些情况下,程序员有以下需求,就会使用final
1)当不希望类被继承时,可以用final修饰
2)当不希望父类的某个方法被子类覆盖/重写(override)时,可以用final关键字修饰
3)当不希望类的某个属性的值被修改,可以用final修饰
4)当不希望某个局部变量被修改,可以使用final修饰
package com.Chapter03.final_;
public class Final01 {
public static void main(String[] args) {
E e = new E();
// e.TAX;
}
}
//如果我们要求A类不能被其他类继承
//可以使用final修饰A类
final class A{}
//class B extends A{} 报错
class C{
//如果我们要求hi不能被子类重写
//可以使用final修饰hi方法
public final void hi(){}
}
class D extends C{
// @Override
// public void hi() {
// System.out.println("重写了C类的hi方法");
// }
}
//当不希望类的某个属性的值被修改,可以用final修饰
class E{
public final double TAX = 0.08;
}
//当不希望某个局部变量被修改,可以使用final修饰
class F{
public void cry(){
final double NUM = 0.01;
// NUM = 0.9;
System.out.println("NUM="+NUM);
}
}
注意事项和实现细节
1)final修饰的属性又叫常量,一般用xx_xx_xx来命令
2)final修饰的属性在定义时,必须赋初值,并且以后不能再修改,赋值可以在如下位置之一(选择一个位置赋初值即可)
- 定义时
- 在构造器中
- 在代码块中
3)如果final修饰的属性是静态的,则初始化的位置只能是
- 定义时
- 在静态代码块 不能在构造器中辅值
4)final类不能继承,但是可以实例化对象
5)如果类不是final类,但是含有final方法,则该方法虽然不能重写,但是可以被继承
package com.hspedu.final_;
public class FinalDetail01 {
public static void main(String[] args) {
CC cc = new CC();
new EE().cal();
}
}
class AA {
/*
1. 定义时:如public final double TAX_RATE=0.08;
2. 在构造器中
3. 在代码块中
*/
public final double TAX_RATE = 0.08;//1.定义时赋值
public final double TAX_RATE2 ;
public final double TAX_RATE3 ;
public AA() {//2.构造器中赋值
TAX_RATE2 = 1.1;
}
{//3.在代码块赋值
TAX_RATE3 = 8.8;
}
}
class BB {
/*
如果final 修饰的属性是静态的,则初始化的位置只能是
1.定义时 2.在静态代码块不能在构造器中赋值。
*/
public static final double TAX_RATE = 99.9;
public static final double TAX_RATE2 ;
static {
TAX_RATE2 = 3.3;
}
}
//final 类不能继承,但是可以实例化对象
final class CC { }
//如果类不是final 类,但是含有final 方法,则该方法虽然不能重写,但是可以被继承
//即,仍然遵守继承的机制.
class DD {
public final void cal() {
System.out.println("cal()方法");
}
}
class EE extends DD { }
6)一般来说,如果一个类已经是final类了,就没有必要再将方法修饰成final方法
7)final不能修饰构造方法(即构造器)
8)final和static往往搭配使用,效率更高,底层编译器做了优化处理
9)包装类(Integer,Double,Float,Boolean等都是final)String也是final类
package com.hspedu.final_;
public class FinalDetail02 {
public static void main(String[] args) {
System.out.println(BBB.num);
//包装类,String 是final 类,不能被继承
}
}
//final 和static 往往搭配使用,效率更高,不会导致类加载.底层编译器做了优化处理
class BBB {
public final static int num = 10000;
static {
System.out.println("BBB 静态代码块被执行");
}
}
final class AAA{
//一般来说,如果一个类已经是final 类了,就没有必要再将方法修饰成final 方法
//public final void cry() {}
}
抽象类
引入
package com.hspedu.abstract_;
public class Abstract01 {
public static void main(String[] args) {
}
}
abstract class Animal {
private String name;
public Animal(String name) {
this.name = name;
}
//思考:这里eat 这里你实现了,其实没有什么意义
//即: 父类方法不确定性的问题
//===> 考虑将该方法设计为抽象(abstract)方法
//===> 所谓抽象方法就是没有实现的方法
//===> 所谓没有实现就是指,没有方法体
//===> 当一个类中存在抽象方法时,需要将该类声明为abstract 类
//===> 一般来说,抽象类会被继承,有其子类来实现抽象方法.
// public void eat() {
// System.out.println("这是一个动物,但是不知道吃什么..");
// }
public abstract void eat() ;
}
基本介绍
1)用abstract关键字来修饰一个类时,这个类就叫抽象类
访问修饰符 abstract 类名{
}
2)用abstract关键字来修饰一个方法时,这个方法就是抽象方法
访问修饰符 abstract 返回类型 方法名(参数列表); //没有方法体
3)抽象类的价值更多作用是在于设计,是设计者设计好后,让子类继承并实现抽象类()
注意事项
1)抽象类不能被实例化
2)抽象类不一定要包含abstract方法,也就是说,抽象类可以没有abstract方法
3)一旦包含了abstract方法,则这个类必须声明为abstract
4)abstract只能修饰类和方法,不能修饰属性和其他的
package com.hspedu.abstract_;
public class AbstractDetail01 {
public static void main(String[] args) {
//抽象类,不能被实例化
//new A();
}
}
//抽象类不一定要包含abstract 方法。也就是说,抽象类可以没有abstract 方法
//,还可以有实现的方法。
abstract class A {
public void hi() {
System.out.println("hi");
}
}
//一旦类包含了abstract 方法,则这个类必须声明为abstract
abstract class B {
public abstract void hi();
}
//abstract 只能修饰类和方法,不能修饰属性和其它的
class C {
// public abstract int n1 = 1;
}
5)抽象类可以有任意成员(抽象类本质还是类),比如:非抽象方法、构造器、静态属性等
6)抽象方法不能有主体,即不能实现
7)如果一个类继承了抽象类,则它必须实现抽象类的所有抽象方法,除非它自己也声明为abstrcat类
8)抽象方法不能使用private、final和static来修饰,因为这些关键词都是与重写相违背
package com.hspedu.abstract_;
public class AbstractDetail02 {
public static void main(String[] args) {
System.out.println("hello");
}
}
//抽象方法不能使用private、final 和static 来修饰,因为这些关键字都是和重写相违背的
abstract class H {
public abstract void hi();//抽象方法
}
//如果一个类继承了抽象类,则它必须实现抽象类的所有抽象方法,除非它自己也声明为abstract 类
abstract class E {
public abstract void hi();
}
abstract class F extends E {
}
class G extends E {
@Override
public void hi() { //这里相等于G 子类实现了父类E 的抽象方法,所谓实现方法,就是有方法体
}
}
//抽象类的本质还是类,所以可以有类的各种成员
abstract class D {
public int n1 = 10;
public static String name = "韩顺平教育";
public void hi() {
System.out.println("hi");
}
public abstract void hello();
public static void ok() {
System.out.println("ok");
}
}
抽象类最佳实践 — 模板设计模式
抽象类体现的就是一种模板模式的设计,抽象类作为多个子类的通用模板,子类在抽象类的基础上进行扩展、改造,但子类总体上会保留抽象类的行为方式
模板设计模式能解决的问题:
1)当功能内部一部分实现是确定,一部分实现是不确定的,这时可以把不确定的部分暴露出去,让子类去实现
2)编写一个抽象父类,父类提供了多个子类的通用方法,并把一个或多个方法留给其子类实现,就是一种模板模式
package com.hspedu.abstract_;
abstract public class Template { //抽象类-模板设计模式
public abstract void job();//抽象方法
public void calculateTime() {//实现方法,调用job 方法
//得到开始的时间
long start = System.currentTimeMillis();
job(); //动态绑定机制
//得的结束的时间
long end = System.currentTimeMillis();
System.out.println("任务执行时间" + (end - start));
}
}
package com.hspedu.abstract_;
public class AA extends Template {
//计算任务
//1+....+ 800000
@Override
public void job() { //实现Template 的抽象方法job
long num = 0;
for (long i = 1; i <= 800000; i++) {
num += i;
}
}
// public void job2() {
// //得到开始的时间
// long start = System.currentTimeMillis();
// long num = 0;
// for (long i = 1; i <= 200000; i++) {
// num += i;
// }
// //得的结束的时间
// long end = System.currentTimeMillis();
// System.out.println("AA 执行时间" + (end - start));
// }
}
package com.hspedu.abstract_;
public class BB extends Template{
public void job() {//这里也去,重写了Template 的job 方法
long num = 0;
for (long i = 1; i <= 80000; i++) {
num *= i;
}
}
}
package com.hspedu.abstract_;
public class TestTemplate {
public static void main(String[] args) {
AA aa = new AA();
aa.calculateTime(); //这里还是需要有良好的OOP 基础,对多态
BB bb = new BB();
bb.calculateTime();
}
}
接口
为什么要有接口?
这样的设计需求在java编程/php/.net/go中也是会大量存在的,一个程序就是一个世界,在现实世界存在的情况,在程序中也会出现,可以用程序模拟
入门案例:
package com.Chapter03.Interface_;
public class Interface01 {
public static void main(String[] args) {
//创建相机
Camera camera = new Camera();
Phone phone = new Phone();
//创建计算机
Computer computer = new Computer();
computer.work(phone);//把手机接入到计算机
System.out.println("============");
computer.work(camera); //把相机接入到计算机
}
}
package com.Chapter03.Interface_;
public interface UsbInterface { //接口
//规定接口的相关方法
public void start();
public void stop();
}
package com.Chapter03.Interface_;
public class Camera implements UsbInterface{
@Override
public void start() {
System.out.println("相机开始工作");
}
@Override
public void stop() {
System.out.println("相机停止工作");
}
}
package com.Chapter03.Interface_;
public class Computer {
//规定接口的方法
public void work(UsbInterface usbInterface){
//通过接口来调用方法
usbInterface.start();
usbInterface.stop();
}
}
package com.Chapter03.Interface_;
//phone类实现usb接口
//1.即phone类需要实现Usb接口 规定/声明的方法
public class Phone implements UsbInterface{
@Override
public void start() {
System.out.println("手机开始工作");
}
@Override
public void stop() {
System.out.println("手机停止工作");
}
}
基本介绍
接口就是给出一些没有实现的方法,封装到一起,到某个类要使用的时候,在根据具体情况把这些方法写出来
语法:
interface 接口名{
//属性
//方法
}
class 类名 implements 接口{
自己属性;
自己方法;
必须实现的接口的抽象方法
}
注意:
1.在JDK7.0前接口里的所有方法都没有方法体,即都是抽象方法
2.JDK8.0 后接口类可以有静态方法,默认方法,也就是说接口中可以有方法的具体实现
package com.Chapter03.Interface_;
public class Interface02 {
public static void main(String[] args) {
A a = new A();
a.hi();
}
}
//1.如果一个类implements实现接口
//2.需要将该接口的所有抽象方法实现
class A implements AInterface{
@Override
public void hi() {
System.out.println("hi()....");
}
}
package com.Chapter03.Interface_;
public interface AInterface {
//写属性
public int n1 = 10;
//写方法
//在接口中,抽象方法,可以省略abstract关键字
public void hi();
//在jdk8后,可以有默认实现方法,需要使用default关键字修饰
default public void ok(){
System.out.println("ok~~~~~");
}
//在jdk8后,可以使用静态方法
public static void cry(){
System.out.println("cry~~~~");
}
}
接口应用场景
理解接口的概念其实不算太难,难得是不知道什么时候使用接口,具体的应用场景有:
1)说现在要制造战斗机,武装直升机,专家只需把飞机需要的功能/规格定下来即可,然后让别人具体实现即可
2)现在有一个项目经理,管理三个程序员,功能开发一个软件,为了控制和管理软件,项目经理可以定义一些接口,然后由程序员具体实现
package com.Chapter03.Interface_;
public class Interface03 {
public static void main(String[] args) {
Mysql mysql = new Mysql();
t(mysql);
OracleDB oracleDB = new OracleDB();
t(oracleDB);
}
public static void t(DBInterface db){
db.connect();
db.close();
}
}
package com.Chapter03.Interface_;
public interface DBInterface { //项目经理写的
public void connect(); //连接方法
public void close(); //关闭连接
}
package com.Chapter03.Interface_;
public class Mysql implements DBInterface{
@Override
public void connect() {
System.out.println("连接数据库");
}
@Override
public void close() {
System.out.println("关闭数据库");
}
}
package com.Chapter03.Interface_;
public class OracleDB implements DBInterface{
@Override
public void connect() {
System.out.println("连接Oracle");
}
@Override
public void close() {
System.out.println("关闭oracle");
}
}
注意事项和实现细节
1)接口不能被实例化
2)接口中所有的方法是public方法,接口中抽象方法,可以不用abstract修饰
3)一个普通类实现接口,就必须将该接口的所有方法实现
4)抽象类实现接口,可以不用实现接口的方法
package com.hspedu.interface_;
public class InterfaceDetail01 {
public static void main(String[] args) {
//new IA();
}
}
//1.接口不能被实例化
//2.接口中所有的方法是public 方法, 接口中抽象方法,可以不用abstract 修饰
//3.一个普通类实现接口,就必须将该接口的所有方法都实现,可以使用alt+enter 来解决
//4.抽象类去实现接口时,可以不实现接口的抽象方法
interface IA {
void say();//修饰符public protected 默认private
void hi();
}
class Cat implements IA{
@Override
public void say() {
}
@Override
public void hi() {
}
}
abstract class Tiger implements IA {
}
5)一个类同时可以实现多个接口
6)接口中的属性,只能是final的,而且是public static final修饰符。比如:int a = 1; 实际是public static final int a = 1;(必须初始化)
7)接口中属性的访问形式:接口名.属性名
8)一个接口不能继承其他的类,但是可以继承多个别的接口
9)接口的修饰符只能是public和默认
package com.hspedu.interface_;
public class InterfaceDetail02 {
public static void main(String[] args) {
//证明接口中的属性,是public static final
System.out.println(IB.n1);//说明n1 就是static
//IB.n1 = 30; 说明n1 是final
}
}
interface IB {
//接口中的属性,只能是final 的,而且是public static final 修饰符
int n1 = 10; //等价public static final int n1 = 10;
void hi();
}
interface IC {
void say();
}
//接口不能继承其它的类,但是可以继承多个别的接口
interface ID extends IB,IC {
}
//接口的修饰符只能是public 和默认,这点和类的修饰符是一样的
interface IE{}
//一个类同时可以实现多个接口
class Pig implements IB,IC {
@Override
public void hi() {
}
@Override
public void say() {
}
}
实现接口和继承类
package com.Chapter03.Interface_;
public class ExtendsVSInterface {
public static void main(String[] args) {
LittleMonkey wuKong = new LittleMonkey("悟空");
wuKong.climbling();
wuKong.swimming();
wuKong.flying();
}
}
//猴子
class Monkey{
private String name;
public Monkey(String name) {
this.name = name;
}
public void climbling(){
System.out.println("猴子会爬树");
}
public String getName() {
return name;
}
}
//接口
interface Fishable{
void swimming();
}
interface Birdable {
void flying();
}
//继承
//小结:
//1.当子类继承了父类,就自动的拥有父类的功能
//2.如果子类需要扩展功能,可以通过实现接口的方法扩展
//3.可以理解实现接口是对java单继承机制的一种补充
class LittleMonkey extends Monkey implements Fishable,Birdable{
public LittleMonkey(String name) {
super(name);
}
@Override
public void swimming() {
System.out.println(getName() + "通过学习会像鱼儿一样游泳");
}
@Override
public void flying() {
System.out.println(getName() + "通过学习会像鸟儿一样飞翔");
}
}
对比:
1)接口和继承解决的问题不同
- 继承的价值主要在于:解决代码的复用性和可维护行
- 接口的价值主要在于:设计,设计好各种规范(方法),让其它类去实现这些方法,即更加灵活
2)接口比继承更加灵活
- 接口比继承更加灵活,继承是满足is - a的关系,而接口只需满足like -a的关系
3)接口在一定程度上实现代码解耦 [即:接口规范性+动态绑定机制]
接口的多态特性
1)多态参数
- 在之前的Usb接口案例中,Usb usb,既可以接收手机对象,又可以接收相机对象,就体现接口多态(接口引用可以指向实现了接口的类的对象)
2)多态数组
- 给Usb数组中,存放Phone和相机对象,Phone类还有一个特有的方法call(),请遍历Usb数组,如果是Phone对象,除了调用Usb接口定义的方法外,还需要调用Phone特有方法call
3)接口存在多态传递现象
package com.hspedu.interface_;
public class InterfacePolyParameter {
public static void main(String[] args) {
//接口的多态体现
//接口类型的变量if01 可以指向实现了IF 接口类的对象实例
IF if01 = new Monster();
if01 = new Car();
//继承体现的多态
//父类类型的变量a 可以指向继承AAA 的子类的对象实例
AAA a = new BBB();
a = new CCC();
}
}
interface IF {}
class Monster implements IF{}
class Car implements IF{}
class AAA {
}
class BBB extends AAA {}
class CCC extends AAA {}
package com.Chapter03.Interface_;
public class InterfacePolyArr {
public static void main(String[] args) {
//多态数组
Usb[] usbs = new Usb[2];
usbs[0] = new Phone_();
usbs[1] = new Camera_();
/*
给Usb 数组中,存放Phone 和相机对象,Phone 类还有一个特有的方法call(),
请遍历Usb 数组,如果是Phone 对象,除了调用Usb 接口定义的方法外,
还需要调用Phone 特有方法call
*/
for(int i = 0 ; i< usbs.length;i++){
usbs[i].work(); //动态绑定
//和前面一样,我们仍然需要类型的向下转型
if(usbs[i] instanceof Phone_) {//判断他的运行类型是Phone_
((Phone_) usbs[i]).cal();
}
}
}
}
interface Usb{
void work();
}
class Phone_ implements Usb{
public void cal(){
System.out.println("手机可以打电话");
}
@Override
public void work() {
System.out.println("手机工作中");
}
}
class Camera_ implements Usb{
@Override
public void work() {
System.out.println("相机工作中");
}
}
运行结果:
package com.Chapter03.Interface_;
public class InterfacePolyPass {
public static void main(String[] args) {
//接口类型的变量可以指向,实现了该接口的类的对象实例
IG ig = new Teacher();
//如果IG继承了IH接口,而Teacher类实现了IG接口
//那么,实际上就相当于Teacher类也实现了IH接口
//这就是接口多态传递现象
IH ih = new Teacher();
}
}
interface IH{}
interface IG extends IH{}
class Teacher implements IG{}
内部类
基本介绍
一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类,嵌套其他类的类称为外部类,是我们类的第五大成员,【类的五大成员:属性、方法、构造器、代码块、内部类】内部类最大的特点就是可以直接访问私有属性,并且可以体现类与类之间的包含关系
基本语法:
class Outer{ //外部类
classs Inner{ //内布类
}
}
class Other{ //外部其他类
}
package com.Chapter03.InnerClass;
public class InnerClass01 { //外部其他类
public static void main(String[] args) {
}
}
class Outer{ //外部类
private int n1 = 100; //属性
public Outer(int n1) { //构造器
this.n1 = n1;
}
public void m1(){ //方法
System.out.println("m1()");
}
{
System.out.println("代码块");
}
class Inner{ //内部类,在Outer类的内部
}
}
内部类的分类:
1)定义在外部类局部位置上(比如方法内):
- 局部内部类(有类名)
- 匿名内部类(没有类名,重点)
2)定义在外部类的成员位置上:
- 成员内部类(没有static修饰)
- 静态内部类(使用static修饰)
局部内部类
局部内部类是定义在外部类的局部位置,比如方法中,并且有类名
1)可以直接访问外部类的所有成员,包含私有的
2)不能添加访问修饰符,因为它的地位就是一个局部变量,局部变量是不能使用修饰符的,但是可以使用final修饰,因为局部变量也可以使用final
3)作用域:仅仅在定义它的方法或代码块中
4)局部内部类 — 访问 —>外部类的成员 [访问方式:直接访问]
5)外部类 — 访问 —局部内部类的成员
- 访问方式:创建对象,再访问(必须在作用域内)
6)外部其他类 — 不能访问 ---->局部内部类(因为局部内部类地位是一个局部变量)
7)如果外部类和局部内部类的成员重名时,默认遵循就近原则,如果想访问呢外部类的成员,则可以使用(外部类名.this.成员)去访问
package com.Chapter03.InnerClass;
//演示局部内部类的使用
public class LoaclInnerClass { //外部其他类
public static void main(String[] args) {
Outer02 outer02 = new Outer02();
outer02.m1();
}
}
class Outer02{
private int n1 = 100;
private void m2(){
System.out.println("Outer02 m2()");
} //私有方法
public void m1(){ //方法
//1.局部内部类是定义在外部类的局部位置,通常在方法中
//3.不能添加访问修饰符,但是可以使用final修饰
//4.作用域:仅仅在定义它的方法或代码块中
final class Inner02{ //局部内部类(本质仍然是一个类)
//2.可以直接访问外部类的所有成员,包含私有的
//7.如果外部类和局部内部类的成员重名时,默认遵循就近原则,如果想访问呢外部类的成员,
// 则可以使用(外部类名.this.成员)去访问
//解释:Outer02.this本质就是外部类的对象,即哪个对象调用了m1,Outer02.this就是哪个对象
private int n1 = 300;
public void f1(){
//5.局部内部类可以直接访问外部类的成员,如下面的n1和m2()
System.out.println("n1=" + n1 +" 外部类的n1= " + Outer02.this.n1);
m2();
}
}
//6.外部类在方法中,可以创建Inner02对象,然后调用方法即可
Inner02 inner02 = new Inner02();
inner02.f1();
}
}
匿名内部类
说明:匿名内部类是定义在外部类的局部位置,比如方法中,并且没有类名
(1)本质是类
(2)内部类
(3)该类没有名字
(4)同时还是一个对象
基本语法:
new 类或接口(参数列表){
类体
};
package com.Chapter03.InnerClass;
//演示匿名内部类的使用
public class AnonymousInnerClass {
public static void main(String[] args) {
Outer04 outer04 = new Outer04();
outer04.method();
}
}
class Outer04{ //外部类
private int n1 = 10; //属性
public void method(){
//基于接口的匿名内部类
//1.需求:想使用IA接口,并创建对象
//2.传统方式,是写一个类,实现该接口。并创建对象
//3.但是希望Tiger类只使用一次,后面不再使用
//4.可以使用匿名内部类来简化开发
// IA tiger = new Tiger();
// tiger.cry();
//5.tiger的编译类型是IA
//6.tiger的运行类型是匿名内部类 XXXX=>Outer04$1
/*
看一下底层 会分配 类名 Outer04$1
class XXX implements IA{
@Override
public void cry() {
System.out.println("老虎叫唤");
}
}
*/
//7.jdk底层在创建匿名内部类Outer04$1,立即马上就创建了Outer$1实例,
//并且把地址返回给tiger
//8.匿名内部类使用一次,就不能再使用
IA tiger = new IA(){
@Override
public void cry() {
System.out.println("老虎叫唤");
}
};
System.out.println("tiger的运行类型=" + tiger.getClass());
tiger.cry();
//基于类的匿名内部类
//分析
//1.father 编译类型是Father
//2.father运行类型是Outer04$2 ($2是按顺序编号的)
//3.底层会创建匿名内部类
/*
class Outer04$2 extends Father{
@Override
public void test() {
System.out.println("匿名内部类重写了test方法");
}
}
*/
//4.同时也返回了匿名内部类Outer04$2的对象
//5.
Father father = new Father("jack"){
@Override
public void test() {
System.out.println("匿名内部类重写了test方法");
}
};
System.out.println("father对象运行类型=" + father.getClass());//Outer04$2
father.test();
//基于抽象类的匿名内部类
Animal animal = new Animal(){
@Override
void eat() {
System.out.println("小狗吃");
}
};
animal.eat();
}
}
interface IA{ //接口
public void cry();
}
//class Tiger implements IA{
//
// @Override
// public void cry() {
// System.out.println("老虎叫唤");
// }
//}
//class Dog implements IA{
//
// @Override
// public void cry() {
// System.out.println("小狗叫");
// }
//}
class Father{
public Father(String name){ //构造器
System.out.println("接收到name = " + name);
}
public void test(){
}
}
abstract class Animal{ //抽象类
abstract void eat();
}
使用细节:
1)匿名内部类的语法比较奇特,因为匿名内部类既是一个类的定义,同时它本身也是一个对象,因此从语法上看,它既有定义类的特征,也有创建对象的特征
2)可以直接访问外部类的所有成员
3)不能添加访问修饰符,因为它的地位就是一个局部变量
4)作用域:仅仅在定义它的方法或代码块中
5)匿名内部类 — 访问 —>外部类成员(访问方式:直接访问)
6)外部其他类不能访问匿名内部类(因为匿名内部类地位是一个局部变量)
7)如果外部类和内部类的成员重名时,内部类访问的话,默认遵循就近原则,如果想访问外部类的成员,则可以使用(外部类名.this.成员)去访问
package com.Chapter03.InnerClass;
public class AnonymousInnerClassDetail {
public static void main(String[] args) {
Outer05 outer05 = new Outer05();
outer05.f1();
}
}
class Outer05{
private int n1 = 99;
public void f1(){
//创建一个基于类的匿名内部类
//不能添加访问修饰符,因为它的地位就是一个局部变量
Person p = new Person(){
private int n1 = 60;
@Override
public void hi() {
//如果外部类和内部类的成员重名时,内部类访问的话,默认遵循就近原则,
// 如果想访问外部类的成员,则可以使用(外部类名.this.成员)去访问
System.out.println("匿名内部类重写了hi方法" + n1 + "外部内的n1= " + Outer05.this.n1);
}
};
p.hi(); //动态绑定,运行类型是Outer05$1
//也可以直接调用,匿名内部类本身也是返回对象
//class 匿名内部类 extends Person{}
// new Person(){
// @Override
// public void hi() {
// System.out.println("匿名内部类重写了hi方法,hhh");
// }
//
// @Override
// public void ok(String str) {
// super.ok(str);
// }
// }.ok("jack");
}
}
class Person{
public void hi(){
System.out.println("Person hi()");
}
public void ok(String str){
System.out.println("Person ok()" + str);
}
}
//抽象类/接口...
匿名内部类的最佳实践
当作实参直接传递:
package com.Chapter03.InnerClass;
public class InnerClassExercise01 {
public static void main(String[] args) {
//当做实参直接传递,简介高效
f1(new IL(){
@Override
public void show() {
System.out.println("这是一副名画....");
}
});
//传统方式
f1(new Picture());
}
//静态方法,形参是接口类型
public static void f1(IL il){
il.show();
}
}
//接口
interface IL{
void show();
}
//类->实现IL->编程领域(硬编码)
class Picture implements IL{
@Override
public void show() {
System.out.println("这是一副名画");
}
}
成员内部类
说明:成员内部类是定义在外部类的成员位置,并且没有static修饰
1)可以直接访问外部类的所有成员,包含私有的
2)可以添加任意访问修饰符(public,protected,默认,private),因为它的地位就是一个成员
3)作用域:和外部类的其他成员一样,为整个类体
4)成员内部类访问外部类成员(比如:属性)访问方式:直接访问
5)外部类访问内部类:访问方式:创建对象,再访问
6)外部其他类访问成员内部类
7)如果外部类和内部类的成员重名时,内部类访问的话,默认遵循就近原则,如果想访问外部类的成员,则可以使用(外部类名.this.成员) 去访问
package com.hspedu.innerclass;
public class MemberInnerClass01 {
public static void main(String[] args) {
Outer08 outer08 = new Outer08();
outer08.t1();
//外部其他类,使用成员内部类的三种方式
// 第一种方式
// outer08.new Inner08(); 相当于把new Inner08()当做是outer08 成员
// 这就是一个语法,不要特别的纠结.
Outer08.Inner08 inner08 = outer08.new Inner08();
inner08.say();
// 第二方式在外部类中,编写一个方法,可以返回Inner08 对象
Outer08.Inner08 inner08Instance = outer08.getInner08Instance();
inner08Instance.say();
}
}
class Outer08 { //外部类
private int n1 = 10;
public String name = "张三";
private void hi() {
System.out.println("hi()方法...");
}
//1.注意: 成员内部类,是定义在外部内的成员位置上
//2.可以添加任意访问修饰符(public、protected 、默认、private),因为它的地位就是一个成员
public class Inner08 {//成员内部类
private double sal = 99.8;
private int n1 = 66;
public void say() {
//可以直接访问外部类的所有成员,包含私有的
//如果成员内部类的成员和外部类的成员重名,会遵守就近原则.
//,可以通过外部类名.this.属性来访问外部类的成员
System.out.println("n1 = " + n1 + " name = " + name + " 外部类的n1=" + Outer08.this.n1);
hi();
}
}
//方法,返回一个Inner08 实例
public Inner08 getInner08Instance(){
return new Inner08();
}
//写方法
public void t1() {
//使用成员内部类
//创建成员内部类的对象,然后使用相关的方法
Inner08 inner08 = new Inner08();
inner08.say();
System.out.println(inner08.sal);
}
}
静态内部类
说明:静态内部类是定义在外部类的成员位置,并且有static修饰
1)可以直接访问外部类的所有静态成员,包含私有的,但不能直接访问非静态成员
2)可以添加任意访问修饰符(public、protected. 默认、private),因为它的地位就是一个成员。
3)作用域:同其他的成员,为整个类体
4)静态内部类–访问---->外部类(比如:静态属性) [访问方式:直接访问所有静态成员]
5)外部类-----访问----->静态内部类 访问方式:创建对象,再访问
6)外部其他类-----访问----> 静态内部类
7)如果外部类和静态内部类的成员重名时,静态内部类访问的时,默认遵循就近原则,如果想访问外部类的成员,则可以使用(外部类名.成员) 去访问
package com.hspedu.innerclass;
public class StaticInnerClass01 {
public static void main(String[] args) {
Outer10 outer10 = new Outer10();
outer10.m1();
//外部其他类使用静态内部类
//方式1
//因为静态内部类,是可以通过类名直接访问(前提是满足访问权限)
Outer10.Inner10 inner10 = new Outer10.Inner10();
inner10.say();
//方式2
//编写一个方法,可以返回静态内部类的对象实例.
Outer10.Inner10 inner101 = outer10.getInner10();
System.out.println("============");
inner101.say();
Outer10.Inner10 inner10_ = Outer10.getInner10_();
System.out.println("************");
inner10_.say();
}
}
class Outer10 { //外部类
private int n1 = 10;
private static String name = "张三";
private static void cry() {}
//Inner10 就是静态内部类
//1. 放在外部类的成员位置
//2. 使用static 修饰
//3. 可以直接访问外部类的所有静态成员,包含私有的,但不能直接访问非静态成员
//4. 可以添加任意访问修饰符(public、protected 、默认、private),因为它的地位就是一个成员
//5. 作用域:同其他的成员,为整个类体
static class Inner10 {
private static String name = "韩顺平教育";
public void say() {
//如果外部类和静态内部类的成员重名时,静态内部类访问的时,
//默认遵循就近原则,如果想访问外部类的成员,则可以使用(外部类名.成员)
System.out.println(name + " 外部类name= " + Outer10.name);
cry();
}
}
public void m1() { //外部类---访问------>静态内部类访问方式:创建对象,再访问
Inner10 inner10 = new Inner10();
inner10.say();
}
public Inner10 getInner10() {
return new Inner10();
}
public static Inner10 getInner10_() {
return new Inner10();
}
}