Day10
第十六章 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 返回值类型 方法名称(参数列表){
//方法体
}
注意事项:
对于类、方法来说,abstract关键字和final关键字不能同时使用,因为矛盾。
*/
public class Fu {
public final void method(){
System.out.println("父类方法执行!");
}
}
public class Zi extends Fu {
/*
错误写法!不能覆盖重写父类当中final的方法
@Override
public void method() {
super.method();
}
*/
}
//修饰局部变量
public class Demo01Final {
public static void main(String[] args) {
int num1 = 10;
System.out.println(num1);
num1 = 20;
System.out.println(num1);
//一旦使用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中,可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。
- default (即默认,什么也不写): 在同一包内可见,不使用任何修饰符。使用对象:类、接口、变量、方法。
- private : 在同一类内可见。使用对象:变量、方法。 注意:不能修饰类(外部类)
- public : 对所有类可见。使用对象:类、接口、变量、方法
- protected : 对同一包内的类和所有子类可见。使用对象:变量、方法。 注意:不能修饰类(外部类)。
我们可以通过以下表来说明访问权限
修饰符 | 当前类 | 同一包内 | 子孙类(同一包) | 子孙类(不同包) | 其他包 |
---|---|---|---|---|---|
public | Y | Y | Y | Y | Y |
protected | Y | Y | Y | N | N |
default | Y | Y | Y | N | N |
private | Y | N | N | N | N |
默认访问修饰符-不使用任何关键字
使用默认访问修饰符声明的变量和方法,对同一个包内的类是可见的。接口里的变量都隐式声明为public static final,而接口里的方法默认情况下访问权限为 public。
第十八章 内部类
18.1 成员内部类
/*
如果一个事物的内部包含另一个事物,那么这就是一个类内部包含另一个类。
例如:身体和心脏的关系。又如:汽车和发动机的关系。
分类:
1.成员内部类
2.局部内部类(包含匿名内部类)
成员内部类的定义格式:
修饰符 class 外部类名称{
修饰符 class 内部类名称{
// ...
}
// ...
}
注意:内用外,随意访问;外用内,需要内部类对象。
==========================
如何使用成员内部类?有两种方式:
1. 间接方式:在外部类的方法当中,使用内部类;然后main只调用外部类的方法。
2. 直接方式,公式:
类名称 对象名 = new 类名称();
【外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();】
*/
public class Body {//外部类
private String name;
public Body(String name) {
this.name = name;
}
public Body() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//成员内部类
public class Heart{
//内部类的方法
public void beat(){
System.out.println("心脏跳动,蹦蹦蹦!");
System.out.println("我叫:" + name);//正确写法
}
}
//外部类的方法
public void methodBody(){
Heart heart = new Heart();
heart.beat();
}
}
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.外部类成员变量名
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);//外部类的成员变量
}
}
}
public class Demo02InnerClass {
public static void main(String[] args) {
Outer.Inner inner = new Outer().new Inner();
inner.methodInner();
}
}
18.2 局部内部类
/*
如果一个类是定义在一个方法内部的,那么这就是一个局部内部类。
“局部”。只有当前所属的方法才能使用它,出了这个方法外面就不能用了.
定义格式:
修饰符 class 外部类名称{
修饰符 返回值类型 外部类方法名称(参数列表){
class 局部内部类名称{
// ...
}
}
}
小结一下类的权限修饰符
public > protected > (default) > private
定义一个类的时候,权限修饰符规则:
1. 外部类:public/(default)
2. 成员内部类:public/protected/(default)/private
3. 局部内部类:什么都不能写
*/
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的。
备注:从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);
}
}
}
}
18.3 匿名内部类
/*
如果接口的实现类(或者是父类的子类)只需要使用唯一的一次,
那么这种情况下就可以省略掉该类的定义,而改为使用【匿名内部类】。
匿名内部类的定义格式:
接口名称 对象名 = new 接口名称(){
//覆盖重写所有抽象方法
};
对格式“new接口名称() {...}”进行解析:
1. new代表创建对象的动作
2.接口名称就是匿名内部类需要实现哪个接口
3. {...}这才是匿名内部类的内容
另外还要注意几点问题:
1.匿名内部类,在【创建对象】的时候,只能使用唯一一次。
如果希望多次创建对象,而且类的内容一样的话,那么就必须使用单独定义的实现类了。
2. 匿名对象,在【调用方法】的时候,只能调用唯一一次。
如果希望同一个对象,调用多次方法,那么必须给对象起个名字。
3. 匿名内部类是省略了【实现类/子类名称】,但是匿名对象是省略了【对象名称】
强调:匿名内部类和匿名对象不是一回事!!!
*/
public interface MyInterface {
public abstract void method();
}
public class DemoMain {
public static void main(String[] args) {
// MyInterfaceImpl imp = new MyInterfaceImpl();
// imp.method();
MyInterface obj = new MyInterfaceImpl();
obj.method();//实现类覆盖重写了方法!
MyInterface obj1 = new MyInterface() {
@Override
public void method() {
System.out.println("匿名内部类实现了方法!");
}
};
obj1.method();//匿名内部类实现了方法!
}
}