java——final关键字、权限、内部类、引用类型

final关键字代表最终、不可改变的。常见四种用法：
1. 可以用来修饰一个类
2. 可以用来修饰一个方法
3. 还可以用来修饰一个局部变量
4. 还可以用来修饰一个成员变量

当final关键字用来修饰一个类的时候，格式：
public final class 类名称 {// ...
}含义：当前这个类不能有任何的子类。（太监类）
注意：一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写（因为没儿子。）

public final class MyClass /*extends Object*/ {public void method() {System.out.println("方法执行！");}}

// 不能使用一个final类来作为父类

// 不能使用一个final类来作为父类
public class MySubClass /*extends MyClass*/ {
}

当final关键字用来修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写。
格式：
修饰符 final 返回值类型 方法名称(参数列表) {// 方法体
}注意事项：
对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾。

public abstract class Fu {public final void method() {System.out.println("父类方法执行！");}public abstract /*final*/ void methodAbs() ;}

public class Zi extends Fu {@Overridepublic void methodAbs() {}// 错误写法！不能覆盖重写父类当中final的方法
//    @Override
//    public void method() {
//        System.out.println("子类覆盖重写父类的方法！");
//    }
}

修饰一个局部变量

public class Student {private String name;public Student() {}public Student(String name) {this.name = name;}public String getName() {return name;}public void setName(String name) {this.name = name;}
}

public class Demo01Final {public static void main(String[] args) {int num1 = 10;System.out.println(num1); // 10num1 = 20;System.out.println(num1); // 20// 一旦使用final用来修饰局部变量，那么这个变量就不能进行更改。// “一次赋值，终生不变”final int num2 = 200;System.out.println(num2); // 200//        num2 = 250; // 错误写法！不能改变！
//        num2 = 200; // 错误写法！// 正确写法！只要保证有唯一一次赋值即可final int num3;num3 = 30;// 对于基本类型来说，不可变说的是变量当中的数据不可改变// 对于引用类型来说，不可变说的是变量当中的地址值不可改变Student stu1 = new Student("赵丽颖");System.out.println(stu1);System.out.println(stu1.getName()); // 赵丽颖stu1 = new Student("霍建华");System.out.println(stu1);System.out.println(stu1.getName()); // 霍建华System.out.println("===============");final Student stu2 = new Student("高圆圆");// 错误写法！final的引用类型变量，其中的地址不可改变
//        stu2 = new Student("赵又廷");System.out.println(stu2.getName()); // 高圆圆stu2.setName("高圆圆圆圆圆圆");System.out.println(stu2.getName()); // 高圆圆圆圆圆圆}}

对于成员变量来说，如果使用final关键字修饰，那么这个变量也照样是不可变。1. 由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值了。
2. 对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值。二者选其一。
3. 必须保证类当中所有重载的构造方法，都最终会对final的成员变量进行赋值。

public class Person {private final String name/* = "鹿晗"*/;public Person() {name = "关晓彤";}public Person(String name) {this.name = name;}public String getName() {return name;}//    public void setName(String name) {
//        this.name = name;
//    }
}

权限修饰符

Java中有四种权限修饰符：public  >   protected   >   (default)   >   private
同一个类（我自己）          YES         YES             YES             YES
同一个包（我邻居）          YES         YES             YES             NO
不同包子类（我儿子）        YES         YES             NO              NO
不同包非子类（陌生人）      YES         NO              NO              NO注意事项：(default)并不是关键字“default”，而是根本不写。

public class MyClass {public int num = 10;public void method() {System.out.println(num);}}

public class MyAnother {public void anotherMethod() {System.out.println(new MyClass().num);}}

不同包

import day11.demo02.MyClass;public class MySon extends MyClass {public void methodSon() {System.out.println(super.num);}}

import day11.demo02.MyClass;public class Stranger {public void methodStrange() {System.out.println(new MyClass().num);}}

内部类

如果一个事物的内部包含另一个事物，那么这就是一个类内部包含另一个类。
例如：身体和心脏的关系。又如：汽车和发动机的关系。分类：
1. 成员内部类
2. 局部内部类（包含匿名内部类）成员内部类的定义格式：
修饰符 class 外部类名称 {修饰符 class 内部类名称 {// ...}// ...
}注意：内用外，随意访问；外用内，需要内部类对象。==========================
如何使用成员内部类？有两种方式：
1. 间接方式：在外部类的方法当中，使用内部类；然后main只是调用外部类的方法。
2. 直接方式，公式：
类名称 对象名 = 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(); // 外部类的对象// 通过外部类的对象，调用外部类的方法，里面间接在使用内部类Heartbody.methodBody();System.out.println("=====================");// 按照公式写：Body.Heart heart = new Body().new Heart();heart.beat();}}

// 如果出现了重名现象，那么格式是：外部类名称.this.外部类成员变量名

public class Outer {int num = 10; // 外部类的成员变量public class Inner /*extends Object*/ {int num = 20; // 内部类的成员变量public void methodInner() {int num = 30; // 内部类方法的局部变量System.out.println(num); // 局部变量，就近原则System.out.println(this.num); // 内部类的成员变量System.out.println(Outer.this.num); // 外部类的成员变量}}
}

public class Demo02InnerClass {public static void main(String[] args) {// 外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();Outer.Inner obj = new Outer().new Inner();obj.methodInner();}
}

如果一个类是定义在一个方法内部的，那么这就是一个局部内部类。
“局部”：只有当前所属的方法才能使用它，出了这个方法外面就不能用了。定义格式：
修饰符 class 外部类名称 {修饰符 返回值类型 外部类方法名称(参数列表) {class 局部内部类名称 {// ...}}
}类的权限修饰符：
public > protected > (default) > private
定义一个类的时候，权限修饰符规则：
1. 外部类：public / (default)
2. 成员内部类：public / protected / (default) / private
3. 局部内部类：什么都不能写

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 obj = new Outer();obj.methodOuter();}}

局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效final的】。备注：从Java 8+开始，只要局部变量事实不变，那么final关键字可以省略。原因：
1. new出来的对象在堆内存当中。
2. 局部变量是跟着方法走的，在栈内存当中。
3. 方法运行结束之后，立刻出栈，局部变量就会立刻消失。
4. 但是new出来的对象会在堆当中持续存在，直到垃圾回收消失。

public class MyOuter {public void methodOuter() {int num = 10; // 所在方法的局部变量class MyInner {public void methodInner() {System.out.println(num);}}}}

如果接口的实现类（或者是父类的子类）只需要使用唯一的一次，
那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】。匿名内部类的定义格式：
接口名称 对象名 = new 接口名称() {// 覆盖重写所有抽象方法
};

public interface MyInterface {void method1(); // 抽象方法void method2();}

// 这个就可以不用了
public class MyInterfaceImpl implements MyInterface {@Overridepublic void method1() {System.out.println("实现类覆盖重写了方法！111");}@Overridepublic void method2() {System.out.println("实现类覆盖重写了方法！222");}
}

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

public class DemoMain {public static void main(String[] args) {
//        MyInterface obj = new MyInterfaceImpl();
//        obj.method();//        MyInterface some = new MyInterface(); // 错误写法！// 使用匿名内部类，但不是匿名对象，对象名称就叫objAMyInterface objA = new MyInterface() {@Overridepublic void method1() {System.out.println("匿名内部类实现了方法！111-A");}@Overridepublic void method2() {System.out.println("匿名内部类实现了方法！222-A");}};objA.method1();objA.method2();System.out.println("=================");// 使用了匿名内部类，而且省略了对象名称，也是匿名对象new MyInterface() {@Overridepublic void method1() {System.out.println("匿名内部类实现了方法！111-B");}@Overridepublic void method2() {System.out.println("匿名内部类实现了方法！222-B");}}.method1();// 因为匿名对象无法调用第二次方法，所以需要再创建一个匿名内部类的匿名对象new MyInterface() {@Overridepublic void method1() {System.out.println("匿名内部类实现了方法！111-B");}@Overridepublic void method2() {System.out.println("匿名内部类实现了方法！222-B");}}.method2();}}

类作为成员变量

// 游戏当中的英雄角色类
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 hero = new Hero();// 为英雄起一个名字，并且设置年龄hero.setName("盖伦");hero.setAge(20);// 创建一个武器对象Weapon weapon = new Weapon("多兰剑");// 为英雄配备武器hero.setWeapon(weapon);// 年龄为20的盖伦用多兰剑攻击敌方。hero.attack();}}

接口为成员变量

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

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 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("Pia~pia~pia~");
//            }
//        };
//        hero.setSkill(skill);// 进一步简化，同时使用匿名内部类和匿名对象hero.setSkill(new Skill() {@Overridepublic void use() {System.out.println("Biu~Pia~Biu~Pia~");}});hero.attack();}}

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

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 = addNames(list);for (int i = 0; i < result.size(); i++) {System.out.println(result.get(i));}}public static List<String> addNames(List<String> list) {list.add("迪丽热巴");list.add("古力娜扎");list.add("玛尔扎哈");list.add("沙扬娜拉");return list;}}

发红包案例

场景说明：红包发出去之后，所有人都有红包，大家抢完了之后，最后一个红包给群主自己。
大多数代码都是现成的，我们需要做的就是填空题。
我们自己要做的事情有：1. 设置一下程序的标题，通过构造方法的字符串参数2. 设置群主名称3. 设置分发策略：平均，还是随机？红包分发的策略：1. 普通红包（平均）：totalMoney / totalCount，余数放在最后一个红包当中。2. 手气红包（随机）：最少1分钱，最多不超过平均数的2倍。应该越发越少。

import java.util.ArrayList;public interface OpenMode {/*** 请将totalMoney分成count份，保存到ArrayList<Integer>中，返回即可。** @param totalMoney            总金额为方便计算，已经转换为整数，单位为分。* @param totalCount            红包个数* @return ArrayList<Integer> 元素为各个红包的金额值，所有元素的值累和等于总金额。*/ArrayList<Integer> divide(int totalMoney, int totalCount);
}

RedPacketFrame 文件包

public class MyRed extends RedPacketFrame {/*** 构造方法：生成红包界面。** @param title 界面的标题*/public MyRed(String title) {super(title);}
}

import day11.red.OpenMode;import java.util.ArrayList;public class NormalMode implements OpenMode {@Overridepublic 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 day11.red.OpenMode;import java.util.ArrayList;
import java.util.Random;public class RandomMode implements OpenMode {@Overridepublic ArrayList<Integer> divide(final int totalMoney, final int totalCount) {ArrayList<Integer> list = new ArrayList<>();// 随机分配，有可能多，有可能少。// 最少1分钱，最多不超过“剩下金额平均数的2倍”// 第一次发红包，随机范围是0.01元~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;}
}

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

java——final关键字、权限、内部类、引用类型相关推荐

Java学习笔记⑩（final关键字、内部类）
一.final关键字 final关键字代表最终.不可改变的. 常用的四种方法: 可以用来修饰一个类可以用来修饰一个方法还可以用来修饰一个局部变量还可以用来修饰一个成员变量不能使用一个final ...
3.4—4 Java final关键字、接口、数组
文章目录一.final 关键字 final修饰属性.方法.类二.接口 (interface. implement) 1.什么是接口? 1)生活中的接口----USB接口 2)面向接口编程 3)接口 ...
Java——final关键字，String为什么不可变
目录 final是什么? 一.修饰类二.修饰变量三.修饰方法 String为什么不可变? 不知道大家有没有这样的疑问:我们在使用某些Java的类或者方法.属性(比如:String类)时,总是会发现 ...
方法对象java final关键字的用法
之前一直在查找方法对象之类的问题,今天正好有机会和大家讨论一下. 1.用final关键字设置常数很多程序设计语言都有自己的方法告知编译器某个数据是"常数".常数重要应用于下述两个 ...
java final关键字_终于明白 Java 为什么要加 final 关键字了！
在开发过程中,由于习惯的原因,我们可能对某种编程语言的一些特性习以为常,特别是只用一种语言作为日常开发的情况.但是当你使用超过一种语言进行开发的时候就会发现,虽然都是高级语言,但是它们之间很多特性都是 ...
Java final关键字的使用和优点
使用: final关键字可以用于成员变量.本地变量.方法以及类. final成员变量必须在声明的时候初始化或者在构造器中初始化,否则就会报编译错误. 你不能够对final变量再次赋值. 本地变量必须在 ...
java final 关键字
java的final关键字前言 final是最终的意思. 在java这门编程语言中,final是一个关键字,它可以被用来修饰类,变量以及成员方法. 被final修饰的变量,又叫被称为自定义常量 ...
Java final关键字修饰变量Test
使用 final 关键字修饰一个变量时,是指引用变量不能变,引用变量所指向的对象中的内容还是可以改变的. package com.test; /*** final修饰一个变量练习* @author M ...
Java final 关键字简述
final 关键字简述 final:最终 1.final 修饰类 final 修饰的类不能被继承 /*** final修饰的类不能被继承* @author **/ public final clas ...

java——final关键字、权限、内部类、引用类型

内部类

java——final关键字、权限、内部类、引用类型相关推荐

最新文章

热门文章