11-final;权限;内部类;引用类型

1. final关键字

final关键字代表最终、不可改变。

常见四种用法:

  1. 可以用来修饰一个类。
  2. 可以用来修饰一个方法。
  3. 还可以用来修饰一个局部变量。
  4. 还可以用来修饰一个成员变量。

1.1. final修饰类

final关键字用来修饰一个类的时候,格式:

public final class 类名称 {
    // ......
}

含义:当前这个类不能有任何的子类!(“太监类”—不能有任何子孙)

注意:一个类如果被final修饰,那么其中所有的成员方法都无法进行覆盖重写(因为没有子类)。

1.2. final修饰成员方法

final关键字用来修饰一个方法的时候,这个方法就是最终方法,也就是不能被覆盖重写!

格式:

修饰符 final 返回值类型 方法名称(参数列表) {
    // 方法体
}

注意事项:对于类、方法来说,abstractfinal关键字不能同时使用,因为矛盾!

1.3. final修饰局部变量

一旦使用final来修饰局部变量,那么这个局部变量就不可变。

什么叫“不可变”:

  1. 对于基本类型来说,不可变说的是变量当中的数据不可改变。
  2. 对于引用类型来说,不可变说的是变量当中的地址值不可改变。

1.4. final修饰成员变量

对于成员变量来说,如果使用final关键字修饰,那么这个变量也照样是不可变。

  1. 由于成员变量具有默认值,所以用了final修饰之后,必须手动赋值。
  2. 对于final修饰的成员变量,要么使用直接赋值,或者使用构造方法进行赋值。
  3. 必须保证类当中所有的构造方法,都最终会对final的成员变量进行赋值。

2. 四种权限修饰符

Java中有四种权限修饰符:public > protected > (default) > private

public protected (default) private
同一个类(我自己) yes yes yes yes
同一个包(我邻居) yes yes yes no
不同包但是是子类(我儿子) yes yes no no
不同包且非子类(陌生人) yes no no no

注意事项:(default)并不是关键字,是可以省略不写的。

3. 内部类

如果一个事物的内部包含另一个事物,那么这就是一个类内部包含另一个类。

例如:身体和心脏的关系、汽车和发动机的关系。

分类:

  1. 成员内部类。
  2. 局部内部类(匿名内部类)

3.1. 成员内部类

格式:

修饰符 class 类名称 {
    修饰符 class 类名称 {
        // 方法体
    }
    // 方法体
}

注意:内用外:可以随意访问;外用内:需要借助内部类对象。

使用成员内部类:

  1. 间接方式:在外部类方法当中,使用内部类‘然后main只是调用外部类的方法。
  2. 直接方式:公式:外部类名称 对象名 = new 外部类名称().new 内部类名称();

创建Body类:

package cn.itcast.demo03;

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;
    }
}

创建主方法:

package cn.itcast.demo03;

public class Demo01InnerClass {
    public static void main(String[] args) {
        // 1. 间接访问:
        Body body = new Body(); // 外部类的对象
        // 通过外部类的对象,调用外部类的方法,里面间接使用内部类Heart:
        body.methodBody();
        System.out.println("=================");

        // 2. 直接访问:
        Body.Heart heart = new Body().new Heart();
        heart.beat();
    }
}
/* 输出结果:
外部类的方法
心脏跳动,蹦蹦蹦
我叫:null
=================
心脏跳动,蹦蹦蹦
我叫:null
*/

以下两张图:创建完内部类,点击Recomplie Body.java,在项目中目录就可以看到文件Body $ Heart.class,$代表内部类的意思。

在这里插入图片描述

在这里插入图片描述

3.2. 内部类的同名变量访问

如果出现了重名现象,格式:

外部类名称.this.外部类成员变量名

定义Outer类:

package cn.itcast.demo03;

public class Outer {

    int num = 10; // 外部类的成员变量

    public class Inner {

        int mum = 20; // 内部类的成员变量

        public void methodInner() {
            int num = 30; // 内部类方法的局部变量
            System.out.println(num); // 局部变量,就近原则
            System.out.println(this.mum); // 内部类的成员变量
            System.out.println(Outer.this.num); // 外部类的成员变量
        }
    }
}

主方法:

package cn.itcast.demo03;

public class Demo02InnerClass {
    public static void main(String[] args) {
        Outer.Inner obj = new Outer().new Inner();
        obj.methodInner();
    }
}
/* 输出结果:
30
20
10
*/

3.3. 局部内部类

如果一个类是定义在一个方法内部的,那么这就是一个局部内部类。

什么叫局部:只有当前所属的方法才能使用它,出了这个方法外面就不能用了。

格式:

修饰符 class 外部类名称 {
    修饰符 返回值类型 外部类方法名称(参数列表) {
        class 局部类名称 {
            // ......
        }
    }
}

总结一下类的修饰符:public > protected > (default) > private;定义一个类的时候,权限修饰符的使用规则:

  1. 外部类:public / (default)
  2. 成员内部类:public / protected / (default) / private
  3. 局部外部类:什么都不写

定义Outer类:

package cn.itcast.demo04;

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();
    }
}

主方法:

package cn.itcast.demo04;

public class DemoMain {
    public static void main(String[] args) {
        Outer obj = new Outer();
        obj.methodOuter();
    }
}

3.4. 局部内部类的final问题

局部内部类,如果希望访问所在方法的局部变量,那么这个局部变量必须是【有效final的】。

备注:从Java 8+开始,只要局部变量事实不变,那么final关键字可以省略。

原因:

  1. new出来的对象再堆内存中。
  2. 局部变量是跟着方法走的没在栈内存中。
  3. 方法运行结束之后,立刻出栈,局部变量就会立刻消失。
  4. new出来的对象会在堆当中持续存在,直到垃圾回收。

定义MyOuter类:

package cn.itcast.demo04;

public class MyOuter {

    public void methodOuter() {
        int num = 10; // 所在方法的局部变量
//        final int num = 10; // 只要局部变量事实不变,那么final关键字可以省略

        class MyInner {
            public void methodInner() {
                System.out.println(num);
            }
        }
    }
}

3.5. 匿名内部类【今天最重要!】

如果接口的实现类,或者是父类的子类,只要使用唯一的一次,那么这种情况下,就可以省略该类的定义,而改为使用【匿名内部类】。

匿名内部类定义格式:

接口名称 对象名 = new 几口名称() {
    // 覆盖重写所有的抽象方法
};

好处:不需要单独定义实现类了!

注意事项:

  1. 对格式"new 接口名() {…}"进行解析:

    1. new代表船舰对象的动作。
    2. 接口名称就是匿名内部类需要实现哪个接口
    3. {…}这才是匿名内部类的内容
  2. 匿名内部类再创建对象时候只能使用唯一一次。如果希望多次创建对象,而且类的内容一样,那么就必须使用单独定义的实现类了。

  3. 匿名对象,【在调用方法】的时候只能调用唯一一次,如果希望同一个对象,调用多次方法,那么必须给对象起名字。

  4. 匿名内部类是省略了【实现类或者是子类】,但是匿名对象是省略了【对象名称】。

    强调:匿名内部类和匿名对象不是一回事!!!

定义接口MyInterface:

package cn.itcast.demo05;

public interface MyInterface {

    void method1(); // 抽象方法

    void method2();
}

主方法:

package cn.itcast.demo05;

public class DemoMain {
    public static void main(String[] args) {
        // 1. 使用普通方法:
//        MyInterface impl = new MyInterfaceImpl();
//        impl.method1();

        // 2. 使用匿名内部类:这样就不需要定义MyInterfaceImpl实现类了!
        // 使用的是匿名内部类,但不是匿名对象,对象名称就叫objA:
        MyInterface objA = new MyInterface() {
            @Override
            public void method1() {
                System.out.println("匿名内部类实现了方法!111-A");
            }
            @Override
            public void method2() {
                System.out.println("匿名内部类实现了方法!222-A");
            }
        };
        objA.method1();
        objA.method2();
        System.out.println("================");

        // 使用了匿名内部类,而且省略了对象名称,也是匿名对象:
        new MyInterface() {
            @Override
            public void method1() {
                System.out.println("匿名内部类实现了方法!111-B");
            }
            @Override
            public void method2() {
                System.out.println("匿名内部类实现了方法!222-B");
            }
        }.method1();
        // 因为匿名对象无法调用第二次方法,所以需要再创建一个匿名内部类的匿名对象:
        new MyInterface() {
            @Override
            public void method1() {
                System.out.println("匿名内部类实现了方法!111-B");
            }
            @Override
            public void method2() {
                System.out.println("匿名内部类实现了方法!222-B");
            }
        }.method2();
    }
}
/* 输出结果:
匿名内部类实现了方法!111-A
匿名内部类实现了方法!222-A
================
匿名内部类实现了方法!111-B
匿名内部类实现了方法!222-B
*/

3.6. 类作为成员变量类型

定义Hero类:

package cn.itcast.demo06;

// 游戏中的英雄角色类:
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() {
        // 注意这里weapon是对象
        System.out.println("年龄为" + age + "的" + name + "用" + weapon.getCode() + "攻击敌人");
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public Weapon getWeapon() {
        return weapon;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setWeapon(Weapon weapon) {
        this.weapon = weapon;
    }
}

定义Weapon类:

package cn.itcast.demo06;

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;
    }
}

主方法:

package cn.itcast.demo06;

public class DemoMain {
    public static void main(String[] args) {
        // 创建一个英雄角色:
        Hero hero = new Hero();
        // 为英雄起个名字,并且设置年龄:
        hero.setName("盖伦");
        hero.setAge(20);

        // 创建一个武器对象:
        Weapon weapon = new Weapon("多兰剑");
        // 为英雄配备武器:
        hero.setWeapon(weapon);

        hero.attack();
    }
}

3.7. 几口作为成员变量类型

定义Hero类:

package cn.itcast.demo07;

public class Hero {
    private String name; // 英雄名称
    private Skill skill; // 英雄技能

    public Hero() {
    }

    public Hero(String name, Skill skill) {
        this.name = name;
        this.skill = skill;
    }

    public void attack() {
        System.out.println("我叫" + name + "开始施放技能:");
        skill.use(); // 调用接口中的抽象方法
    }

    public String getName() {
        return name;
    }

    public Skill getSkill() {
        return skill;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setSkill(Skill skill) {
        this.skill = skill;
    }
}

定义Skill接口:

package cn.itcast.demo07;

public interface Skill {
    void use(); // 释放技能的抽象方法
}

定义SkillImpl实现类:

package cn.itcast.demo07;

public class SkillImpl implements Skill{

    @Override
    public void use() {
        System.out.println("Biu-Biu-Biu");
    }
}

主方法:

package cn.itcast.demo07;

public class DemoMain {
    public static void main(String[] args) {
        Hero hero = new Hero();
        hero.setName("艾希射手");

        // 1. 使用当单独定义的实现类:
//        hero.setSkill(new SkillImpl());

        // 2. 还可以改成使用匿名内部类:
//        Skill skill = new Skill() {
//            @Override
//            public void use() {
//                System.out.println("Pai-Pai-Pia");
//            }
//        };
//        hero.setSkill(skill);

        // 3. 进一步简化,同时使用匿名内部类和匿名对象:
        hero.setSkill(new Skill() {
            @Override
            public void use() {
                System.out.println("Biu-Pia-Biu-Pia");
            }
        });
        hero.attack();
    }
}
/* 输出结果:
我叫艾希射手开始施放技能:
Biu-Pia-Biu-Pia
*/

3.8. 接口作为方法的参数和返回值

java.util.List正式ArrayList所实现的接口。

package cn.itcast.demo07;

import java.util.ArrayList;
import java.util.List;

public class DemoInterface {
    public static void main(String[] args) {
        // 左边是接口名称,右边是实现类名称,这就是多态写法:
        List<String> list = new ArrayList<>();

        List<String> result = addName(list);
        for (int i = 0; i < result.size(); i++) {
            System.out.println(result.get(i));
        }
    }

    // 讲接口List作为返回值:
    public static List<String> addName(List<String> list) {
        list.add("迪丽热巴");
        list.add("古力娜扎");
        list.add("马儿扎哈");
        list.add("沙扬娜拉");
        return list;
    }
}
/* 输出结果:
迪丽热巴
古力娜扎
马儿扎哈
沙扬娜拉
*/

4. 发红包案例

展开阅读全文
©️2019 CSDN 皮肤主题: 大白 设计师: CSDN官方博客
应支付0元
点击重新获取
扫码支付

支付成功即可阅读