A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

[我的日记] 【成都校区】

© 呵呵呵呵呵233 初级黑马   /  2018-11-29 14:08  /  675 人查看  /  0 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

final关键字的四种用法
1,        final修饰类
a)        定义位置,final修饰类定义在class前
b)        public final calss Demo{}
c)        特点:不能被子类继承,是一个太监类,但是可以去继承别的类也可以去覆盖重写它父类的方法。
2,        final修饰成员方法
a)        当final修饰一个方法的时候,这个方法就是最终的方法,不可以被覆盖重写
b)        格式:
修饰符 final 返回值类型 方法名(参数列表){
//方法体
}
3,        final修饰局部变量
a)        一但用final修饰局部变量,那么这个变量就不能进行更改
b)        final int num = 10;一次赋值终生不变
c)        final int num1;
d)        num1 = 20;只要保证有唯一一次赋值即可;
e)        如果final修饰一个引用类型来说
i.        比如:final Student stu = new Student(“高圆圆”);
ii.           stu  = new Student (“霍建华”);//错误写法
iii.           stu.setName(“赵又廷”);//
4,        final修饰成员变量
a)        由于成员变量有默认值
b)        对于final的成员变量,要么使用直接赋值,要么通过构造方法赋值,二者选其一



Java中有四种权限修饰符:
                    public  >   protected   >   (default)   >   private
同一个类(我自己)        YES         YES             YES             YES
同一个包(我邻居)        YES         YES             YES             NO
不同包子类(我儿子)       YES         YES             NO              NO
不同包非子类(陌生人)      YES         NO              NO              NO

注意事项:(default)并不是关键字“default”,而是根本不写。




内部类
        分类:
1,        成员内部类
2,        局部内部类(包括匿名内部类)

1,        成员内部类
a)        格式
修饰符 class 外部类名称 {
修饰符 class 内部类名称
}
                        注意:内用外,随意访问,外用内 需要内部类的对象
                        使用方式:
1,        间接的方式:在外部类的方法中,使用内部类,然后main方法只是调用外部类的方法
2,        直接的方式:
a)        类名称 对象名 = new 类名称
b)        外部类.内部类 对象名 = new 外部类名称().new 内部类名称  ();
c)        Wai.Nei wn = new Wai().new Nei();

局部内部类
        定义位置:在外部类中的方法中定义的类是局部内部类
        调用方式,只能通过方法间接的去调用局部内部类

                Class Demo{
                        Public void method(){
                                Class Inner{
                                        Public void method(){
                                                int num = 10;
                                                num = 20;
                                                System.out.println(“成员内部类中的方法执行了”);
}
}
                                        Inner in = new Inner();
                                        In.method();
}
}


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

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

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

如果一个类是定义在一个方法内部的,那么这就是一个局部内部类。
“局部”:只有当前所属的方法才能使用它,出了这个方法外面就不能用了。

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

小节一下类的权限修饰符:
public > protected > (default) > private
定义一个类的时候,权限修饰符规则:
1. 外部类:public / (default)
2. 成员内部类:public / protected / (default) / private
3. 局部内部类:什么都不能写


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

匿名内部类的定义格式:
接口名称 对象名 = new 接口名称() {
    // 覆盖重写所有抽象方法
};

对格式“new 接口名称() {...}”进行解析:
1. new代表创建对象的动作
2. 接口名称就是匿名内部类需要实现哪个接口
3. {...}这才是匿名内部类的内容
new MyInterface(){
public void method(){
        System.out.println(“111”);
}
}.method();
另外还要注意几点问题:
1. 匿名内部类,在【创建对象】的时候,只能使用唯一一次。
如果希望多次创建对象,而且类的内容一样的话,那么就需要使用单独定义的实现类了。
2. 匿名对象,在【调用方法】的时候,只能调用唯一一次。
如果希望同一个对象,调用多次方法,那么必须给对象起个名字。
3. 匿名内部类是省略了【实现类/子类名称】,但是匿名对象是省略了【对象名称】
强调:匿名内部类和匿名对象不是一回事!!!



一个类作为一个成员变量
        // 游戏当中的英雄角色类
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() + "攻击敌方。");
    }
//省略了get和set方法
    }
}

        如何去使用类作为成员变量
        public class DemoMain {

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

        // 创建一个武器对象
        Weapon weapon = new Weapon("AK-47");
        // 为英雄配备武器
        hero.setWeapon(weapon);

        // 年龄为20的盖伦用多兰剑攻击敌方。
        hero.attack();
    }

}
一个接口作为一个类的成员变量
        接口不能直接创建它的对象可以用实现类和匿名内部类
        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(); // 调用接口中的抽象方法
        System.out.println("施放技能完成。");
    }

具体实现的效果
        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("Pia~pia~pia~");
//            }
//        };
//        hero.setSkill(skill);

        // 进一步简化,同时使用匿名内部类和匿名对象
        hero.setSkill(new Skill() {
            @Override
            public void use() {
                System.out.println("Biu~Pia~Biu~Pia~");
            }
        });

        hero.attack();
    }

}









0 个回复

您需要登录后才可以回帖 登录 | 加入黑马