373，类变量引出
代码就提到了问题分析里的3点
package com.hspedu.static_;
public class ChildGame {
public static void main(String[] args) {
//定义一个变量 count，统计有多少小孩加入了游戏
int count = 0;
Child child1 = new Child("张三");
child1.join();
count++;
Child child2 = new Child("李四");
child2.join();
count++;
Child child3 = new Child("王五");
child3.join();
count++;
System.out.println("共有" + count + " 小孩加入了游戏...");
}
}
class Child{
private String name;
public Child(String name)
{
this.name = name;
}
public void join()
{
System.out.println(name + " 加入了游戏...");
}
}374，类变量快速入门
package com.hspedu.static_;
public class ChildGame {
public static void main(String[] args) {
//定义一个变量 count，统计有多少小孩加入了游戏
int count = 0;
Child child1 = new Child("张三");
child1.join();
//count++;
child1.count++;
Child child2 = new Child("李四");
child2.join();
//count++;
child2.count++;
Child child3 = new Child("王五");
child3.join();
//count++;
child3.count++;
System.out.println("共有" + Child.count + " 小孩加入了游戏...");
}
}
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类变量，在类加载的时候就生成了。
376，类变量定义访问
377，类变量使用细节
378，类方法快速入门
package com.hspedu.static_;
public class StaticMethod {
public static void main(String[] args) {
//创建2个学生对象，交学费
Stu tom = new Stu("tom");
tom.payFee(100);//Stu.payFee(100)也是对的
Stu mary = new Stu("mary");
Stu.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);
}
}运行结果：
379，类方法最佳实践
package com.hspedu.static_;
public class StaticMethod {
public static void main(String[] args) {
System.out.println(MyTools.calSum(1,2));
}
}
//开发自己的工具类，可以将方法做成静态的，方便调用
class MyTools{
public static double calSum(double n1, double n2)
{
return n1 + n2;
}
}运行结果：
380，类方法注意事项
382，main语法说明（和 384 main动态传值 ）
在idea的 Edit configurations 也能设置String类型的数组参数
package com.hspedu.static_;
public class StaticMethod {
public static void main(String[] args) {
for(int i = 0; i < args.length; i++)
{
System.out.print(args[i] + " ");
}
}
}
代码运行结果：
383，main特别说明
package com.hspedu.static_;
public class Main01 {
//静态的变量/属性
private static String name = "韩顺平教育";
//非静态的变量/属性
private int n1 = 100;
//静态方法
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，静态方法可以访问本类的静态成员
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();
}
}运行结果：
385，代码块快速入门
代码块调用的顺序优先于构造器package com.hspedu.codeblock_;
public class CodeBlock01 {
public static void main(String[] args) {
Movie movie = new Movie("你好，李焕英");
System.out.println("==================");
Movie movie1 = new Movie("唐探3", 100, "陈思成");
}
}
class Movie{
private String name;
private double price;
private String director;
//构造器 ---> 重载
//（1）下面的三个构造器都有相同的语句，就是3个输出语句本来在构造器里写着，现在放在{}里了
//（2）这样代码看起来比较冗余
//（3）这时我们可以把相同的语句，放入到一个代码块中，即可
//（4）这样当我们不管调用哪个构造器，创建对象，都会先调用代码块的内容
//（5）代码块调用的顺序优先于构造器...
{
System.out.println("电影屏幕打开...");
System.out.println("广告开始...");
System.out.println("电影正式开始...");
}
public Movie(String name) {
System.out.println("Movie(String name) 被调用...");
this.name = name;
}
public Movie(String name, double price) {
this.name = name;
this.price = price;
}
public Movie(String name, double price, String director) {
System.out.println("Movie(String name, double price, String director) 被调用");
this.name = name;
this.price = price;
this.director = director;
}
}运行结果：
386，代码块使用细节1
因为在类加载的时候，会调用代码块，所以当我们知道代码块啥时候调用时，就能知道类啥时候加载。
package com.hspedu.codeblock_;
public interface 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);//静态代码块一定会执行
}
}
class DD {
public static int n1 = 88;//静态属性
//静态代码块
static {
System.out.println("DD 的静态代码1被执行...");
}
//普通代码块，在new 对象时，被调用，而且是每创建一个对象，就调用一次
//可以这样简单的理解 普通代码块是构造器的补充，DD.n1就没有用到构造器
{
System.out.println("DD 的普通代码块...");
}
}
class Cat {
public static int n1 = 999;//静态属性
//静态代码块
static {
System.out.println("Cat 的静态代码1被执行...");
}
}
class BB {
//静态代码块
static {
System.out.println("BB 的静态代码1被执行...");
}
}
class AA extends BB{ //BB的子类
//静态代码块
static {
System.out.println("AA 的静态代码1被执行...");
}
}387，代码块使用细节2
package com.hspedu.codeblock_;
public class CodeBlockDetail02 {
public static void main(String[] args) {
A a = new A();
}
}
class A{
//普通属性的初始化
private int n2 = getN2();
//静态属性的初始化
private static int n1 = getN1();
//普通代码块
{
System.out.println("A 普通代码块01");
}
//静态代码块
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() 构造器被调用");
}
}运行结果：
388，代码块使用细节3
package com.hspedu.codeblock_;
public class CodeBlockDetail03 {
public static void main(String[] args) {
new BBB();//先看父类，再看子类，顺序和上节讲的一样
}
}
class AAA{
{
System.out.println("AAA的普通代码块...");
}
public AAA()
{
//(1)super()
//(2)调用本类的普通代码块
System.out.println("AAA() 构造器被调用...");
}
}
class BBB extends AAA{
{
System.out.println("BBB的普通代码块...");
}
public BBB(){
//(1)super()
//(2)调用本类的普通代码块
System.out.println("BBB() 构造器被调用...");
}
}运行结果：
389，代码块使用细节4
package com.hspedu.codeblock_;
public class CodeBlockDetail04 {
public static void main(String[] args) {
//(1)进行类的加载
//(2)创建对象
new B02();//对象
}
}
class A02{ //父类
private static int n1 = getVal01();
static {
System.out.println("A02的一个静态代码块...");
}
{
System.out.println("A02的一个普通代码块");
}
public int n3 = getVal02();
public static int getVal01()
{
System.out.println("getVal01");
return 10;
}
public int getVal02()
{
System.out.println("getVal02");
return 10;
}
public A02()
{
System.out.println("A02的构造器");
}
}
class B02 extends A02{
private static int n3 = getVal03();
static {
System.out.println("B02的一个静态代码块...");
}
{
System.out.println("B02的一个普通代码块");
}
public int n5 = getVal04();
public static int getVal03()
{
System.out.println("getVal03");
return 10;
}
public int getVal04()
{
System.out.println("getVal04");
return 10;
}
public B02()
{
//隐藏了
//super()
//普通代码块和普通属性的初始化
System.out.println("B02的构造器");
}
}运行结果：
391，单例模式饿汉式
package com.hspedu.codeblock_;
public class SingleTon01 {
public static void main(String[] args) {
//通过方法可以获取对象
GirlFriend instance = GirlFriend.getInstance();
System.out.println(instance);
GirlFriend instance2 = GirlFriend.getInstance();
System.out.println(instance2);
System.out.println(instance == instance2); // true，static 只会初始化一次
}
}
//有一个类，GirlFriend
//只能有一个女朋友
class GirlFriend {
private String name;
private static GirlFriend gf = new GirlFriend("小红红");//只要类加载，还没有用到gf，就已经创建好了一个对象，叫饿汉式
//如何保障我们只能创建一个 GirlFriend 对象
//步骤（单例模式-饿汉式）
//1，将构造器私有化
//2，在类的内部直接创建对象（该对象是static）
//3，提供一个公共的static方法，返回 gf 对象
private GirlFriend(String name)
{
this.name = name;
}
public static GirlFriend getInstance()
{
return gf;
}
@Override
public String toString() {
return "GirlFriend{" +
"name='" + name + '\'' +
'}';
}
}运行结果：
392，单例模式懒汉式
package com.hspedu.codeblock_;
public class SingleTon02 {
public static void main(String[] args) {
Cat instance = Cat.getInstance();
System.out.println(instance);
//再次调用getInstance
Cat instance2 = Cat.getInstance();
System.out.println(instance2);
}
}
//希望在程序运行过程中，只能创建一个Cat对象
//使用单例模式
class Cat {
private String name;
private static Cat cat = null;//默认是null
//步骤
//1，仍然构造器私有化
//2，定义一个static静态属性对象
//3，提供一个public的static方法，可以返回一个Cat对象
//4，懒汉式，只有当用户使用getInstance时，才返回cat对象，后面再次调用时，会返回上次创建的cat对象
private 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 + '\'' +
'}';
}
}运行结果：
393，final基本使用
package com.hspedu.final_;
public class Final01 {
public static void main(String[] args) {
E e = new E();
//e.TAX_RATE = 0.09;
}
}
//如果我们要求A类不能被其他类继承
//可以使用final修饰 A类
final class A {}
//calss B extends A{}
class C{
//如果我们要求hi不能被子类重写
//可以使用final修饰 hi 方法
public final void hi() {}
}
class D extends C {
// public void hi() {
// System.out.println("重写了C类的hi方法...");
// }
}
//当不希望类的某个属性的值被修改，可以用final修饰
class E {
public final double TAX_RATE = 0.08;
}
//当不希望某个局部变量被修改，可以使用final修饰
class F {
public void cry()
{
//这时，NUM也称为 局部变量
final double NUM = 0.01;
//NUM = 0.9;
System.out.println("NUM = " + NUM);;
}
}394，final使用细节1
package com.hspedu.final_;
public class Final01 {
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(double TAX_RATE2) { //构造器中赋值
this.TAX_RATE2 = TAX_RATE2;
}
{//在代码块赋值
TAX_RATE3 = 8.8;
}
}
class BB {
/*
如果final修饰的属性是静态的，则初始化的位置只能是
1，定义时 2，在静态代码块 不能在构造器中赋值
* */
public static final double TAX_RATE = 9.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 { }运行结果：
395，final使用细节2
package com.hspedu.final_;
public class Final01 {
public static void main(String[] args) {
System.out.println(BBB.num);
}
}
//final 和 static 往往搭配使用，效率更高，不会导致类加载，底层编译器做了优化处理
class BBB {
public final static int num = 100;
static {
System.out.println("BBB 静态代码块被执行");
}
}运行结果：
397，抽象类引出
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();
}398，抽象类细节1
package com.hspedu.abstract_;
public class Abstract01 {
public static void main(String[] args) {
}
}
//抽象类不一定要包含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;
}399，抽象类细节2
package com.hspedu.abstract_;
public class Abstract01 {
public static void main(String[] args) {
}
}
abstract class H {
public abstract void hi();
}
//如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类
abstract class E{
public abstract void hi();//抽象方法，static 无法被重写
}
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");
}
}401，抽象模板模式
父类模板类 Tmeplate 代码
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));
}
}子类AA类代码
package com.hspedu.abstract_;
public class AA extends Template{
//计算任务
//1+...+80000
@Override
public void job() {//实现Template的抽象方法job
long num = 0;
for (long i = 1; i <= 80000; i++) { //快捷键 80000.for 回车
num += i;
}
}
}子类BB类代码
package com.hspedu.abstract_;
public class BB extends Template{
@Override
public void job() {//这里也去重写了Template的job方法
long num = 0;
for (long i = 1; i <= 80000; i++) {
num *= i;
}
}
}主类TestTemplate代码
package com.hspedu.abstract_;
public class TestTemplate {
public static void main(String[] args) {
AA aa = new AA();
aa.calculateTime();
BB bb = new BB();
bb.calculateTime();
}
}运行结果：
402，接口快速入门
接口 UsbInterface类方法
package com.hspedu.interface_;
public interface UsbInterface {//接口
//规定接口的相关方法
public void start();
public void stop();
}Phone类代码
package com.hspedu.interface_;
//Phone类实现UsbInterface
//解读1，即 Phone类需要实现 UsbInterface接口 规定/声明的方法
public class Phone implements UsbInterface{
@Override
public void start() {
System.out.println("手机开始工作...");
}
@Override
public void stop() {
System.out.println("手机停止工作...");
}
}Camera类代码
package com.hspedu.interface_;
public class Camera implements UsbInterface{//实现接口
@Override
public void start() {
System.out.println("相机开始工作...");
}
@Override
public void stop() {
System.out.println("相机停止工作...");
}
}Computer类代码
package com.hspedu.interface_;
public class Computer {
//编写一个方法，计算机工作
//1，UsbInterface usbInterface 形参是接口类型 UsbInterface
//2，看到 接收 实现了 UsbInterface接口的类的对象实例
public void work(UsbInterface usbInterface)
{
//通过接口，来调用方法
usbInterface.start();
usbInterface.stop();
}
}主类 Interface01类代码
package com.hspedu.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);//把相机接入到计算机
}
}运行结果：
403，接口基本介绍
如下接口：
package com.hspedu.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...");
}
}404，接口应用场景
接口 DBInterface类代码
package com.hspedu.interface_;
public interface DBInterface {//项目经理
public void connect();//连接方法
public void close();//关闭连接
}MysqlDB类代码
package com.hspedu.interface_;
//A程序员连接Mysql
public class MysqlDB implements DBInterface{
@Override
public void connect() {
System.out.println("连接mysql");
}
@Override
public void close() {
System.out.println("关闭mysql");
}
}Oracle类代码
package com.hspedu.interface_;
//B程序员连接Oracle
public class OracleDB implements DBInterface{
@Override
public void connect() {
System.out.println("连接oracle");
}
@Override
public void close() {
System.out.println("关闭oracle");
}
}主类 Interface03类代码
package com.hspedu.interface_;
public class Interface03 {
public static void main(String[] args) {
MysqlDB mysqlDB = new MysqlDB();
t(mysqlDB); //主方法是static，可以调用static的t方法
System.out.println("=====================");
OracleDB oracleDB = new OracleDB();
t(oracleDB);
}
public static void t(DBInterface dbInterface)
{
dbInterface.connect();
dbInterface.close();
}
}运行结果：
405，接口使用细节1
package com.hspedu.interface_;
public class InterfaceDetail01 {
public static void main(String[] args) {
//new IA();
}
}
//1，接口不能被实例化
//2，接口中所有的方法是public方法，接口中抽象方法，可以不用abstract修饰
//3，一个普通类实现接口，就必须将该接口的所有方法都实现
//4，抽象类去实现接口时，可以不实现接口的抽象方法
interface IA {
void say();//不写修饰符，其实是public
}
class Cat implements IA{ //快捷键 alt + enter 可以快速添加实现方法
@Override
public void say() {
}
}
abstract class Tiger implements IA {
}406，接口使用细节2
package com.hspedu.interface_;
public class InterfaceDetail02 {
public static void main(String[] args) {
System.out.println(IB.n1);//说明 n1 就是 static
//IB.n1 = 30;//说明n1是final
}
}
//接口的修饰符只能是public和默认，这点和类的修饰符是一样的
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 {
}
//一个类同时可以实现多个接口
class Pig implements IB,IC {
@Override
public void hi() {
}
@Override
public void say() {
}
}408，接口VS继承
解耦 即：接口规范性+动态绑定
package com.hspedu.interface_;
public class ExtendsVsInterface {
public static void main(String[] args) {
LittleMonkey wuKong = new LittleMonkey("悟空");
wuKong.climbing();
wuKong.swimming();
wuKong.flying();
}
}
//猴子
class Monkey {
private String name;
public Monkey(String name) {
this.name = name;
}
public void climbing(){
System.out.println(name +" 会爬树...");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
//接口
interface Fishable {
void swimming();
}
interface Birdable {
void flying();
}
//继承
//小结： 当子类继承了父类，就自动的拥有了父类的功能
// 如果子类需要扩展功能，可以通过实现接口的方式扩展
// 可以理解 实现接口 是 对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() + " 通过学习，可以像鸟儿一样飞翔...");
}
}运行结果：
409，接口多态特性
案例1：多态参数
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{}案例2：多态数组
package com.hspedu.interface_;
public class InterfacePloyArr {
public static void main(String[] args) {
//多态数组 -> 接口类型数组
Usb[] usbs = new Usb[2];
usbs[0] = new Phone_();
usbs[1] = new Camera_();
for(int i = 0; i < usbs.length; i++)
{
usbs[i].work();//动态绑定
//需要进行类型的向下转型
if(usbs[i] instanceof Phone_)//判断他的运行类型是 Phone_
{
((Phone_) usbs[i]).call();//调用Phone_的特有方法call
}
}
}
}
interface Usb{
void work();
}
class Phone_ implements Usb {
public void call(){
System.out.println("手机可以打电话...");
}
@Override
public void work() {
System.out.println("手机工作中...");
}
}
class Camera_ implements Usb {
@Override
public void work() {
System.out.println("相机工作中...");
}
}运行结果：
案例3：多态传递
package com.hspedu.interface_;
public class InterfacePloyPass {
public static void main(String[] args) {
//接口类型的变量可以指向，实现了该接口的类的对象实例
IG ig = new Teacher();
//如果Teacher 类实现了 IG 接口,IG 继承了IH 接口
//那么，实际上就相当于 Teacher 类也实现了 IH 接口
//这就是所谓的 接口多态传递现象
IH ih = new Teacher();
}
}
interface IH { }
interface IG extends IH{ }
class Teacher implements IG {
}
412，四种内部类
package com.hspedu.InnerClass;
public class InnerClasses01 {//外部其他类
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类的内部
}
}
413，局部内部类1
package com.hspedu.InnerClass;
public class LocalInnerClass {
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,可以直接访问外部类的所有成员，包含私有的
public void f1() {
//5,局部内部类可以直接访问外部类的成员，比如下面 外部类n1 和 m2()
System.out.println("n1=" + n1);
m2();
}
}
//6,外部类在方法中，可以创建Inner02对象，然后调用方法即可
Inner02 inner02 = new Inner02();
inner02.f1();
}
}运行结果：
414，局部内部类2
package com.hspedu.InnerClass;
public class LocalInnerClass {//外部其他类
public static void main(String[] args) {
Outer02 outer02 = new Outer02();
outer02.m1();
System.out.println("outer02的hashcode=" + outer02);
}
}
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,可以直接访问外部类的所有成员，包含私有的
private int n1 = 800;
public void f1() {
//5,局部内部类可以直接访问外部类的成员，比如下面 外部类n1 和 m2()
//7,如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员
// 使用(外部类名.this.成员）去访问
// 老韩解读 Outer02.this 本质就是外部类的对象，即哪个对象调用了m1，Outer02.this就是哪个对象
System.out.println("n1=" + n1 + " 外部类的n1=" + Outer02.this.n1);
System.out.println("Outer02.this hashcode=" + Outer02.this);
m2();
}
}
//6,外部类在方法中，可以创建Inner02对象，然后调用方法即可
Inner02 inner02 = new Inner02();
inner02.f1();
}
}运行结果：
415，匿名内部类本质 （和 416 匿名内部类使用）
没有名字只是隐藏了，看不到而已。
1，演示基于接口，类，抽象类的匿名内部类
package com.hspedu.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/Dog 类只是使用一次，后面再不使用
//4，可以使用匿名内部类来简化开发
//5，tiger的编译类型？IA
//6，tiger的运行类型？就是匿名内部类 XXXX -> Outer04$1
/*
* 我们看底层 会分配 类名 Outer04$1
* class Outer04$1 implements IA {
@Override
public void cry() {
System.out.println("老虎叫唤...");
}
}
* */
//7，jdk底层在创建匿名内部类 Outer04$1,立即马上创建了 Outer04$1实例，并且把地址
// 返回给tiger
//8，匿名内部类使用一次，就不能再使用，但是下面实例的对象tiger可以反复使用
IA tiger = new IA() {
@Override
public void cry() {
System.out.println("老虎叫唤...");
}
};
System.out.println("tiger的运行类型=" + tiger.getClass());
tiger.cry();
tiger.cry();
tiger.cry();
// IA tiger = new Tiger();
// tiger.cry();
//演示基于类的匿名内部类
//分析
//1，father编译类型 Father
//2，father运行类型 Outer04$2
//3，底层会创建匿名内部类
/*
class Outer04$2 extends Father {
@Override
public void test() {
System.out.println("匿名内部类重写了test方法");
}
}
* */
//4，同时也直接返回了 匿名内部类 Outer04$2的对象
//5，注意("jack") 参数列表会传递给 构造器
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();
}运行结果：
417，匿名内部类细节
package com.hspedu.InnerClass;
public class AnonymousInnerClassDetail {
public static void main(String[] args) {
Outer05 outer05 = new Outer05();
outer05.f1();
//外部其他类 ----不能访问 --->匿名内部类
System.out.println("main outer05 hashcode=" + outer05);
}
}
class Outer05 {
private int n1 = 99;
public void f1() {
//创建一个基于类的匿名内部类
//不能添加访问修饰符，因为它的地位就是一个局部变量
//作用域：仅仅在定义它的方法或代码块中
Person p = new Person() {
private int n1 = 88;
@Override
public void hi() {
//可以直接访问外部类的所有成员，包含私有的
//如果外部类和匿名内部类的成员重名时，匿名内部类访问的话，
//默认遵循就近原则，如果想访问外部类的成员，则可以使用 （外部类名.this.成员）去访问
System.out.println("匿名内部类重写了 hi方法 n1=" + n1 + " 外部内的n1=" + Outer05.this.n1);
//Outer05.this 就是调用 f1的 对象
System.out.println("Outer05.this.hashcode=" + Outer05.this);
}
};
p.hi();//动态绑定，运行类型是 Outer05$1
//也可以直接调用，匿名内部类本身也是返回对象
//class 匿名内部类 extends Person {}
new Person() {
@Override
public void hi() {
System.out.println("匿名内部类重写了 hi方法，哈哈...");
}
@Override
public void ok(String str) {
super.ok(str);
}
}.ok("jack");
}
}
abstract class Person {//类
public void hi() {
System.out.println("Person hi()");
}
public void ok(String str) {
System.out.println("Person ok() " + str);
}
}
//抽象类/接口运行结果：
418，匿名内部类实践
1，练习1，当做实参直接传递
package com.hspedu.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("这是一幅名画xx...");
}
}运行结果：
2，练习2
package com.hspedu.InnerClass;
public class InnerClassExercise02 {
public static void main(String[] args) {
CellPhone cellPhone = new CellPhone();
//1，传递的是实现了 Bell接口的匿名内部类 InnerClassExercise02$1
//2，重写了 ring
//3，Bell bell = new Bell() {
// @Override
// public void ring() {
// System.out.println("懒猪起床了");
// }
// };
cellPhone.alarmclock(new Bell() {
@Override
public void ring() {
System.out.println("懒猪起床了");
}
});
cellPhone.alarmclock(new Bell() {
@Override
public void ring() {
System.out.println("小伙伴上课了");
}
});
}
}
interface Bell {//接口
void ring();//方法
}
class CellPhone {//类
public void alarmclock(Bell bell)//形参是Bell接口类型
{
System.out.println(bell.getClass());
bell.ring();//动态绑定
}
}运行结果：
419，成员内部类1
package com.hspedu.InnerClass;
public class MemberInnerClass01 {
public static void main(String[] args) {
Outer08 outer08 = new Outer08();
outer08.t1();
}
}
class Outer08 {//外部类
private int n1 = 10;
public String name = "张三";
//1，注意：成员内部类，是定义在外部类的成员位置上
//2，可以添加任意访问修饰符(public,protected,默认,private),因为它的地位就是一个成员
private class Inner08 {//成员内部类
public void say() {
//可以直接访问外部类的所有成员，包含私有的
System.out.println("n1 = " + n1 + " name = " + name);
}
}
//写方法
public void t1() {
//使用成员内部类
Inner08 inner08 = new Inner08();
inner08.say();
}
}运行结果：
420，成员内部类2
package com.hspedu.InnerClass;
public class MemberInnerClass01 {
public static void main(String[] args) {
Outer08 outer08 = new Outer08();
outer08.t1();
//外部其他类，使用成员内部类的两种方式
//其他外部类访问内部类，方式1
//老韩解读
//outer08.new Inner08(); 相当于把 new Inner08()当做是outer08成员
//这就是一个语法，不要特别的纠结
Outer08.Inner08 inner08 = outer08.new Inner08();
//第二种方式，在外部类中，编写一个方法，可以返回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),因为它的地位就是一个成员
class Inner08 {//成员内部类
public 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);
}
}运行结果：
421，静态内部类
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();//类名访问是指 new那里用了 外部类名.静态内部类名，不用创建对象了
inner10.say();
//方式二
//编写一个方法，可以返回静态内部类的对象实例
Outer10.Inner10 inner101 = Outer10.getInner10();//静态可以通过类名访问
System.out.println("==================");
inner101.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);
}
}
public void m1() {//外部类---访问------>静态内部类 访问方式：创建对象，再访问
Inner10 inner10 = new Inner10();
inner10.say();
}
public static Inner10 getInner10() {
return new Inner10();
}
}运行结果：
