java学习笔记(10) 第10 章(上) - 面向对象编程(高级部分)
第10 章 - 面向对象编程-高级部分-上
- 10.1 类变量和类方法
- 10.1.1 类变量-提出问题-传统方法解决
- 10.1.2 类变量快速入门
- 10.1.3 类变量内存布局
- 10.1.4 类变量的概念、定义语法、如何访问
- 10.1.5 类变量使用注意事项和细节讨论
- 10.1.6 类方法基本介绍、类方法的调用、案例演示、经典使用场景
- 10.1.7 类方法使用注意事项和细节讨论
- 10.1.8 课堂练习 StaticExercise01.java
- 10.2 理解main 方法语法
- 10.2.1 深入理解main 方法
- 10.2.2 特别提示:
- 10.2.3 案例演示-main传参
- 10.3 代码块
- 10.3.1 基本介绍、基本语法
- 10.3.2 代码块的好处和案例演示
- 10.3.3 代码块使用注意事项和细节讨论
- 10.3.4 课堂练习题
- 10.4 单例设计模式
- 10.4.1 什么是设计模式
- 10.4.2 什么是单例模式
- 10.4.3 单例模式应用实例
- 10.4.4 饿汉式VS 懒汉式
- 10.5 final 关键字
- 10.5.1 基本介绍
- 10.5.2 final 使用注意事项和细节讨论
- 10.5.3 final 应用实例
10.1 类变量和类方法
10.1.1 类变量-提出问题-传统方法解决
提出问题
说:有一群小孩在玩堆雪人,不时有新的小孩加入,请问如何知道现在共有多少人在玩?,编写程序解决。传统的方法来解决
使用我们现有的技术来解决这个问题,大家看看如何?com.hspedu.static_.ChildGame.java
思路:
1.在main方法中定义一个变量 count
2.当一个小孩加入游戏后count++,最后个count 就记录有多少小孩玩游戏
问题分析:
1.count是一个独立于对象,很尴尬
2.以后我们访问count很麻烦,没有使用到OOP
3.因此,我们引出类变量/静态变量
传统方法代码:
public class LianXi {public static void main(String[] args) {//定义一个变量 count, 统计有多少小孩加入了游戏int count = 0;Child child1 = new Child("白骨精");child1.join();count++;Child child2 = new Child("狐狸精");child2.join();count++;Child child3 = new Child("老鼠精");child3.join();count++;System.out.println("共有" + count + " 个小孩加入了游戏...");}}class Child { //类private String name;//定义一个变量 count ,是一个类变量(静态变量) static 静态//该变量最大的特点就是会被Child 类的所有的对象实例共享// public static int count = 0;public Child(String name) {this.name = name;}public void join() {System.out.println(name + " 加入了游戏.."); }}
10.1.2 类变量快速入门
思考: 如果,设计一个int count 表示总人数,我们在创建一个小孩时,就把count 加1,并且count 是所有对象共享的就ok 了!,我们使用类变量来解决
改进代码:
public class ChildGame {public static void main(String[] args) {//定义一个变量 count, 统计有多少小孩加入了游戏int count = 0;Child child1 = new Child("白骨精");child1.join();//count++;child1.count++;Child child2 = new Child("狐狸精");child2.join();//count++;child2.count++;Child child3 = new Child("老鼠精");child3.join();//count++;child3.count++;//===========//类变量,可以通过类名来访问System.out.println("共有" + Child.count + " 小孩加入了游戏...");//下面的代码输出什么?System.out.println("child1.count=" + child1.count);//3System.out.println("child2.count=" + child2.count);//3System.out.println("child3.count=" + child3.count);//3}
}class Child { //类private String name;//定义一个变量 count ,是一个类变量(静态变量) static 静态//该变量最大的特点就是会被Child 类的所有的对象实例共享public static int count = 0;public Child(String name) {this.name = name;}public void join() {System.out.println(name + " 加入了游戏..");}
}
10.1.3 类变量内存布局
- 类变量在哪里?
参考文章1:https://blog.csdn.net/x iya/article/details/81260154/可以看到 static 变量保存在 Class 实例的尾部。Class 对象确实在堆中。
参考文章2:https://www.zhihu.com/question/59174759/answer/163207831结论:JDK7以上版本,静态域存储于定义类型的Class对象中,Class对象如同堆中其他对象一样,存在于GC堆中。
有些书说在方法区…, 与jdk 版本有关系,记住一点:static变量是对象共享
不管static变量在哪里,共识
(1) static变量是同一个类所有对象共享(2) static类变量,在类加载的时候就生成了.
10.1.4 类变量的概念、定义语法、如何访问
- 1.类变量的概念
类变量也叫静态变量/静态属性,是该类的所有对象共享的变量,任何一个该类的对象去访问它时,取到的都是相同的值,同样任何一个该类的对象去修改它时,修改的也是同一个变量。这个从前面的图也可看出来。
2.如何定义类变量
定义语法:
访问修饰符 static 数据类型 变量名;[推荐用这个定义]
static 访问修饰符 数据类型 变量名;3.如何访问类变量VisitStatic.java
类名.类变量名
或者 对象名.类变量名【静态变量的访问修饰符的访问权限和范围和普通属性是一样的。】
推荐使用:类名.类变量名;
代码演示
public class VisitStatic {public static void main(String[] args) {//类名.类变量名//说明:类变量是随着类的加载而创建,所以即使没有创建对象实例也可以访问System.out.println(A.name);A a = new A();//通过对象名.类变量名System.out.println("a.name=" + a.name);}
}class A {//类变量//类变量的访问,必须遵守 相关的访问权限.public static String name = "Java教育"; //public改成private上边就报错了,private只能在本类使用//普通属性/普通成员变量/非静态属性/非静态成员变量/实例变量private int num = 10;
}
注意:如果A类public改成private上边就报错了,private只能在本类使用
10.1.5 类变量使用注意事项和细节讨论
StaticDetail.java
- 什么时候需要用类变量?
当我们需要让某个类的所有对象都共享一个变量时,就可以考虑使用类变量(静态变量):比如:定义学生类,统计所有学生共交多少钱。Student (name,staticfee) - 类变量与实例变量(普通属性)区别
类变量是该类的所有对象共享的,而实例变量是每个对象独享的。 - 加上static称为类变量或静态变量,否则称为实例变量/普通变量/非静态变量
- 类变量可以通过 类名.类变量名 或 对象名.类变量名 来访问,但java设计者推荐我们使用 类名.类变量名 方式访问。【前提是满足访问修饰符的访问权限和范围】
- 实例变量不能通过 类名.类变量名 方式访问。
- 类变量是在类加载时就初始化了,也就是说,即使你没有创建对象,只要类加载了,就可以使用类变量了。[案例演示]
- 类变量的生命周期是随类的加载开始,随着类消亡而销毁。
代码:
public class StaticDetail {public static void main(String[] args) {B b = new B();//System.out.println(B.n1); //n1是实例变量,不是静态变量System.out.println(B.n2); //n2是静态的,可以访问//静态变量是类加载的时候,就创建了,所以我们没有创建对象实例//也可以通过类名.类变量名来访问System.out.println(C.address);}
}class B {public int n1 = 100;public static int n2 = 200;
}class C {public static String address = "北京";
}
10.1.6 类方法基本介绍、类方法的调用、案例演示、经典使用场景
基本介绍
类方法也叫静态方法。形式如下:
访问修饰符 static 数据返回类型 方法名 ( )【推荐】
static 访问修饰符 数据返回类型 方法名 ( )类方法的调用
使用方式: 类名.类方法名 或者 对象名.类方法名【前提是满足访问修饰符的访问权限和范围】方法应用案例 StaticMethod.java
学生交学费的应用案例类方法经典的使用场景
当方法中不涉及到任何和对象相关的成员,则可以将方法设计成静态方法,提高开发效率
比如:工具类中的方法utils
Math类、Arrays类、Collections集合类看下源码:小结
在程序员实际开发,往往会将一些通用的方法,设计成静态方法,这样我们不需要创建对象就可以使用了,比如打印一维数组,冒泡排序,完成某个计算任务等…
public class StaticMethod {public static void main(String[] args) {//创建2个学生对象,交学费Stu tom = new Stu("tom");//tom.payFee(100); //对象名.类方法名 调用Stu.payFee(100);//类名.类方法名 调用,对不对?对Stu mary = new Stu("mary");//mary.payFee(200);Stu.payFee(200);//对//输出当前收到的总学费Stu.showFee();//300//如果我们希望不创建实例,也可以调用某个方法(即当做工具来使用)//这时,把方法做成静态方法时非常合适System.out.println("9开平方的结果是=" + Math.sqrt(9));System.out.println(MyTools.calSum(10, 30));}
}
//开发自己的工具类时,可以将方法做成静态的,方便调用
class MyTools {//求出两个数的和public static double calSum(double n1, double n2) {return n1 + n2;}//可以写出很多这样的工具方法...
}
class Stu {private String name;//普通成员//定义一个静态变量,来累积学生的学费private static double fee = 0;public Stu(String name) {this.name = name;}//说明//1. 当方法使用了static修饰后,该方法就是静态方法//2. 静态方法就可以访问静态属性/变量public static void payFee(double fee) {Stu.fee += fee;//传进来的fee,累积到静态fee}public static void showFee() {System.out.println("总学费有:" + Stu.fee);}
}
10.1.7 类方法使用注意事项和细节讨论
- 类方法和普通方法都是随着类的加载而加载,将结构信息存储在方法区:类方法中无this的参数,
普通方法中隐含着this的参数 - 类方法可以通过类名调用,也可以通过对象名调用。[举例]
- 普通方法和对象有关,需要通过对象名调用,比如对象名.方法名(参数),不能通过类名调用。[举例]
- 类方法中不允许使用和对象有关的关键字,比如this和super。普通方法(成员方法)可以。[举例]
- 类方法(静态方法)中只能访问静态变量或静态方法。【如何理解】
- 普通成员方法,既可以访问非静态成员,也可以访问静态成员。
- 小结:静态方法,只能访问静态的成员。非静态的方法,可以访问静态成员和非静态成员(必须遵守访问权限)
代码:
public class StaticMethodDetail {public static void main(String[] args) {D.hi();//ok//非静态方法,不能通过类名调用//D.say();, 错误,需要先创建对象,再调用new D().say();//可以,创建对象也可以是匿名对象}
}
class D {private int n1 = 100;private static int n2 = 200;public void say() {//非静态方法,普通方法}public static void hi() {//静态方法,类方法// 类方法中不允许使用和对象有关的关键字,比如this和super。普通方法(成员方法)可以。//System.out.println(this.n1);}//类方法(静态方法)中 只能访问 静态变量 或静态方法//口诀:静态方法只能访问静态成员.public static void hello() {System.out.println(n2);System.out.println(D.n2);//System.out.println(this.n2);不能使用hi();//OK//say();//错误,say()是非静态方法。}//普通成员方法,既可以访问 非静态成员,也可以访问静态成员//小结: 非静态方法可以访问 静态成员和非静态成员public void ok() { //非静态方法//非静态成员System.out.println(n1);say(); //say()是非静态方法。//静态成员System.out.println(n2);hello();}
}
10.1.8 课堂练习 StaticExercise01.java
- 题目1,写出下面代码输出结果
- 题目2,看看下面代码有没有错误,如果有错误,就修改,看看输出什么?
代码:
注意:new Person()才会进入无参构造器
public class LianXi {public static void main(String[] args) {System.out.println("Number of total is " +Person.getTotalPerson()); //0 Person类直接调用类方法Person p1 = new Person();System.out.println( "Number of total is "+ Person.getTotalPerson()); //1}
}
class Person { //StaticExercise02.java 2min 时间private int id;private static int total = 0;public static int getTotalPerson() {//id++;//错误, 注销return total;}public Person() {//构造器total++; //total = 1id = total;//id = 1}
}
- 题目3,看看下面代码有没有错误,如果有错误,就修改,看看total 等于多少4?
public class LianXi {}
class Person { //StaticExercise03.java 2min 看private int id;private static int total = 0;public static void setTotalPerson(int total){// this.total = total;//错误,因为在static方法中,不可以使用this 关键字Person.total = total;}public Person() {//构造器total++; //4id = total; //4}//编写一个方法,输出total的值public static void m() {System.out.println("total的值=" + total);}}
class TestPerson {public static void main(String[] args) {Person.setTotalPerson(3);new Person(); //最后 total的值就是4Person.m();//看看输出的是不是4}
}
10.2 理解main 方法语法
10.2.1 深入理解main 方法
所以,传参给args是java执行程序的时候传进去的。
10.2.2 特别提示:
- 在main()方法中,我们可以直接调用main 方法所在类的静态方法或静态属性。
- 但是,不能直接访问该类中的非静态成员,必须创建该类的一个实例对象后,才能通过这个对象去访问类中的非静态成员,[举例说明] Main01.java
- 代码
public class Main01 {//静态的变量/属性private static String name = "java教育";//非静态的变量/属性private int n1 = 10000;//静态方法public static void hi() {System.out.println("Main01的 hi方法");}//非静态方法public void cry() {System.out.println("Main01的 cry方法");}public static void main(String[] args) {//可以直接使用 name//1. 静态方法main 可以访问本类的静态成员System.out.println("name=" + name);hi();//2. 静态方法main 不可以访问本类的非静态成员//System.out.println("n1=" + n1);//错误//cry();//3. 静态方法main 要访问本类的非静态成员,需要先创建对象 , 再调用即可Main01 main01 = new Main01();System.out.println(main01.n1);//okmain01.cry();}
}
10.2.3 案例演示-main传参
一般在submit软件运行时 直接传参方便,以下是演示IDEA如何传参。
现在,不传参直接运行代码 ,没有输出值
10.3 代码块
10.3.1 基本介绍、基本语法
10.3.2 代码块的好处和案例演示
好处:
- 相当于另外一种形式的构造器(对构造器的补充机制),可以做初始化的操作
- 场景:如果多个构造器中都有重复的语句,可以抽取到初始化块中,提高代码的重用
性 - 代码块的快速入门 CodeBlock01.java
public class CodeBlock01 {public static void main(String[] args) {Movie movie = new Movie("你好,李焕英");System.out.println("===============");Movie movie2 = new Movie("唐探3", 100, "陈思诚");}
}class Movie {private String name;private double price;private String director;//3个构造器-》重载//解读//(1) 下面的三个构造器都有相同的语句//(2) 这样代码看起来比较冗余//(3) 这时我们可以把相同的语句,放入到一个代码块中,即可//(4) 这样当我们不管调用哪个构造器,创建对象,都会先调用代码块的内容//(5) 代码块调用的顺序优先于构造器..{System.out.println("电影屏幕打开...");System.out.println("广告开始...");System.out.println("电影正式开始...");};public Movie(String name) {System.out.println("Movie(String name) 被调用...");this.name = name;}public Movie(String name, double price) {this.name = name;this.price = price;}public Movie(String name, double price, String director) {System.out.println("Movie(String name, double price, String director) 被调用...");this.name = name;this.price = price;this.director = director;}
}
10.3.3 代码块使用注意事项和细节讨论
- 细节第1-3点
CodeBlockDetail01.java
第1-3点对应的代码: 从下往上看,从AA类开始看到DD类
public class CodeBlockDetail01 {public static void main(String[] args) {//类被加载的情况举例//1. 创建对象实例时(new)// AA aa = new AA();//2. 创建子类对象实例,父类也会被加载, 而且,父类先被加载,子类后被加载// AA aa2 = new AA();//3. 使用类的静态成员时(静态属性,静态方法)// System.out.println(Cat.n1); //父类先被加载,子类后被加载//所以animal的也会被加载//static代码块,是在类加载时,执行的,而且只会执行一次.// DD dd = new DD();// DD dd1 = new DD();//普通的代码块,在创建对象实例时,会被隐式的调用。// 被创建一次,就会调用一次。// 如果只是使用类的静态成员时,普通代码块并不会执行System.out.println(DD.n1);//8888, 静态模块块一定会执行}
}class DD {public static int n1 = 8888;//静态属性//静态代码块static {System.out.println("DD 的静态代码1被执行...");//}//普通代码块, 在new 对象时,被调用,而且是每创建一个对象,就调用一次//可以这样简单的,理解 普通代码块是构造器的补充{System.out.println("DD 的普通代码块...");}
}class Animal {//静态代码块static {System.out.println("Animal 的静态代码1被执行...");//}
}class Cat extends Animal {public static int n1 = 999;//静态属性//静态代码块static {System.out.println("Cat 的静态代码1被执行...");//}
}class BB {//静态代码块static {System.out.println("BB 的静态代码1被执行...");//1}
}class AA extends BB {//静态代码块static {System.out.println("AA 的静态代码1被执行...");//2}
}
- 细节第4点
第4点对应代码:
public class CodeBlockDetail02 {public static void main(String[] args) {A a = new A();// (1) A 静态代码块01 (2) getN1被调用...(3)A 普通代码块01(4)getN2被调用...(5)A() 构造器被调用}
}class A {{ //普通代码块System.out.println("A 普通代码块01");}private int n2 = getN2();//普通属性的初始化static { //静态代码块System.out.println("A 静态代码块01");}//静态属性的初始化private static int n1 = getN1();public static int getN1() {System.out.println("getN1被调用...");return 100;}public int getN2() { //普通方法/非静态方法System.out.println("getN2被调用...");return 200;}//无参构造器public A() {System.out.println("A() 构造器被调用");}
}
- 细节第5点
第5点对应代码:
public class CodeBlockDetail03 {public static void main(String[] args) {new BBB();//(1)AAA的普通代码块(2)AAA() 构造器被调用(3)BBB的普通代码块(4)BBB() 构造器被调用}
}class AAA { //父类Object没什么输出{System.out.println("AAA的普通代码块");}public AAA() {//(1)super()//(2)调用本类的普通代码块System.out.println("AAA() 构造器被调用....");}
}class BBB extends AAA {{System.out.println("BBB的普通代码块...");}public BBB() {//(1)super()//(2)调用本类的普通代码块System.out.println("BBB() 构造器被调用....");}
}
- 细节第6-7点:
第6-7点对应代码:
public class CodeBlockDetail04 {public static void main(String[] args) {//说明//(1) 进行类的加载//1.1 先加载 父类 A02 1.2 再加载 B02//(2) 创建对象//2.1 从子类的构造器开始new B02();//对象new C02();}
}class A02 { //父类private static int n1 = getVal01();static {System.out.println("A02的一个静态代码块..");//(2)}{System.out.println("A02的第一个普通代码块..");//(5)}public int n3 = getVal02();//普通属性的初始化public static int getVal01() {System.out.println("getVal01");//(1)return 10;}public int getVal02() {System.out.println("getVal02");//(6)return 10;}public A02() {//构造器//隐藏//super()//普通代码和普通属性的初始化......System.out.println("A02的构造器");//(7)}}class B02 extends A02 { //private static int n3 = getVal03();static {System.out.println("B02的一个静态代码块..");//(4)}public int n5 = getVal04();{System.out.println("B02的第一个普通代码块..");//(9)}public static int getVal03() {System.out.println("getVal03");//(3)return 10;}public int getVal04() {System.out.println("getVal04");//(8)return 10;}//一定要慢慢的去品..public B02() {//构造器//隐藏了//super()//普通代码块和普通属性的初始化...System.out.println("B02的构造器");//(10)}
}class C02 {private int n1 = 100;private static int n2 = 200;private void m1() {}private static void m2() {}static {//静态代码块,只能调用静态成员//System.out.println(n1);错误System.out.println(n2);//ok//m1();//错误m2();}{//普通代码块,可以使用任意成员System.out.println(n1);System.out.println(n2);//okm1();m2();}
}
10.3.4 课堂练习题
CodeBlockExercise01.java
题1:下面的代码输出什么?
输出为:
in static block!
100
100题2:下面的代码输出什么?
解析:new Test()会导致类加载,然后会导致静态代码块和静态属性初始化。new Sample(“静态成员sam初始化”)这里把参数传给Sample的有参构造器。静态代码块执行完进行普通代码块或普通属性的初始化。输出结果:
静态成员sam初始化
static块执行
sam1成员初始化
Test默认构造函数被调用
10.4 单例设计模式
10.4.1 什么是设计模式
- 是静态方法和属性的经典使用
- 设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。设计模式就像是经典的棋谱,不同的棋局,我们用不同的棋谱,免去我们自己再思考和摸索。
10.4.2 什么是单例模式
单例(单个的实例)
- 所谓类的单例设计模式,就是采取一定的方法保证在整个的软件系统中,对某
个类只能存在一个对象实例,并且该类只提供一个取得其对象实例的方法 - 单例模式有两种方式: 1) 饿汉式 2) 懒汉式
10.4.3 单例模式应用实例
(1)饿汉式代码:
public class SingleTon01 {public static void main(String[] args) {// GirlFriend xh = new GirlFriend("小红");
// GirlFriend xb = new GirlFriend("小白");//创建了2个对象 就不是单例//通过方法可以获取对象GirlFriend instance = GirlFriend.getInstance();System.out.println(instance);GirlFriend instance2 = GirlFriend.getInstance();System.out.println(instance2);System.out.println(instance == instance2);//T }
}//有一个类, GirlFriend
//只能有一个女朋友
class GirlFriend {private String name;//为了能够在静态方法中,返回 gf对象,需要将其修饰为static//對象,通常是重量級的對象, 饿汉式可能造成创建了对象,但是沒有使用.private static GirlFriend gf = new GirlFriend("小红红");//如何保障我们只能创建一个 GirlFriend 对象//步骤[单例模式-饿汉式]//1. 将构造器私有化//2. 在类的内部直接创建对象(该对象是static)//3. 提供一个公共的static方法,返回 gf对象private GirlFriend(String name) {System.out.println("構造器被調用.");this.name = name;}public static GirlFriend getInstance() {return gf;}@Overridepublic String toString() {return "GirlFriend{" +"name='" + name + '\'' +'}';}
}
(2)懒汉式代码:
public class SingleTon02 {public static void main(String[] args) {//new Cat("大黃"); //不行,因为构造器私有化了//System.out.println(Cat.n1); //类虽然加载了,但是没创建Cat对象Cat instance = Cat.getInstance();//创建Cat对象System.out.println(instance);//再次调用getInstanceCat instance2 = Cat.getInstance();System.out.println(instance2);System.out.println(instance == instance2);//T}
}//希望在程序運行過程中,只能創建一個Cat對象
//使用單例模式
class Cat {private String name;public static int n1 = 999;private static Cat cat ; //默认是null//步骤//1.仍然构造器私有化//2.定义一个static静态属性//3.提供一个public的static方法,可以返回一个Cat对象//4.懒汉式,只有档用户使用getInstance时,才返回cat对象, 后面再次调用时,会返回上次创建的cat对象,//从而保证了单例private Cat(String name) {System.out.println("構造器調用...");this.name = name;}public static Cat getInstance() {if(cat == null) {//如果还沒有创建cat對象cat = new Cat("小可愛");}return cat;}@Overridepublic String toString() {return "Cat{" +"name='" + name + '\'' +'}';}
}
10.4.4 饿汉式VS 懒汉式
- 二者最主要的区别在于创建对象的时机不同:饿汉式是在类加载就创建了对象实例。
而懒汉式是在使用时才创建。 - 饿汉式不存在线程安全问题,懒汉式存在线程安全问题。(后面学习线程后,会完善一把)
- 饿汉式存在浪费资源的可能。因为如果程序员一个对象实例都没有使用,那么饿汉
式创建的对象就浪费了,懒汉式是使用时才创建,就不存在这个问题。 - 在我们javaSE标准类中, java.lang.Runtime就是经典的单例模式。
10.5 final 关键字
10.5.1 基本介绍
Final01.java
final中文意思:最后的,最终的.
final可以修饰类、属性、方法和局部变量.
在某些情况下,程序员可能有以下需求,就会使用到final:
- 当不希望类被继承时,可以用final修饰.【案例演示】
- 当不希望父类的某个方法被子类覆盖/重写(override)时,可以用final关键字
修饰。【案例演示:访问修饰符 final返回类型方法名】 - 当不希望类的的某个属性的值被修改,可以用final修饰.【案例演示: public final double TAX RATE=0.08】
- 当不希望某个局部变量被修改,可以使用final修饰【案例演示: final double TAX RATE=0.08 】
代码:
public class Final01 {public static void main(String[] args) {E e = new E();//e.TAX_RATE = 0.09;}
}//如果我们要求A类不能被其他类继承
//可以使用final修饰 A类
final class A { }//class B extends A {} //报错class C {//如果我们要求hi不能被子类重写//可以使用final修饰 hi方法public final void hi() {}
}
class D extends C {// @Override
// public void hi() {// System.out.println("重写了C类的hi方法..");
// }
}//当不希望类的的某个属性的值被修改,可以用final修饰
class E {public final double TAX_RATE = 0.08;
}//当不希望某个局部变量被修改,可以使用final修饰
class F {public void cry() {//这时,NUM 也称为 局部常量final double NUM = 0.01;//NUM = 0.9;System.out.println("NUM=" + NUM);}
}
10.5.2 final 使用注意事项和细节讨论
- final修饰的属性又叫常量,一般用XX XX XX来命名
- final修饰的属性在定义时,必须赋初值,并且以后不能再修改,赋值可以在如
下位置之一【选择一个位置赋初值即可】:
①定义时:如public final double TAX_RATE=0.08; ②在构造器中 ③在代码块中。 - 如果final修饰的属性是静态的,则初始化的位置只能是
① 定义时 ② 在静态代码块,不能在构造器中赋值。 - final类不能继承,但是可以实例化对象。
- 如果类不是final类,但是含有final方法,则该方法虽然不能重写,但是可以被继承。
- 一般来说,如果一个类已经是final类了,就没有必要再将方法修饰成final方法。
- final不能修饰构造方法(即构造器)
- final和static往往搭配使用,效率更高,不会导致类加载.底层编译器做了优化处理。
class Demo{
public static final int i=16; //不写final下边语句就输出了。
static{ System.out.println(“Java教育~”);} - 包装类(Integer,Double,Float,Boolean等都是final),String也是final类.
细节1-5点对应代码:
public class FinalDetail01 {public static void main(String[] args) {CC cc = new CC();new EE().cal();}
}class AA {/*1. 定义时:如 public final double TAX_RATE=0.08;2. 在构造器中3. 在代码块中*/public final double TAX_RATE = 0.08;//1.定义时赋值public final double TAX_RATE2 ;public final double TAX_RATE3 ;public AA() {//构造器中赋值TAX_RATE2 = 1.1;}{//在代码块赋值TAX_RATE3 = 8.8;}
}class BB {/*如果final修饰的属性是静态的,则初始化的位置只能是1 定义时 2 在静态代码块 不能在构造器中赋值。*/public static final double TAX_RATE = 99.9;public static final double TAX_RATE2 ;static {TAX_RATE2 = 3.3;}
}//final类不能继承,但是可以实例化对象
final class CC { }//如果类不是final类,但是含有final方法,则该方法虽然不能重写,但是可以被继承
//即,仍然遵守继承的机制.
class DD {public final void cal() {System.out.println("cal()方法");}
}
class EE extends DD { }
细节6-9点对应代码:
public class FinalDetail02 {public static void main(String[] args) {System.out.println(BBB.num);//包装类,String 是final类,不能被继承}
}//final 和 static 往往搭配使用,效率更高,不会导致类加载.底层编译器做了优化处理
class BBB {public final static int num = 10000;//不写final,下边的静态代码块就要被执行了。写了就不执行static {System.out.println("BBB 静态代码块被执行");}
}
final class AAA{//一般来说,如果一个类已经是final类了,就没有必要再将方法修饰成final方法//public final void cry() {}
}
10.5.3 final 应用实例
- 题1 :请编写一个程序,能够计算圆形的面积。要求圆周率为3.14。赋值的位置3个方式都写一下.
public class FinalExercise01 {public static void main(String[] args) {Circle circle = new Circle(5.0);System.out.println("面积=" + circle.calArea());}
}class Circle {private double radius;private final double PI;// = 3.14;//构造器public Circle(double radius) {this.radius = radius;//PI = 3.14;}{PI = 3.14;}public double calArea() {return PI * radius * radius;}
}
- 题目2:看看下面的代码有没有错误
class Something { //FinalExercise02.javapublic int addOne(final int x) { //下面的代码是否有误,为什么? 1min//++x; //错误,原因是不能修改 final x的值return x + 1; //这里是可以.x的值没有变化}
}
java学习笔记(10) 第10 章(上) - 面向对象编程(高级部分)相关推荐
- Java_第08章_面向对象编程(高级)
第08章_面向对象编程(高级) 本章专题与脉络 1. 关键字:static 回顾类中的实例变量(即非static的成员变量) class Circle{private double radius;pu ...
- java学习笔记(8) 第8章(下)- 面向对象编程(中级部分) - 练习题
目录: 题目1 题目2 题目3 题目4 题目5 题目6 题目7 题目8 题目9 题目10 题目11 题目12 题目13 题目14 题目15 题目16 题目1 1.定义一个Person类 {name, ...
- Python快速编程入门#学习笔记08# |第8章 :面向对象
目录 1. 面向对象概述 2. 类的定义 3.对象的创建与使用 类的成员 4.属性 1.类属性 2.实例属性 5.方法 1.实例方法 2.类方法 3.静态方法 6.私有成员 特殊方法 7.构造方法 8 ...
- C++学习笔记:(七)C语言实现面向对象编程
面试官:C和C++有什么不同? 应聘者:一个是面向过程,一个是面向对象. 这样的答案在我看是不完全正确,因为面向过程编程和面向对象编程是编程思想,C++可以用面向过程的思想编程,同样,C语言也可以用面 ...
- 第08章_面向对象编程(高级)
本章专题与脉络 1. 关键字:static 回顾类中的实例变量(即非static的成员变量) class Circle{private double radius;public Circle(doub ...
- java学习笔记2021.1.10
有关于多接口中的重名变量的解决方案:下面列出一些错误的写法: interface one{static int x=11;}interface two{static int x=22;}class t ...
- java学习笔记(13) 第13章 - 常用类
第13 章常用类-目录 13.1 包装类 13.1.1 包装类的分类.包装类和基本数据的转换.案例演示.课堂测试 13.1.2 包装类型和String 类型的相互转换 13.1.3 Integer 类 ...
- java学习笔记(9) 第9章 Java项目-房屋出租系统
Java项目-房屋出租系统 代码打包--百度网盘链接: 9.1 房屋出租系统-需求 9.1.1 项目需求说明 9.2 房屋出租系统-界面 9.3 房屋出租系统-设计(!!) 9.4 房屋出租系统-实现 ...
- JAVA学习笔记(第五章 接口与继承)
一.什么是接口 接口就像是一种模板,接口中放着没有内容的方法,类要是使用接口就必须声明接口中的方法.下面继续以LOL游戏为例: LOL的英雄,有些能够使用物理攻击,有些能够使用魔法攻击击,有些则两种攻 ...
- Java学习笔记-第十四章-NIO与NIO2
目录 一.NIO 二.NIO2 1. NIO2架构 2. 操作路径 3. 属性读取与设定 4. 操作文档与记录 5. 读取/访问目录 6. 过滤/搜索文档 一.NIO /*** 原始的dump** @ ...
最新文章
- ad19电气规则检查_建议收藏Altium Designer Rules规则详解
- 为什么汉字不能当密码,假如用汉字做密码,又会怎样?
- python使用matplotlib可视化跨年数值指标中位数变化率、使用pct_change函数计算变化率、年环比变化率(pct_change function)
- SAP 预算控制业务集成
- boost::hana::fill用法的测试程序
- Spring高级程序设计这本书怎么样
- dedeCMS 文件路径、全局替换(待续···)
- Python基础——模块的安装
- python和c 的区别-对比平台--C和Python之间的区别
- 数组的最长递减子序列java_47.创新工场: 求一个数组的最长递减子序列 | 学步园...
- 数据结构遍历顺序栈_[C++]数据结构:栈之顺序栈
- 什么软件可以室内导航?怎样使用导航地图导航?
- EXCEL/WPS中的数组公式{},在钉钉用什么进行替代
- 不要因为英语和数学而害怕学习编程.
- bzoj 1941 kd-tree求最大最小曼哈顿距离
- 策略路由(本地策略和接口策略)
- Shiny的架构浅析
- SpringBoot进阶教程(七十三)整合elasticsearch
- cannot use message (variable of type protoreflect.ProtoMessage) as type protoiface.MessageV1 in argu
- 怎么把录音转文字?快把这些方法收好
热门文章
- 调侃计算机专业的笑话,段子手要失业了 计算机也懂幽默
- 爱的5种能力,你有吗?
- Linux下解决cannot connect to X server :0.0 问题
- 武汉大学计算机学院夏桂松,实验室硕士研究生王碧杉、何敬伟在ECCV上发表事件相机高质量图像重建论文...
- Chrome扩展框架-Vue项目(用vue配合webpack实现浏览器扩展,包含热更新,无需重复加载浏览器插件)
- Quadratic Video Interpolation 视频插帧
- 如何在PowerPoint演示文稿中链接或嵌入Excel工作表
- ★如何解释特修斯之船问题?
- BOOST元状态机用户手册之三教程(Meta State Machine (MSM))(1)——基本前端及例程
- 怪异,漂亮的几个数学恒等式(转)