1. 内部类
1.1 概述
什么是内部类
将一个类A定义在另一个类B里面,里面的那个类A就称为内部类,B则称为外部类。
如果一个事物的内部包含另一个事物,那么这就是一个类内部包含另一个类。
例如:人体和心脏的关系。又如,汽车和发动机的关系。
分类:
- 成员内部类
- 局部内部类(包含匿名内部类)
(匿名内部类用的是最多的,所以【重点掌握】)
具有内部类的.class文件:两个类名称之间具有$符号。
如图所示:这也是为什么在标识符中不推荐使用$符号的原因。
如何在main方法内使用成员内部类?
有两种方式:
- 间接调用方式:在外部类的方法当中,使用内部类;然后main只是调用外部方法。
- 直接调用方式:记住公式:
类名称 对象名 = new 类名称();
【外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();】
public class Body { //外部类
public class Heart{ //成员内部类
//内部类的方法
public void beat(){
System.out.println("心脏跳动:蹦蹦蹦");
System.out.println("我叫:" + name);//正确写法!
}
}
//外部类的成员变量
private String name;
//外部类的方法
public void methodBody(){
System.out.println("外部类的方法");
new Heart().beat();//匿名对象
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
public class Demo01InnerClass {
public static void main(String[] args) {
Body body =new Body();//外部类的对象
//通过外部类的对象,调用外部类的方法,里面间接在使用内部类Heart。
body.methodBody();
System.out.println("-------------------------------------");
//按照公式写:
Body.Heart heart = new Body().new Heart();
heart.beat();
}
}
如何来访问重名的外部类变量:
如果出现了重名现象,那么格式是:外部类名称.this.外部类成员变量名
局部内部类
如果一个类是定义在一个方法内部的,那么这就是一个局部内部类。
“局部”:只有当前所属的方法才能使用它,出了这个方法外面就不能用了。
局部内部类定义格式:
修饰符 class 外部类名称{ //外部类
public void 外部类方法名称(参数列表){ //外部类方法
class 局部内部类名称{ //外部类方法里的类:局部内部类
//…
}
}
}
权限修饰符的注意事项:
小结一下类的权限修饰符:
public > protected > (default) > private
定义一个类的时候,权限修饰符规则:
- 外部类:public / (default)
- 成员内部类: public / protected / (default) / private
- 局部内部类: 什么都不能写(局部的,只有本方法才能用,与default是不一样的)
局部内部类的访问方法与成员内部类间接访问方法类似:都是在方法内部直接创建对象,调用方法。
例子:
public class Outer {
public void methodOuter(){
class Inner{ //局部内部类
int num = 10;
public void methodInner(){
System.out.println(num); //10
}
}
Inner inner = new Inner();
inner.methodInner();
}
}
public class DemoMain {
public static void main(String[] args) {
Outer outer = new Outer();
outer.methodOuter();
}
}
局部内部类的final问题:
局部内部类,如果希望访问所在方法的局部变量,那么这个局部变量必须是(有效final的:只赋值了一次)
备注:从java 8 开始,只要局部变量事实不变(只赋值了一次,没有第二次赋值),那么final关键字可以省略。
原因:
- new出来的对象在堆内存当中。
- 局部变量是跟着方法走,在栈内存当中。
- 方法运行结束之后,立刻出栈,局部变量就会立刻消失。
- 但是new出来的对象会在堆当中持续存在,知道垃圾回收消失。
(因为生命周期问题,局部变量消失后,内部类会复制一个常量进去,所以即使局部变量消失了,局部内部类也可以使用)
public class MyOuter {
public void methodOuter(){
int num = 10;//所在方法的局部变量
num = 20;
class MyInner{
public void methodInner(){
System.out.println(num);
}
}
}
}
1.2 匿名内部类【重点】
如果接口的实现类(或者是父类的子类)只需要使用唯一的一次时。
那么这种情况下就可以省略掉该类的定义,而该为使用【匿名内部类】。
匿名内部类的定义格式:
接口名称 对象名 = new 接口名称(){
//覆盖重写接口中所有抽象方法
};
(大括号内部是一个没有名字的类:匿名内部类)
用匿名内部类的好处:想用接口,为了接口不得不去定义一个实现类,这多麻烦;直接用匿名内部类,这样可以让我们省掉一个实现类的单独定义。
public interface MyInterface {
/*public abstract*/ void method();//抽象方法
}
public class MyInterfaceImpl implements MyInterface{
@Override
public void method() {
System.out.println("实现类覆盖重写了方法!");
}
}
public class DemoMain {
public static void main(String[] args) {
MyInterface impl = new MyInterfaceImpl();
impl.method();
MyInterface some = new MyInterface(){
@Override
public void method() {
System.out.println("匿名内部类实现了方法!");
}
};
some.method();
}
}
匿名内部类的注意事项:
对个格式“new 接口名称(){…}”进行解析:
- new 代表创建对象的动作
- 接口对象就是匿名内部类需要实现哪个接口。
- {…}这才是匿名内部类的内容。
另外还要注意几点及几点问题:
- 匿名内部类,在【创建对象】的时候,只能使用唯一的一次(再new就必须再来一个大括号)。
如果希望多次创建对象,而且类的内容一样的话,那么就必须使用单独定义的实现类了。(或者匿名内部类写两遍) - 匿名对象,在【调用方法】的时候,只能调用唯一一次。
如果希望同一个对象调用多次方法,就要给个对象名(创建对象),也可以再次创建一个匿名对象(匿名内部类)进行调用。 - 匿名内部类是省略了【实现类/子类名称】,但是匿名对象是省略了【对象名称】。
强调:匿名内部类(有名字或没名字的)与匿名对象(没名字)不是一回事!!!
public interface MyInterface {
/*public abstract*/ void method1();//抽象方法
void method2();
}
public class MyInterfaceImpl implements MyInterface{
@Override
public void method1() {
System.out.println("实现类覆盖重写了方法!111");
}
@Override
public void method2() {
System.out.println("实现类覆盖重写了方法!222");
}
}
public class DemoMain {
public static void main(String[] args) {
MyInterface impl = new MyInterfaceImpl();
impl.method1();
impl.method2();
//匿名内部类、匿名对象、对象的区别
//使用匿名内部类,但不是匿名对象,对象名称就是someA
MyInterface someA = new MyInterface(){
@Override
public void method1() {
System.out.println("匿名内部类A实现了方法!111");
}
@Override
public void method2() {
System.out.println("匿名内部类A实现了方法!222");
}
};
someA.method1();
someA.method2();
System.out.println("-----------------------------------");
//使用了匿名内部类,而且省略了对象名称,也是匿名对象
new MyInterface() {
@Override
public void method1() {
System.out.println("匿名内部类B实现了方法!111");
}
@Override
public void method2() {
System.out.println("匿名内部类B实现了方法!222");
}
}.method1();
}
}
2. 引用类型用法总结
实际的开发中,引用类型的使用非常重要,也是非常普遍的。我们可以在理解基本类型的使用方式基础上,进一步去掌握引用类型的使用方式。基本类型可以作为成员变量、作为方法的参数、作为方法的返回值,那么当然引用类型也是可以的。
(类)class作为成员变量类型:
/*
游戏当中的英雄角色类
*/
public class Hero {
private String name;//英雄名字
private int age;//英雄的年龄
private Weapon weapon;//武器
public Hero() {
}
public Hero(String name, int age, Weapon weapon) {
this.name = name;
this.age = age;
this.weapon = weapon;
}
public void attack(){
System.out.println("年龄为" + age + "的" + name + "用" + weapon.getCode() + "攻击敌方");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Weapon getWeapon() {
return weapon;
}
public void setWeapon(Weapon weapon) {
this.weapon = weapon;
}
}
public class Weapon {
private String code;//武器的代号
public Weapon() {
}
public Weapon(String code) {
this.code = code;
}
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
}
public class DemoMain {
public static void main(String[] args) {
//创建一个英雄角色
Hero one = new Hero();
one.setName("盖伦");
one.setAge(18);
//创建一个武器对象
Weapon weapon = new Weapon("霜之哀伤");
//为英雄配备武器
one.setWeapon(weapon);
//年龄为18的盖伦用霜之哀伤攻击敌方
one.attack();
}
}
(接口)interface作为成员变量类型:
public interface Skill {
public abstract void use();//释放技能的抽象方法
}
public class SkillImpl implements Skill{
@Override
public void use() {
System.out.println("烈焰吐息~~~~!!!");
}
}
public class Hero {
private String name;//英雄的名称
private Skill skill;//英雄的法术技能
public Hero() {
}
public Hero(String name, Skill skill) {
this.name = name;
this.skill = skill;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Skill getSkill() {
return skill;
}
public void setSkill(Skill skill) {
this.skill = skill;
}
}
public class DemoGame {
public static void main(String[] args) {
Hero hero = new Hero();
hero.setName("希尔薇");//设置英雄的名称
// hero.setSkill(new SkillImpl());//使用单独定义的实现类
//使用匿名内部类
/* Skill skill = new Skill() {
@Override
public void use() {
System.out.println("烈焰吐息~~~!!!");
}
};
hero.setSkill(skill);*/
//进一步简化 同时使用匿名内部类和匿名对象。
hero.setSkill(new Skill() {
@Override
public void use() {
System.out.println("烈焰吐息~~~!!!");
}
});
// System.out.println(hero.getName() + "使用" + hero.getSkill().use());
//不能这么使用:use()内部本来就是一条输出语句,不能嵌套输出。
System.out.println("我叫" + hero.getName() + ",开始释放技能:");
hero.getSkill().use();//调用接口的实现类方法
System.out.println("释放技能完成。");
}
}
接口作为方法的参数或是返回值:
import java.util.ArrayList;
import java.util.List;
/*
java.util.list 正是ArrayList所实现的接口。
*/
public class DemoInterface {
public static void main(String[] args) {
//左边是接口名称,右边是实现类名称,这是多态写法
List<String> list =new ArrayList<>();
List<String> result = addName(list);
System.out.println(result);//ArrayList直接打印,出现的不是地址,而是内容
for (int i = 0; i < result.size(); i++) {
System.out.println(result.get(i));
}
}
public static List<String> addName(List<String> list){
list.add("迪丽热巴");
list.add("古力娜扎");
list.add("马尔扎哈");
list.add("沙扬娜拉");
return list;
}
}
3. 综合案例-发红包【界面版】
红包文化源远流长。从古时的红色纸包,到手机App中的手气红包,红包作为一种独特的中华文化传承至今。之前的课程中,我们也编写过程序,模拟发普通红包。那么今天,我们将整合基础班课程中所有的技术和知识,编写一个带界面版的 发红包 案例。
场景说明:
红包发出去之后,所有人都有红包,大家抢完了之后,最后一个红包给群主自己。
大多数代码都是现成的,我们需要做的就是填空题。
我们自己要做的事情有:
1. 设置一下程序的标题,通过构造方法的字符串参数。
2. 设置群主名称。
3. 设置分发策略:平均还是随机?
红包分发的策略:
1. 普通红包(平均):totalMoney(总额) / totalCount(份数),余数放在最后一个红包当中
2. 手气红包(随机):最少一分钱,最多不超过平均数的2倍。应该是越发越少。
import cn.itcast.red.OpenMode;
import java.util.ArrayList;
public class NormalMode implements OpenMode {
@Override
public ArrayList<Integer> divide(final int totalMoney, final int totalCount) {
ArrayList<Integer> list = new ArrayList<>();
int avg = totalMoney / totalCount ;//平均值
int mod = totalMoney % totalCount; // 余数,模,零头
//注意totalCount - 1 代表最后一个先留着
for (int i = 0; i < totalCount - 1; i++) {
list.add(avg);
}
//有零头,需放在最后一个红包当中。
list.add(avg + mod);
return list;
}
}
**import cn.itcast.red.OpenMode;
import java.util.ArrayList;
import java.util.Random;
public class RandomMode implements OpenMode {
@Override
public ArrayList<Integer> divide(final int totalMoney, final int totalCount) {
ArrayList<Integer> list = new ArrayList<>();
//随机分配,有可能多,有可能少。
//最少1分钱,最多不超过‘剩下金额平均数的2倍’。
//第一次发红包,随机范围是0.01元 -- 3.33*2= 6.66元。
//第一次之后,剩下的至少是3.34元。
//此时还需要再发2个红包。
//此时的再发范围应该是0.01元~3.34元(取不到右边,剩下0.01)
//总结一下:范围的公式是:1 + random.nextInt(leftMoney / leftCount * 2 );
Random r = new Random();//首先创建一个随机数生成器。
//totalMoney是总金额,totalCount是总份数,不变
//额外定义两个变量,分别代表剩下多少钱,剩下多少份,
int leftMoney = totalMoney;
int leftCount = totalCount;
//随机发钱n-1个,最后一个不需要随机发
for (int i = 0; i < totalCount - 1; i++) {
//按照公式,生成随机金额
int money = r.nextInt(leftMoney / leftCount * 2) + 1;
list.add(money);//将一个随机红包放入集合
leftMoney -= money;//剩下的金额越发越少
leftCount--;//剩下还应该再发的红包个数,递减
}
//最后一个红包不需要随机发,直接放进去就得了。
list.add(leftMoney);
return list;
}
}**
import cn.itcast.red.RedPacketFrame;
public class MyRed extends RedPacketFrame {
/**
* 构造方法:生成红包界面。
*
* @param title 界面的标题
*/
public MyRed(String title) {
super(title);
}
}
public class Bootstrap {
public static void main(String[] args) {
MyRed red =new MyRed("传智播客双元课程");
//设置群主名称
red.setOwnerName("王思聪");
//设置分发策略
//普通红包
/* OpenMode normal = new NormalMode();
red.setOpenWay(normal);*/
//普通红包注掉,用随机红包(手气红包)
OpenMode random = new RandomMode();
red.setOpenWay(random);
}
}
界面代码省略
补充:轻量级小工具:jsheel
——此文档为学习笔记!