概述
将一个类A定义在另一个类B里面,里面的那个类A就称为内部类,B则称为外部类。
成员内部类
成员内部类 :定义在类中方法外的类。
定义格式:
class 外部类 {
class 内部类{
}
}
在描述事物时,若一个事物内部还包含其他事物,就可以使用内部类这种结构。比如,汽车类Car 中包含发动机类Engine ,这时, Engine 就可以使用内部类来描述,定义在成员位置。
代码举例:
class Car { //外部类
class Engine { //内部类
}
}
访问特点
- 内部类可以直接访问外部类的成员,包括私有成员
- 外部类要访问内部类的成员,必须要建立内部类的对象。
如何使用成员内部类
1、间接方式:在外部类的方法当中,使用内部类,然后main只是调用外部类的方法
2、直接方式:公式:
类名称 对象名 = new 类名称();
【外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称()】
public class DemoInnerClasss{
public static void main(String[] args){
Body body = new Body();//外部类对象
//通过外部类的对象,调用外部类的方法,里面间接在使用内部类heart
body.methodBody;
//按照公式写:
Body.Heart heart =new Body().new Heart();
heart.beat();
}
}
成员变量重名
如果出现重名现象,那么格式是:外部类名称.this外部成员变量名
public class Outer{
int num =10;//外部类成员变量
public class Inner{
int num = 20;
public void methodInner(){
int num = 30;//内部类方法的局部变量
System.out.println(num);
System.out.println(this.num);
System.out.println(Outer.this.num);
}
}
局部内部类
定义格式:
修饰符 class 外部类名称{
修饰符 返回值类型 外部类方法名称(参数列表){
class 局部内部类名称{
//...
}
}
}
类的权限修饰符总结
public>protected>(default)>private
定义一个类的时候i,权限修饰符规则:
1、外部类:public/(default)
2、成员内部类:public>protected>(default)>private
3、局部内部类:什么都不写
匿名内部类
如果接口的实现类(或者父类的子类)只需要使用唯一的一次,那么这种情况下就可以省略掉该类的定义,而改为使用匿名内部类
匿名内部类的使用格式:
接口名称 对象名 = new 接口名称(){
//覆盖重写所有抽象类方法
};
对格式“new 接口名称(){…}”进行解析:
1、new 代表创建对象的动作
2、接口名称就是匿名内部类需要实现那个接口
3、{…}这才是匿名内部类的内容
另外还需注意:
1、匿名内部类在【创建对象】的时候,只能使用唯一的一次
如果希望多次创建对象,而且类的内容一样的话,那么久必须使用单独定义的类了
2、匿名对象在【调用方法】的时候,只能调用唯一的一次
如果希望同一个对象,多次调用方法,那么必须给对象起个名字
3、匿名内部类是省略了【实现类/子类名称】,但是匿名对象是省略了【对象名称】
强调匿名内部类和匿名对象不是一回事
package Demo07;
public class DemoInterface01 {
public static void main(String[] args) {
//使用匿名内部类
MyInterface obj = new MyInterface() {
@Override
public void method1() {
System.out.println("匿名类实现了方法111");
}
@Override
public void method2() {
System.out.println("匿名类实现了方法222");
}
};
obj.method1();
obj.method2();
//使用了匿名内部类,而且省略了对象名称,也是匿名对象
new MyInterface(){
@Override
public void method1() {
System.out.println("匿名类实现了方法AAA");
}
@Override
public void method2() {
System.out.println("匿名类实现了方法BBB");
}
}.method1();
// 因为匿名对象无法调用第二次方法,所以需要在创建一个匿名内部类对象
new MyInterface() {
@Override
public void method1() {
System.out.println("匿名类实现了方法AAA");
}
@Override
public void method2() {
System.out.println("匿名类实现了方法BBB");
}
}.method2();
}
}
引用类型用法总结
基本类型可以作为成员变量,作为方法的参数,作为方法的返回值,引用类型也是可以的
class作为成员变量
类作为成员变量时,对他进行赋值的操作,实际上是赋给他该类一个对象
interface作为成员变量
接口是对方法的封装,对应游戏当中,可以看作是扩展游戏角色的技能。所以,如果想扩展更强大技能,我们在Role 中,可以增加接口作为成员变量,来设置不同的技能。
我们使用一个接口,作为成员变量,以便随时更换技能,这样的设计更为灵活,增强了程序的扩展性。
接口作为成员变量时,对它进行赋值的操作,实际上,是赋给它该接口的一个子类对象。
package Demo07;
public class Role {
private int id;
private int blood;//生命值
private String name;
//添加武器属性
private Weapon wp;
private Armour ar;
private FaShuSkill fs;
public Role() {
}
public Role(int id, int blood, String name, Weapon wp, Armour ar,FaShuSkill fs) {
this.id = id;
this.blood = blood;
this.name = name;
this.wp = wp;
this.ar = ar;
this.fs = fs;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getBlood() {
return blood;
}
public void setBlood(int blood) {
this.blood = blood;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Weapon getWp() {
return wp;
}
public void setWp(Weapon wp) {
this.wp = wp;
}
public Armour getAr() {
return ar;
}
public void setAr(Armour ar) {
this.ar = ar;
}
public FaShuSkill getFs() { return fs; }
public void setFs(FaShuSkill fs) { this.fs = fs; }
//攻击方法
public void attack(){
System.out.println("使用"+wp.getName()+"造成"+wp.getHurt()+"点伤害");
}
//穿戴盔甲
public void wear(){
this.blood +=ar.getProtect();
System.out.println("穿上"+ar.getName()+",生命值增加"+ar.getProtect());
}
public void FaShuSkillAttack(){
System.out.print("发动法术攻击:");
fs.faShuAttack();
System.out.println("攻击完毕");
}
}
package Demo07;
public class DemoClassTest {
public static void main(String[] args) {
//创建Weapon对象
Weapon wp = new Weapon("屠龙刀",9999);
//创建Weapon对象
Armour ar = new Armour("麒麟甲",10000);
//创建Weapon对象
Role r = new Role();
r.setWp(wp);//设置武器属性
r.setAr(ar);//设置盔甲属性
r.attack();
r.wear();
r.setFs(new FaShuSkill() {
@Override
public void faShuAttack() {
System.out.println("逆转乾坤");
}
});
r.FaShuSkillAttack();
new FaShuSkill(){
@Override
public void faShuAttack() {
System.out.println("纵横天下");
}
}.faShuAttack();
r.FaShuSkillAttack();
}
}
interface作为方法参数和返回值类型
当接口作为方法的参数时,需要传递什么呢?当接口作为方法的返回值类型时,需要返回什么呢?对,其实都是它的子类对象。 ArrayList 类我们并不陌生,查看API我们发现,实际上,它是 java.util.List 接口的实现类。所以,当我们看见List 接口作为参数或者返回值类型时,当然可以将ArrayList 的对象进行传递或返回。
接口作为参数时,传递它的子类对象。
接口作为返回值类型时,返回它的子类对象。
package Demo07;
import java.util.ArrayList;
import java.util.List;
public class DemoInterfaceTest02 {
public static void main(String[] args) {
ArrayList<Integer> srcList = new ArrayList<>();
for (int i = 0; i < 10; i++) {
srcList.add(i);
}
List list = getEvenNum(srcList);
System.out.println(list);
}
public static List<Integer> getEvenNum(List<Integer> list){
ArrayList<Integer> evenList = new ArrayList<>();
for (int i = 0; i < list.size(); i++) {
Integer inter = list.get(i);
if (inter%2==0){
evenList.add(i);
}
}
return evenList;
}
}