目录
面向对象编程(高级部分)
类变量和类方法
类变量-提出问题
传统方法解决
问题分析:
类变量快速入门
类变量内存布局
什么是类变量
如何定义类变量定义语法:
如何访问类变量
定义语法:
类变量使用注意事项和细节讨论
类方法基本介绍
类方法的调用:
类方法应用案例
类方法经典的使用场景
类方法使用注意事项和细节讨论
练习题
理解main方法语法
深入理解main方法
特别提示
main方法使用案例演示
代码块
基本介绍
基本语法
注意:
代码块的好处和案例演示
代码块使用注意事项和细节讨论
代码块练习题
单例设计模式
什么是设计模式
什么是单例模式单例(单个的实例)
单例模式应用实例
[单例模式]饿汉式
[单例模式]懒汉式
饿汉式 VS 懒汉式
final关键字
基本介绍
final使用注意事项和细节讨论
final应用实例
1、请编写一个程序,能够计算圆形的面积。要求圆周率为3.14。赋值的位置3个方式都写一下
2、下面代码正确么,为什么
面向对象编程(高级部分)
类变量和类方法
类变量-提出问题
说:有一群小孩在玩堆雪人,不时有新的小孩加入,请问如何知道现在共有多少人在玩?,编写程序解决。
传统方法解决
思路
1、在main方法中定义一个变量count
2、当一个小孩加入游戏后count++,最后个count 就记录有多少小孩玩游戏
package com10.static_;public class ChildGame {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;public Child(String name) {this.name = name;}public void join() {System.out.println(name + " 加入了游戏..");}}
问题分析:
1、count是一个独立于对象,很尴尬
2、以后我们访问count很麻烦,没有使用到OOP
3、因此,我们引出类变量/静态变量
类变量快速入门
思考:如果,设计一个int count表示总人数,我们在创建一个小孩时,就把count加1,并且 count是所有对象共享的就ok了!,使用类变量来解决ChildGame.java改进
package com10.static_;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 {//类//定义一个变量 count,是一个类变量(静态变量)static静态//该变量最大的特点就是会被Child 类的所有的对象实例共享public static int count = 0;private String name;public Child(String name) {this.name = name;}public void join() {System.out.println(name + " 加入了游戏..");}}
类变量内存布局
画一个小图理解。=> 画出一个示意图帮助理解,静态变量放在哪里?
1.静态变量被对象共享
2.因此不影响对静态变量的使用
不管static变量在哪里,
共识(1)static变量是同一个类所有对象共享
共识(2)static类变量,在类加载的时候就生成了
什么是类变量
类变量也叫静态变量/静态属性,是该类的所有对象共享的变量,任何一个该类的对象去访问它时,取到的都是相同的值,同样任何一个该类的对象去修改它时,
如何定义类变量定义语法:
访问修饰符static 数据类型变量名;[推荐]
static 访问修饰符数据类型变量名;
如何访问类变量
定义语法:
类名.类变量名
或者 对象名.类变量名
【静态变量的访问修饰符的访问权限和范围和普通属性是一样的】
推荐使用类名.类变量名
package com10.static_;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 = "甲柒";}
类变量使用注意事项和细节讨论
1、什么时候需要用类变量
当我们需要让某个类的所有对象都共享一个变量时,就可以考虑使用类变量(静态变量):
比如:定义学生类,统计所有学生共交多少钱。Student (name, fee)
2、类变量与实例变量(普通属性)区别
类变量是该类的所有对象共享的,而实例变量是每个对象独享的。
3、加上static称为类变量或静态变量,否则称为实例变量/普通变量/非静态变量
4、类变量可以通过 类名.类变量名 或者对象名.类变量名来访问,但java设计者推荐我们使用类名.类变量名方式访问。【前提是 满足访问修饰符的访问权限和范围】
5、实例变量不能通过类名.类变量名方式访问。
6、类变量是在类加载时就初始化了,也就是说,即使你没有创建对象,只要类加载了,就可以使用类变量了。[案例演示]
7、类变量的生命周期是随类的加载开始,随着类消亡而销毁。[举例,Monster.name][案例演示]
package com10.static_;public class StaticDetail {public static void main(String[] args) {B b = new B();// System.out.println(B.n1);System.out.println(B.n2);//静态变量是类加载的时候,就创建了,所以没有创建对象实例//也可以通过 类名.变量名 来访问System.out.println(C.address);}}class B {public static int n2 = 200;public int n1 = 100;}class C {public static String address = "郑州";}
类方法基本介绍
类方法也叫静态方法
形式如下:
访问修饰符 static 数据返回类型 方法名(){}【推荐】
static 访问修饰符 数据返回类型 方法名(){}
类方法的调用:
使用方式:类名.类方法名 或者 对象名.类方法名【前提是 满足访问修饰符的访问权限和范围】
类方法应用案例
统计学费总和
package com10.static_;public class StaticMethod {public static void main(String[] args) {//创建两个学生对象,来累计学生的学费Stu tom = new Stu("tom");tom.payFee(100);Stu.payFee(100);Stu mary = new Stu("mary");mary.payFee(200);Stu.payFee(200);//输出当前收到的总学费Stu.showFee();}}class Stu {//定义一个静态变量,来累计学生的学费private static double fee = 0;private String name;//普通成员public Stu(String name) {this.name = name;}//说明//1.当方法使用了static修饰后,该方法就是静态方法//2.静态方法就可以访问静态属性/变量public static void payFee(double fee) {Stu.fee += fee;//累积到}public static void showFee() {System.out.println("总学费有:" + Stu.fee);}}
运行结果
类方法经典的使用场景
当方法中不涉及到任何和对象相关的成员,则可以将方法设计成静态方法,提高开发效率。
比如:工具类中的方法utils
Math类、Arrays类、Collections集合类看下源码
小结
在程序员实际开发,往往会将一些通用的方法,设计成静态方法,这样我们不需要创建对象就可以使用了,比如打印一维数组,冒泡排序,完成某个计算任务等..[举例说明...]
类方法使用注意事项和细节讨论
1、类方法和普通方法都是随着类的加载而加载,将结构信息存储在方法区
类方法中无this的参数
普通方法中隐含着this的参数
2、类方法可以通过类名调用,也可以通过对象名调用。[举例]
3、普通方法和对象有关,需要通过对象名调用,比如 对象名.方法名(参数),不能通过类名调用。[举例]
4、类方法中不允许使用和对象有关的关建字,比如this和super。晋迪万法(永员万法)可以。[举例]
5、类方法(静态方法)中 只能访问 静态变量 或 静态方法。【如何理解】
6、普通成员方法,既可以访问普通变量(方法),也可以访问静态变量(方法)。
小结:静态方法,只能访问静态的成员,非静态的方法,可以访问静态成员和非静态成员(必须遵守访问权限)
package com10.static_;public class StaticMethodDetail {public static void main(String[] args) {D.hi();//ok//非静态方法,不能通过类名调用// D.say();//错误,需要先创建对象,再调用new D().say();//ok}}class D {private static int n2 = 200;private int n1 = 100;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();//错误}public void say() {//非静态类}//普通成员方法,既可以访问普通变量(方法),也可以访问静态变量(方法)//小结:非静态方法可以访问 静态成员和非静态成员public void ok() {//非静态成员System.out.println(n1);say();//静态成员System.out.println(n2);hello();}}
练习题
1、以下代码输出什么
package com10.static_;public class StaticExercise01 {public static void main(String[] args) {new Test().count();//9new Test().count();//10System.out.println(Test.count);//11}}class Test {static int count = 9;public void count() {System.out.println("count=" + (count++));}}
运行结果
2、看下面代码有没有错误,如果有错误,就修改,看看输出什么?
package com10.static_;public class StaticExercise02 {public static void main(String[] args) {System.out.println("Number of total is" + Person.getTotalPerson());Person p1 = new Person();System.out.println("Number of total is" + Person.getTotalPerson());}}class Person {private static int total = 0;private int id;public Person() {total++;id = total;}public static int getTotalPerson() {id++;//错误return total;}}
修改后的代码
package com10.static_;public class StaticExercise02 {public static void main(String[] args) {System.out.println("Number of total is" + Person.getTotalPerson());Person p1 = new Person();System.out.println("Number of total is" + Person.getTotalPerson());}}class Person {private static int total = 0;private int id;public Person() {total++;id = total;}public static int getTotalPerson() {// id++;//错误return total;}}
运行结果
3、看看下面代码有没有错误,如果有错误,就修改,看看total等于多少
package com10.static_;public class StaticExercise03 {public static void main(String[] args) {Person03.setTotalPerson(3);new Person03();}}class Person03 {private static int total = 0;private int id;public Person03() {total++;id = total;}public static void setTotalPerson(int total) {this.total;Person03.total = total;}}
修改后的代码
package com10.static_;public class StaticExercise03 {public static void main(String[] args) {Person03.setTotalPerson(3);new Person03().m();}}class Person03 {private static int total = 0;private int id;public Person03() {//构造器total++;id = total;}public static void setTotalPerson(int total) {// this.total;//错误,因为在static方法中,不可以使用this关键字Person03.total = total;}//编写一个方法,输出total的值public void m() {System.out.println("total=" + total);}}
运行结果
理解main方法语法
深入理解main方法
解释main方法的形式:public static void main(String[]args){ }
1、main方法是虚拟机调用
2、java虚拟机需要调用类的main()方法,所以该方法的访问权限必须是public
3、java虚拟机在执行main()方法时不必创建对象,所以该方法必须是static
4、该方法接收String类型的数组参数,该数组中保存执行java命令时传递给所运行的类的参数,案例演示,接收参数
5、java 执行的程序参数1参数2参数3
package com10.static_;public class Hello {public static void main(String[] args) {for (int i = 0; i < args.length; i++) {System.out.println("第" + (i + 1) + "个参数=" + args[i]);}}}
特别提示
1、在main()方法中,我们可以直接调用main方法所在类的静态方法或静态属性。
2、但是,不能直接访问该类中的非静态成员,必须创建该类的一个实例对象后,才能通过这个对象去访问类中的非静态成员,
package com10.static_;public class Main01 {//静态的变量/属性private static String name = "甲柒";//非静态的变量/属性private int n1 = 3600;//静态方法public static void hi() {System.out.println("Main01的 hi方法");}public static void main(String[] args) {//可以直接使用name//1.静态方法可以访问本类的静态成员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);main01.cry();}//非静态方法public void cry() {System.out.println("Main01的 cry方法");}}
main方法使用案例演示
package com10.static_;public class Main02 {public static void main(String[] args) {for (int i = 0; i < args.length; i++) {System.out.println("args[" + i + "]=" + args[i]);}}}
代码块
基本介绍
代码化块又称为初始化块,属于类中的成员[即 是类的一部分],类似于方法,将逻辑语句封装在方法体中,通过{}包围起来。
但和方法不同,没有方法名,没有返回,没有参数,只有方法体,而且不用通过对象或类显式调用,而是加载类时,或创建对象时隐式调用。
基本语法
[修饰符]{
代码
};
注意:
1、修饰符 可选,要写的话,也只能写static
2、代码块分为两类,使用static修饰的叫静态代码块,没有static修饰的,叫普通代码块/非静态代码块。
3、逻辑语句可以为任何逻辑语句(输入、输出、方法调用、循环、判断等)
4、;号可以写上,也可以省略。
代码块的好处和案例演示
1、相当于另外一种形式的构造器(对构造器的补充机制),可以做初始化的操作
2、场景:如果多个构造器中都有重复的语句,可以抽取到初始化块中,提高代码的重用性
3、代码块的快速入门
package com10.static_;public class CodeBlock01 {public static void main(String[] args) {Movie movie = new Movie("你好,李焕英");System.out.println("=================================");Movie movie1 = new Movie("十二生肖", 46, "成龙");}}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;}}
运行结果
代码块使用注意事项和细节讨论
1、static代码块也叫静态代码块,作用就是对类进行初始化,而且它随着类的加载而执行,并且只会执行一次。如果是普通代码块,每创建一个对象,就执行。
2、类什么时候被加载【重要】
创建对象实例时(new)创建子类对象实例,父类也会被加载使用类的静态成员时(静态属性,静态方法)
案例演示:A类extends B类的静态块
3、普通的代码块,在创建对象实例时,会被隐式的调用。
被创建一次,就会调用一次。
如果只是使用类的静态成员时,普通代码块并不会执行。
package com10.codeblock;public class CodeBlockDetail01 {public static void main(String[] args) {//类被加载的情况举例//1.创建对象实例时(new)// AA aa = new AA();//2.创建子类对象实例,父类也会被加载,而且,父类先被加载,子类后被加载// AA aa1 = new AA();//3.使用类的静态成员时(静态属性,静态方法)// System.out.println(Cat.n1);//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 AA extends BB {//静态代码块static {System.out.println("AA 的静态代码1被执行...");}}class BB {//静态代码块static {System.out.println("BB 的静态代码1被执行...");}}
小结:
1.static代码块是类加载时,执行,只会执行一次
2.普通代码块时在创建对象时调用的,创建一次,调用一次
4、创建一个对象时,在一个类调用顺序是:(重点,难点)
调用静态代码块和静态属性初始化
(注意:静态代码块和静态属性初始化调用的优先级一样,如果有多个静态代码块和多个静态变量初始化,则按他们定义的顺序调用)调用普通代码块和普通属性的初始化
(注意:普通代码块和普通属性初始化调用的优先级一样,如果有多个普通代码块和多个普通属性初始化,则按定义顺序调用)调用构造方法。
新写一个类演示
package com10.codeblock;public class CodeBlockDetail02 {public static void main(String[] args) {A a = new A();//(1)A 静态代码块01(2)getN1被调用...(3)getN2被调用...(4)A 普通代码块01(5)A() 构造器被调用}}class A {//静态属性的初始化private static int n1 = getN1();static {//静态的代码块System.out.println("A 静态代码块01");}//普通属性的初始化private int n2 = getN2();{//普通代码块System.out.println("A 普通代码块01");}//无参构造器public A() {System.out.println("A() 构造器被调用");}public static int getN1() {System.out.println("getN1被调用...");return 100;}public static int getN2() {System.out.println("getN2被调用...");return 200;}}
5、构造方法(构造器)的最前面其实隐含了super()和调用普通代码块,新写一个类演示【截图+说明】,静态相关的代码块,属性初始化,在类加载时,就执行完毕,因此是优先于构造器和普通代码块执行的
package com10.codeblock;public class CodeBlockDetail03 {public static void main(String[] args) {BBB bbb = 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、我们看一下创建一个子类时(继承关系),他们的静态代码块,静态属性初始化,普通代码块,普通属性初始化,构造方法的调用顺序如下:
父类的静态代码块和静态属性(优先级一样,按定义顺序执行)子类的静态代码块和静态属性(优先级一样,按定义顺序执行)父类的普通代码块和普通属性初始化(优先级一样,按定义顺序执行)4父类的构造方法子类的普通代码块和普通属性初始化(优先级一样,按定义顺序执行)子类的构造方法面试题
A extends B类演示
package com10.codeblock;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 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();}}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)// TODO Auto-generated constructor stub}}
7、静态代码块只能直接调用静态成员(静态属性和静态方法),普通代码块可以调用任意成员。
代码块练习题
1、下面的代码输出什么?
package com10.codeblock;public class CodeBlockExercise01 {public static void main(String[] args) {System.out.println("total = " + Person.total); //100System.out.println("total = " + Person.total); //100}}class Person {public static int total;//静态变量static {//静态代码块total = 100;System.out.println("in static block!");//(1)}}
运行结果
2、下面的代码输出什么?
package com10.codeblock;public class CodeBlockExercise02 {//主方法public static void main(String str[]) {Test a = new Test();//无参构造器}}class Sample {Sample(String s) {System.out.println(s);}Sample() {System.out.println("Sample默认构造函数被调用");}}class Test {static Sample sam = new Sample("静态成员sam初始化 ");//1static {System.out.println("static块执行");//2if (sam == null) System.out.println("sam is null");}Sample sam1 = new Sample("sam1成员初始化");//3Test()//构造器{System.out.println("Test默认构造函数被调用");//4}}
运行结果
单例设计模式
什么是设计模式
1、静态方法和属性的经典使用
2、设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。设计模式就像是经典的棋谱,不同的棋局,我们用不同的棋谱,免去我们自己再思考和摸索
什么是单例模式单例(单个的实例)
1、所谓类的单例设计模式,就是采取一定的方法保证在整个的软件系统中,对某个类只能存在一个对象实例,并且该类只提供一个取得其对象实例的方法
2、单例模式有两种方式:
饿汉式懒汉式
单例模式应用实例
演示饿汉式和懒汉式单例模式的实现。
步骤如下:
1、构造器私有化 => 防止直接new
2、类的内部创建对象
3、向外暴露一个静态的公共方法。getInstance
4、代码实现
[单例模式]饿汉式
package com10.single_;public class SingleTon01 {public static void main(String[] args) {// GirlFriend xh = new GirlFriend("小红");// GirlFriend xb = new GirlFriend("小白");//通过方法可以获取对象GirlFriend instance = GirlFriend.getInstance();System.out.println(instance);GirlFriend instance2 = GirlFriend.getInstance();System.out.println(instance2);System.out.println(instance == instance2);//T//System.out.println(GirlFriend.n1);//...}}//有一个类, GirlFriend//只能有一个女朋友class GirlFriend {//public static int n1 = 100;//为了能够在静态方法中,返回 gf对象,需要将其修饰为static//对象,通常是重量级的对象, 饿汉式可能造成创建了对象,但是没有使用.private static GirlFriend gf = new GirlFriend("小红红");private String name;//如何保障我们只能创建一个 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 + '\'' +'}';}}
[单例模式]懒汉式
package com10.single_;/*** 演示懒汉式的单例模式*/public class SingleTon02 {public static void main(String[] args) {//new Cat("大黄");//System.out.println(Cat.n1);Cat instance = Cat.getInstance();System.out.println(instance);//再次调用getInstanceCat instance2 = Cat.getInstance();System.out.println(instance2);System.out.println(instance == instance2);//T}}//希望在程序运行过程中,只能创建一个Cat对象//使用单例模式class Cat {public static int n1 = 999;private static Cat cat; //默认是nullprivate String name;//步骤//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 + '\'' +'}';}}
饿汉式 VS 懒汉式
1、二者最主要的区别在于创建对象的时机不同:
饿汉式是在类加载就创建了对象实例而懒汉式是在使用时才创建。
2、饿汉式不存在线程安全问题,懒汉式存在线程安全问题。(后面学习线程后,会完善一把)
3、饿汉式存在浪费资源的可能。因为如果程序员一个对象实例都没有使用,那么饿汉式创建的对象就浪费了,懒汉式是使用时才创建,就不存在这个问题。
4、在我们javaSE标准类中,java.lang.Runtime就是经典的单例模式。
final关键字
基本介绍
final中文意思:最后的,最终的.
final可以修饰类、属性、方法和局部变量,
在某些情况下,程序员可能有以下需求,就会使用到final
1、当不希望类被继承时,可以用final修饰【案例演示】
2、当不希望父类的某个方法被子类覆盖/重写(override)时,可以用final关键字修饰
【案例演示:访问修饰符final返回类型方法名】
3、当不希望类的的某个属性的值被修改,可以用final修饰
【案例演示:public final double TAX RATE=0.08】
4、当不希望某个局部变量被修改,可以使用final修饰
【案例演示:final double TAX RATE=0.08】
package com10.final_;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);}}
final使用注意事项和细节讨论
1、final修饰的属性又叫常量,一般用XX XX XX来命名
2、final修饰的属性在定义时,必须赋初值,并且以后不能再修改,赋值可以在如下位置之一
【选择一个位置赋初值即可】
定义时:如public final double TAX_RATE=0.08;在构造器中在代码块中
3、如果final修饰的属性是静态的,则初始化的位置只能是
定义时在静态代码块不能在构造器中赋值。
4、final类不能继承,但是可以实例化对象。[A2类]
5、如果类不是final类,但是含有final方法,则该方法虽然不能重写,但是可以被继承。[A3类]
package com10.final_;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;{//在代码块赋值TAX_RATE3 = 8.8;}public AA() {//构造器中赋值TAX_RATE2 = 1.1;}}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 {}
5、一般来说,如果一个类已经是final类了,就没有必要再将方法修饰成final方法。
6、final不能修饰构造方法(即构造器)
7、final和static往往搭配使用,效率更高,底层编译器做了优化处理。
8、包装类(Integer,Double,Float, Boolean等都是final),String也是final类。
package com10.final_;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;static {System.out.println("BBB 静态代码块被执行");}}final class AAA {//一般来说,如果一个类已经是final类了,就没有必要再将方法修饰成final方法//public final void cry() {}}
final应用实例
1、请编写一个程序,能够计算圆形的面积。要求圆周率为3.14。赋值的位置3个方式都写一下
package com10.final_;public class FinalExercise01 {public static void main(String[] args) {Circle circle = new Circle(5.0);System.out.println("面积=" + circle.calArea());}}class Circle {private final double PI;// = 3.14;private double radius;{PI = 3.14;}//构造器public Circle(double radius) {this.radius = radius;//PI = 3.14;}public double calArea() {return PI * radius * radius;}}
2、下面代码正确么,为什么
package com10.final_;public class FinalExercise02 {public static void main(String[] args) {}}class Something { //FinalExercise02.javapublic int addOne(final int x) { //下面的代码是否有误,为什么?++x; //错误,原因是不能修改 final x的值return x + 1; //这里是可以.}}