42-面对对象编程（高级部分）1
2024-06-04 07:03:56
42-面对对象编程（高级部分）1
- 类变量
- 快速入门
- 类变量的内存图
- 类变量定义
- 类变量的访问
- 类变量使用注意事项
- 类方法
- 基本介绍
- 类方法的调用
- 类方法的经典使用场景
- 类方法使用注意事项
- 类成员课堂练习
- main方法
- main 方法语法说明
- 注意事项
- main动态传值
- 代码块
- 基本介绍
- 基本语法
- 代码块的好处
- 代码块使用细节
- 课堂练习
- 单例设计模式
- 设计模式
- 单例(单个的实例)：
- 单例模式应用实例
- 饿汉式
- 懒汉式
- final关键字
- 基本介绍
- final注意事项
- final课堂练习
- 抽象类(abstract)
- 引例
- 快速入门
- 抽象类介绍
- 抽象类注意事项
- 抽象类课堂练习
- 抽象模板模式
类变量
快速入门
package com.hspedu.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 { //类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 + " 加入了游戏..");}
}类变量的内存图
注：static变量是对象共享不管static变量在哪，共识：（1）static变量 是同一个类所有对象共享（2）static类变量，在类加载的时候就生成了
类变量定义
类变量也叫静态变量/静态属性，是该类的所有对象共享的变量，任何一个该类的对象去访问它时，取到的都是相同的值，同样任何一个该类的对象去修改它时，修改的也是同一个变量，这个从前面的图也可以看出来
语法：
访问修饰符 static 数据类型 变量名;
static 访问修饰符 数据类型 变量名;
类变量的访问
类名.变量名
或 对象名.类变量名
(静态变量的访问修饰符的访问权限和范围和普通属性是一样的)
package com.hspedu.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 = "韩顺平教育";//普通属性/普通成员变量/非静态属性/非静态成员变量/实例变量private int num = 10;}类变量使用注意事项
- 当我们需要让某一个类的所有对象都共享一个变量时，就可以考虑使用类变量（静态变量）：比如：定义学生类，统计所有学生共交多少钱。
- 类变量与实例变量（普通属性）区别：
类变量时该类的所有对象共享的，而实例变量是每个对象独享的 - 加上static称为类变量或静态变量，否则称为实例变量/普通变量/非静态变量
- 类变量可以通过类名.类变量名，但java设计者推荐我们使用 类名.类变量名 方式访问[前提是满足访问修饰符的访问权限和范围]
- 实例变量不能通过类名.类变量名方式访问
- 类变量是在类加载时就初始化了,也就是说,即使你没有创建对象,只要类加载了,就可以使用变量了.
- 类变量的生命周期是随类加载开始,随着类消亡而销毁
类方法
基本介绍
类方法也叫静态方法
形式如下:
访问修饰符 static 数据返回类型 方法名(){};
static 访问修饰符 数据返回类型 方法名(){};
类方法的调用
使用方法:类名.方法名 或者 对象名.类方法名
package com.hspedu.static_;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;//累积到}public static void showFee() {System.out.println("总学费有:" + Stu.fee);}
}类方法的经典使用场景
- 当方法中不涉及到任何和对象相关的成员,则可以将方法设计成静态方法,提高开发效率
- 比如:工具类中的方法utils
Math类,Arrays类,Collections集合类,看源码 - 小结:在程序员实际开发,往往会将一些通用的方法设计成静态方法,这样我们不需要创建对象就可以使用了,比如打印一维数组,冒泡排序,完成某个计算任务等…
类方法使用注意事项
- 类方法和普通方法都是随着类的加载而加载将结构信息储存在方法区
类方法中无this的参数
普通方法中隐含着this的参数 - 类方法可以通过类名调用，也可以通过对象名调用
- 普通方法和对象有关，需要通过对象名调用，比如：对象名.方法名(参数),不能通过类名调用.
- 类方法中不允许使用和对象有关的关键字,比如this和super.普通方法(成员方法)可以
- 类方法(静态方法)中只能访问静态变量或静态方法
- 普通成员方法,既可以访问非静态发成员,也可以访问静态成员
小结:静态方法只能访问静态的成员,非静态的方法可以访问静态成员和非静态成员(必须遵守访问权限)
package com.hspedu.static_;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();//错误}//普通成员方法，既可以访问 非静态成员，也可以访问静态成员//小结: 非静态方法可以访问 静态成员和非静态成员public void ok() {//非静态成员System.out.println(n1);say();//静态成员System.out.println(n2);hello();}
}类成员课堂练习
main方法
main 方法语法说明
public static void main(String[] args){}
- java虚拟机需要调用类的mian()方法,所以该方法的访问权限必须时public
- java虚拟机在执行main()方法时不必创建对象,所以该方法 必须时static
- 该方法接受String类型的数组参数
- java执行的程序 参数1 参数2 参数3
(在java执行程序的时候传入参数)
注意事项
- 在mian()方法中,我们可以直接调用mian ()方法所在类的静态成员
- 但是不能直接访问该类中的非静态成员,必须创建该类的一个实例对象后,才能通过这个对象去访问类中的非静态成员(其他静态方法一样)
ackage com.hspedu.main_;public class Main01 {//静态的变量/属性private static String name = "韩顺平教育";//非静态的变量/属性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();}
}main动态传值
在idea如何传值
代码块
基本介绍
代码块又称为初始化块,属于类中的成员[即是类的一部分],类似于方法,将逻辑语句封装在方法体中,通过{}包围起来
但和方法不同的是,没有方法名,返回,没有参数,只有方法体,而且不通过对象或类显示调用,而是在加载类时,或创建对象时隐式调用
基本语法
[修饰符]{代码块
};
注:
- 修饰符可选,要写的话,也只能写static
- 代码块分为两类,使用static修饰符的脚静态代码块,没有static修饰的,叫普通代码块
- 逻辑语句可以为任何逻辑语句(输入,输出,方法调用,判断等)
- ; 号可以写上,也可以省略
代码块的好处
- 相当于另外一种形式的构造器(对构造器的补充机制,可以做初始化的操作)
- 场景:如果多个构造器中都有重复的语句,可以抽取到初始化块中,提高代码复用性
eg:
package com.hspedu.codeblock_;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;}
}代码块使用细节
- static代码块也叫静态代码块,作用就是对类进行初始化,而且它随着类的加载而执行,并且只会执行一次
- 类是什么时候被加载的;
①创建对象实例时(new)
②创建子类对象实例,父类 也会被加载
③使用类的静态成员时(静态属性和静态方法) - 普通的代码块,在创建对象实例时,会被隐式的调用.被创建一次,就会调用一次
如果只是使用类的静态成员时,普通代码块并不会执行
package com.hspedu.codeblock_;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);//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}
}- 创建一个对象时,在类调用顺序是:
①调用静态代码块和静态属性初始化(注: 静态代码块和静态属性初始化调用的优先级是一样的,如果有多个静态代码块和多个静态变量初始化,则按他们定义的顺序调用)
②调用普通代码块和普通属性的初始化(注: 普通代码块和普通属性初始化调用的优先级一样,如果有多个普通代码块和多个普通变量初始化,则按他们定义的顺序调用)
③调用构造器
package com.hspedu.codeblock_;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() 构造器被调用");}}- 构造方法(构造器)的最前面其实隐含了super()和调用普通代码块,新写一个类演示,静态相关的代码块,属性初始化,在类加载时,就执行完毕,因此是优先于构造器和普通代码块执行的
package com.hspedu.codeblock_;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() 构造器被调用....");}
}- 我们看一下创建一个子类时(继承关系),他们的静态代码块,静态属性初始化,普通代码块,普通属性初始化,构造方法的调用顺序:
①父类的静态代码块和静态属性初始化(优先级一样,按顺序执行)
②子类的静态代码块和静态属性初始化(优先级一样,按顺序执行)
③父类的普通代码块和普通属性初始化(优先级一样,按顺序执行)
④父类的构造方法
⑤子类的普通代码块和普通属性初始化(优先级一样,按顺序执行)
⑥子类的构造方法 - 静态代码块只能直接调用静态成员(静态属性和静态方法),普通代码块可以调用任意成员
package com.hspedu.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}
}课堂练习
单例设计模式
设计模式
在大量的实践中总结和理论化之后优选的代码结构,编程风格,以及解决问题的思考方式
单例(单个的实例)：
- 所谓的单例设计模式,就是采取一定的方法保证在整个的软件系统中,对某个类只能存在一个对象实例,并且该类只提供一个取得其对象的方法
- 单例模式有两种方式:①饿汉式②懒汉式
单例模式应用实例
步骤:
- 构造器私有化 => 防止直接new
- 类的内部创建对象
- 向外暴露一个静态的公共方法
- 代码实现
饿汉式
package com.hspedu.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 {private String name;//public static int n1 = 100;//为了能够在静态方法中，返回 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 + '\'' +'}';}
}懒汉式
package com.hspedu.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 {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 + '\'' +'}';}
}
final关键字
基本介绍
fianl中文意思:最后的最终的
final可以修饰类,属性,方法和局部变量
在某些情况下,程序员可能有以下需求,就会用到final:
- 当不希望类被继承时,可以用final修饰
- 当不会希望父类的某个方法被子类覆盖/重写时,可以用final修饰
- 当不希望类的某个属性的值被修改,可以用final修饰
- 当不希望某个局部变量被修改,可以使用final修饰
package com.hspedu.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注意事项
- final修饰的属性又叫常量,一般用XX_XX_XX来命名
- final修饰的属性在定义时,必须赋初值,并且以后不能再修改,赋值可以再如下位置之一:
①定义时:如public final double TAX = 0.08;
②在构造器中
③在代码块中 - 如果final修饰的属性是静态的,则初始化的位置只能是
①定义时
②在静态代码块,不能在构造器中赋值 - final类不能继承,但是可以实例化对象
- 如果类不是final类,但是含有final方法,则该方法虽然不能重写,但是可以被继承
package com.hspedu.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 ;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 { }- 一般来说,如果一个类已经时final类了,就没有必要再将方法修饰成fianl方法
- final不能修饰构造方法(构造器)
- final和static往往搭配使用,效率更高,不会导致类加载,底层编译器做了优化处理
- 包装类(Integer,Double,Float,Boolean等都是final),String也是final类
package com.hspedu.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课堂练习
package com.hspedu.final_;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;}
}
抽象类(abstract)
引例
package com.hspedu.abstract_;public class Abstract01 {public static void main(String[] args) {}
}abstract class Animal {private String name;public Animal(String name) {this.name = name;}//思考：这里eat 这里你实现了，其实没有什么意义//即： 父类方法不确定性的问题//===> 考虑将该方法设计为抽象(abstract)方法//===> 所谓抽象方法就是没有实现的方法//===> 所谓没有实现就是指，没有方法体//===> 当一个类中存在抽象方法时，需要将该类声明为abstract类//===> 一般来说，抽象类会被继承，有其子类来实现抽象方法.
// public void eat() {// System.out.println("这是一个动物，但是不知道吃什么..");
// }public abstract void eat() ;
}当父类的某些方法,需要声明,但是又不确定如何实现,可以将其声明为抽象方法,那么这个类就是抽象类
快速入门
当父类的一些方法不能确定时,可以用abstract来修饰该方法,这个方法就是抽象方法.用abstract来修饰该类就是抽象类
抽象类介绍
- 用abstract关键字来修饰一个类时,这个类就叫抽象类
访问修饰符 abstract 类名 {}
- 用abstract关键字来修饰一个方法时,这个方法就是抽象方法
访问修饰符 abstract 返回类型 方法名(参数);//没有方法体
- 抽象类的价值更多是在于设计,是设计者设计好后,让子类继承并实现抽象类
- 抽象类,是考官比较爱问的知识点,在框架和设计模式使用较多
抽象类注意事项
- 抽象类不能被实例化
- 抽象类不一定要包含abstract方法.也就是说,抽象类可以没有abstract方法
- 一旦包含了abstract方法,则这个类必须声明为abstract
- abstract只能修饰类和方法,不能修饰属性和其他的
package com.hspedu.abstract_;public class AbstractDetail01 {public static void main(String[] args) {//抽象类，不能被实例化//new A();}
}
//抽象类不一定要包含abstract方法。也就是说,抽象类可以没有abstract方法
//，还可以有实现的方法。
abstract class A {public void hi() {System.out.println("hi");}
}
//一旦类包含了abstract方法,则这个类必须声明为abstract
abstract class B {public abstract void hi();
}
//abstract 只能修饰类和方法，不能修饰属性和其它的
class C {// public abstract int n1 = 1;
}- 抽象类可以有任意成员(因为抽象类还是类)比如:非抽象方法,构造器,静态属性等
- 抽象方法不能有主体,即不能实现
- 如果一个类继承了抽象类,则它必须实现抽象类的所有抽象方法,除非它自己也声明为abstract类
- 抽象方法不能使用private,final和static来修饰,因为这些关键字都是和重写相违背的
package com.hspedu.abstract_;public class AbstractDetail02 {public static void main(String[] args) {System.out.println("hello");}
}
//抽象方法不能使用private、final 和 static来修饰，因为这些关键字都是和重写相违背的
abstract class H {public abstract void hi();//抽象方法
}//如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类
abstract class E {public abstract void hi();
}
abstract class F extends E {}
class G extends E {@Overridepublic void hi() { //这里相等于G子类实现了父类E的抽象方法，所谓实现方法，就是有方法体}
}//抽象类的本质还是类，所以可以有类的各种成员
abstract class D {public int n1 = 10;public static String name = "韩顺平教育";public void hi() {System.out.println("hi");}public abstract void hello();public static void ok() {System.out.println("ok");}
}抽象类课堂练习
package com.hspedu.abstract_;public class AbstractExercise01 {public static void main(String[] args) {//测试Manager jack = new Manager("jack", 999, 50000);jack.setBonus(8000);jack.work();CommonEmployee tom = new CommonEmployee("tom", 888, 20000);tom.work();}
}package com.hspedu.abstract_;abstract public class Employee {private String name;private int id;private double salary;public Employee(String name, int id, double salary) {this.name = name;this.id = id;this.salary = salary;}//将work做成一个抽象方法public abstract void work();public String getName() {return name;}public void setName(String name) {this.name = name;}public int getId() {return id;}public void setId(int id) {this.id = id;}public double getSalary() {return salary;}public void setSalary(double salary) {this.salary = salary;}
}package com.hspedu.abstract_;public class CommonEmployee extends Employee{public CommonEmployee(String name, int id, double salary) {super(name, id, salary);}@Overridepublic void work() {System.out.println("普通员工 " + getName() + " 工作中...");}
}package com.hspedu.abstract_;public class Manager extends Employee {private double bonus;public Manager(String name, int id, double salary) {super(name, id, salary);}public double getBonus() {return bonus;}public void setBonus(double bonus) {this.bonus = bonus;}@Overridepublic void work() {System.out.println("经理 " + getName() + " 工作中...");}
}抽象模板模式
需求:
- 有多个类,完成不同任务job
- 要求能够得到各自完成任务的时间
- 请编程实现
设计一个抽象类(Template),能够完成如下功能:
- 编写方法caleTime(),可以计算某段代码的耗时时间
- 编写抽象方法code()
- 编写一个子类Sub,继承抽象类Template,并实现code()方法
- 编写一个测试类TestTemplate,看看是否好用
package com.hspedu.abstract_;public class TestTemplate {public static void main(String[] args) {AA aa = new AA();aa.calculateTime(); //这里还是需要有良好的OOP基础，对多态BB bb = new BB();bb.calculateTime();}
}package com.hspedu.abstract_;abstract public class Template { //抽象类-模板设计模式public abstract void job();//抽象方法public void calculateTime() {//实现方法，调用job方法//得到开始的时间long start = System.currentTimeMillis();job(); //动态绑定机制//得的结束的时间long end = System.currentTimeMillis();System.out.println("任务执行时间 " + (end - start));}
}package com.hspedu.abstract_;public class AA extends Template {//计算任务//1+....+ 800000@Overridepublic void job() { //实现Template的抽象方法joblong num = 0;for (long i = 1; i <= 800000; i++) {num += i;}}// public void job2() {// //得到开始的时间
// long start = System.currentTimeMillis();
// long num = 0;
// for (long i = 1; i <= 200000; i++) {// num += i;
// }
// //得的结束的时间
// long end = System.currentTimeMillis();
// System.out.println("AA 执行时间 " + (end - start));
// }
}
package com.hspedu.abstract_;public class BB extends Template{public void job() {//这里也去，重写了Template的job方法long num = 0;for (long i = 1; i <= 80000; i++) {num *= i;}}
}42-面对对象编程（高级部分）1相关推荐
- 基于java面对对象编程范式笔记
https://www.icourse163.org/learn/NJU-1002246017?tid=1002791118#/learn/content 科学思维&工程思维 科学思维:限制条 ...
- 面对对象编程(OOP, Object Oriented Programming)及其三个基本特性
一千个读者,一千个哈姆雷特.对于面对对象编程,书上都会告诉我们它有三个基本特性,封装,继承,多态,但谈起对这三点的见解,又是仁者见仁智者见智,感觉还是得多去编程中体验把 . 面向对象编程(OOP, O ...
- java俄罗斯方块视频_[VIP视频]【A0233】java面对对象编程-俄罗斯方块视频教程 高清视频 百度云 百度网...
Java视频教程名称:java面对对象编程-俄罗斯方块视频教程 俄罗斯方块视频教程 $ X0 X1 Z: W4 P3 T e. m3 q百度网盘下载链接: . M% x- I- V5 p( J 游 ...
- SIGIA_4P python学习 列表 字典 集合 面对对象编程 闭包 装饰器 函数式编程 作用域 异常处理
SIGIA_4P python学习 列表 字典 集合 面对对象编程 闭包 装饰器 函数式编程 作用域 异常处理 本文连接 简介 SIGIA_4P 网址 a. 课程OKR Objectives and ...
- 易语言java类_易语言面对对象编程
易语言面对对象编程---类的创建与使用 面对对象编程,可以说是当前最流行的编程方式,当前流行的面对对象的编程语言很多,如:C++.JAVA等等.易语言3．8版推出后,同样紧跟编程语言发展的方向,也开始 ...
- java面对对象编程
因为这直接关系到你阅读设计模式的速度和理解质量. 接下来我将简单介绍java中面对对象编程的一些基础知识. 1,类和修饰符 public class ClassTest{public ClassTes ...
- LabVIEW上位机学习 面对对象编程实例项目源码 与下位机PLC
LabVIEW上位机学习 面对对象编程实例项目源码 与下位机PLC,工厂MES通讯,数据库,NI vision视觉等开发,及操作者框架源码可运行,想学习面对对象的可以参考 ID:16199647294 ...
- 六、Scala从入门到精通一一面对对象编程（初级）
目录 6.面向对象编程 6.1.类与对象 6.1.1.Scala语言是面向对象的 6.1.2.快速入门-面向对象的方式解决养猫问题 6.1.3.类与对象的区别和联系 6.1.4.如何定义类 6.1.5 ...
- python面对对象编程-------5：获取属性的四种办法：@property, __setattr__(__getattr__) ,descriptor...
一:最基本的属性操作 1 class Generic: 2 pass 3 4 g= Generic() 5 6 >>> g.attribute= "value" ...
- c不是面向对象编程语言 所以不具有面对,go 学习笔记之go是不是面向对象语言是否支持面对对象编程?...
面向对象编程风格深受广大开发者喜欢,尤其是以 C++, Java 为典型代表的编程语言大行其道,十分流行! 有意思的是这两中语言几乎毫无意外都来源于 C 语言,却不同于 C 的面向过程编程,这种面向对 ...
最新文章
- 汽车票销售系统mysql,jsp683客运汽车票网上售票系统mysql
- 自动化运维之CentOS7下PXE+Kickstart+DHCP+TFTP+HTTP无人值守安装系统
- 软件构架实践(第2版)学习笔记
- android之PackageManager简单介绍
- .NET Core实战项目之CMS 第十章 设计篇-系统开发框架设计
- tesorflow 填充‘same’与‘valid’
- 【转】使用PowerApps快速构建基于主题的轻业务应用 —— 入门篇
- php memcached 方法,php操作使用Memcached常用方法代码和例子大全
- WPF 模拟UI 键盘录入
- Python的安装与配置
- JSON入门指南--服务端处理JSON
- Android 如何通过拨号盘暗码启动你的应用
- Onenote插入代码块
- Hotspot 重量级锁ObjectMonitor（一） 源码解析
- java 解析m3u8的实例_m3u8文件完整实例及TS流抓取
- 2017 杭电多校联赛第二场 1003 Maximum Sequence（单调队列）HDU 6047
- 【线性代数复习笔记】同济大学版第三章和第四章 矩阵的初等变换与线性方程组与向量组的线性相关性
- 波长、子载波、载波容量和波长容量、频谱效能（针对光通信来说）
- LOJ2402 [THUPC2017] 天天爱射击 / Shooting 二分查找+主席树
- 经济金融领域简单数学建模和分析：MATLAB成本曲线方程和销售收入直线方程