java基础 -面向对象(高级)笔记
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();
}
}
运行结果:
436,家庭作业1
package com.hspedu.enum_;
public class Homework {
public static void main(String[] args) {
}
}
class Frock{
private static int currentNum = 100000;
private int serialNumber;
public static int getNextNum()
{
currentNum += 100; //将currentNum增加100
return currentNum;
}
public Frock() {
serialNumber = getNextNum();
}
public int getSerialNumber() {
return serialNumber;
}
}
class TestFrock{
public static void main(String[] args) {
System.out.println(Frock.getNextNum());//100100
System.out.println(Frock.getNextNum());//100200
Frock frock = new Frock();//序列号就是100300
Frock frock1 = new Frock();//序列号就是100400
Frock frock2 = new Frock();//序列号就是100500
System.out.println(frock.getSerialNumber());//100300
System.out.println(frock1.getSerialNumber());//100400
System.out.println(frock2.getSerialNumber());//100500
}
}
437,家庭作业2(匿名内部类的题)
package com.hspedu.enum_;
public class Homework {
public static void main(String[] args) {
Celllphone celllphone = new Celllphone();
//老韩解读
//1,匿名内部类是
/*
new ICalculate() {
@Override
public double work(double n1, double n2) {
return n1 + n2;
}
}, 同时也是一个对象
他的编译类型 ICalculate,他的运行类型就是 匿名内部类
*/
celllphone.testWork(new ICalculate() {
@Override
public double work(double n1, double n2) {
return n1 + n2;
}
}, 10, 8);//18
celllphone.testWork(new ICalculate() {
@Override
public double work(double n1, double n2) {
return n1 * n2;
}
}, 10, 8);//80
}
}
interface ICalculate{
//work方法 是完成计算,但是题没有具体要求,所以自己设计
//至于该方法完成怎样的计算,我们交给匿名内部类完成
public double work(double n1, double n2);
}
class Celllphone {
//老韩解读,当我们调用testWork方法时,直接传入一个实现了ICalculate接口的匿名内部类即可
//该匿名内部类,可以灵活的实现work,完成不同的计算任务
public void testWork(ICalculate iCalculate, double n1, double n2)
{
double result = iCalculate.work(n1, n2);//动态绑定
System.out.println("计算后的结果是= " + result);
}
}
438,家庭作业3(局部内部类的题)
package com.hspedu.enum_;
public class Homework {
public static void main(String[] args) {
new A().f1();
}
}
class A { //外部类
private String NAME = "hello";
public void f1() {
class B {//局部内部类
private final String NAME = "韩顺平教育";
public void show()
{
//如果内部类和外部类的属性重名,可以同 外部类.this.属性名来指定
System.out.println("NAME=" + NAME + " 外部类的name=" + A.this.NAME);
}
}
//别忘了:外部类A类在方法中,可以创建B类对象,然后调用方法即可
B b = new B();
b.show();
}
}
439,家庭作业4(综合题)
编程 : 需求 -----> 理解-------> 代码 ---------> 优化
增加一个情况,如果唐僧过火焰山,使用 飞机 ----> 程序扩展性,我们前面的程序结构就非常好扩展
文件结构如下:
Vehicles接口类代码:
package com.hspedu.homework;
public interface Vehicles {
//有一个交通工具接口类Vehicles,有work接口
public void work();
}
Boat类代码:
package com.hspedu.homework;
public class Boat implements Vehicles{
@Override
public void work() {
System.out.println("过河的时候,使用小船...");
}
}
Horse类代码:
package com.hspedu.homework;
public class Horse implements Vehicles{
@Override
public void work() {
System.out.println("一般情况下,使用马儿前进...");
}
}
Plane类代码:
package com.hspedu.homework;
public class Plane implements Vehicles{
@Override
public void work() {
System.out.println("过火焰山,使用飞机...");
}
}
VehiclesFactory类代码:
package com.hspedu.homework;
public class VehiclesFactory {
//马儿始终是同一匹,因为唐僧西天取经只骑着同一匹白龙马
private static Horse horse = new Horse();//饿汉式
private VehiclesFactory(){}
//创建交通工厂类,有两个方法分别获得交通工具Horse和Boat
//用static是因为,我们只用VehiclesFactory类里的方法,不用创建对象了
public static Horse getHorse(){
// return new Horse();
return horse;
}
public static Boat getBoat(){
return new Boat();
}
public static Plane getPlane(){
return new Plane();
}
}
Person类代码:
package com.hspedu.homework;
public class Person {
private String name;
private Vehicles vehicles;
//在创建人对象时,事先给他分配一个交通工具
public Person(String name, Vehicles vehicles) {
this.name = name;
this.vehicles = vehicles;
}
//思考一个问题,如何不浪费,在构建对象时,传入的交通工具对象
public void passRiver(){
//先得到船
//判断一下,当前的 vehicles 属性是null,就获取一艘船
// Boat boat = VehiclesFactory.getBoat();
// boat.work();
//如何防止始终使用的是传入的马 instanceof
// vehicles instanceof Boat 是判断 当前的 vehicles是不是Boat
//(1) vehicles = null : vehicles instanceof Boat => false
//(2) vehicles = 马对象 : vehicles instanceof Boat => false
//(3) vehicles = 船对象 : vehicles instanceof Boat => true
if(!(vehicles instanceof Boat))
{
//这里使用的是多态
vehicles = VehiclesFactory.getBoat();
}
vehicles.work();
}
public void common(){
//得到马儿
//判断一下,当前的 vehicles 属性是null,就获取一匹马
if(!(vehicles instanceof Horse) )
{
//这里使用的是多态
vehicles = VehiclesFactory.getHorse();
}
//这里体现使用接口调用
vehicles.work();
}
//过火焰山
public void passFireHill(){
//得到马儿
//判断一下,当前的 vehicles 属性是null,就获取一匹马
if(!(vehicles instanceof Plane) )
{
//这里使用的是多态
vehicles = VehiclesFactory.getPlane();
}
//这里体现使用接口调用
vehicles.work();
}
}
Homework1主类代码:
package com.hspedu.homework;
public class Homework1 {
public static void main(String[] args) {
Person tang = new Person("唐僧", new Horse());
tang.common();//一般情况下
tang.passRiver();//过河
tang.common();//一般情况下
tang.passRiver();//过河
tang.passRiver();//过河
//过火焰山
tang.passFireHill();
}
}
主类运行结果:
440,家庭作业5(成员内部类的题)
package com.hspedu.enum_;
public class Homework {
public static void main(String[] args) {
//实例化不同的car对象
Car car = new Car(60);
car.getAir().flow();
Car car1 = new Car(-1);
car1.getAir().flow();
Car car2 = new Car(20);
car2.getAir().flow();
}
}
class Car {
private double temperature;
public Car(double temperature) {
this.temperature = temperature;
}
//Air 成员内部类
class Air {
public void flow() {
if(temperature > 40)
{
System.out.println("温度大于40 空调吹冷气...");
} else if(temperature < 0)
{
System.out.println("温度小于0 空调吹暖气...");
} else {
System.out.println("温度正常,关闭空调...");
}
}
}
//返回一个Air对象
public Air getAir()
{
return new Air();
}
}