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(); } }
运行结果:
标签:java,void,System,public,面向对象,println,out,class,顺平 From: https://www.cnblogs.com/romantichuaner/p/18086219