Java 笔记 12
抽象类
面试题:
- 1、面向对象的基本特征:封装、继承、多态
- 2、面向对象的特征:封装、继承、多态、抽象
- 抽象:abstract
- 是具体的反义词
- 和模糊,不确定,不清晰有的类似
- 1、什么情况下会用到抽象?
- 当我们在声明一个父类时,某个/些方法的实现不清楚,或者说无法给出具体的实现,
- 要等到具体的子类中才能给出具体的实现,那么这样的方法,就可以声明为抽象方法。
- 抽象方法没有方法体
- 2、抽象方法
- 语法格式:
- 【其他修饰符】 abstract 返回值类型 方法名(【形参列表】);
- 3、抽象类
- 如果一个类中包含了抽象方法,那么这个类必须是一个抽象类。
- 语法格式:
- 【其他修饰符】 abstract class 抽象类名{
-
【其他修饰符】 abstract 返回值类型 方法名(【形参列表】);
- }
- 例如:我们声明一个图形类:Graphic
-
我们知道在图形这个事物中,不管是什么图形,都有两个特征:(1)求面积(2)求周长
- 4、抽象类的特点
- (1)抽象类不能实例化,不能直接创建对象或者说,不能创建抽象类的对象
- (2) 如果子类继承了抽象类,必须重写父类的所有的抽象方法,否则子类也得是一个抽象类
- (3)抽象类也有构造器,这个构造器不是为了创建抽象类自己的对象用的,而是为子类创建对象服务的
- (4)抽象父类与子类的对象之间可以构成多态引用
- (5)抽象类中也可能没有抽象方法,目的就是不能你创建它的对象
- 如果一个类中包含了抽象方法,那么这个类必须是一个抽象类。
1、abstract:抽象的
- 2、可以修饰什么?
- (1)类
- (2)方法
- 3、修饰类的话,和那些修饰符不能一起使用
- 类:public和缺省
- final
- abstract和final不能一起修饰类。
- 4、修饰方法,和那些修饰符不能一起使用
- 方法:4种权限修饰符
-
static,final,abstract,native
- (1)final,abstract不行 因为final不能被重写
- (2)static,abstract不行 因为static不能被重写
- (3)native,abstract不行 因为都没有方法体,不知道是什么情况,会有歧义
- (4)private,abstract不行 因为private不能被重写
模板设计模式
设计模式?
- 解决问题的套路,代码结构。
- Java中常用的设计模式有23种。
- JavaSE阶段给大家普及几个:
- (1)模板设计模式
- (2)单例设计模式:(*****)脱稿
- (3)工厂设计模式:(**)会调用工厂类的方法
- (4)代理设计模式:(***)模仿
- (5)迭代器设计模式
- (6)装饰者设计模式
- 能看懂代码,能认识
- (1)模板设计模式
- ppt模板,论文模板,简历模板,请假条模板
- 当你解决一下问题时,总体的算法的结构/步骤是确定的,但是其中的一步或几步的代码的具体实现是不确定的,
- 得使用者自己来确定。
- 举例:
- 编写一个类,包含一个方法,可以统计 你执行任意代码的运行时间
- 步骤:
- (1)获取开始时系统时间
- (2)执行xxxx
- (3)获取结束时系统时间
- (4)计算时间差
- 时间的单位:毫秒
- 提示:System.currentTimeMillis()
java.lang.Object
Java中规定:
- 如果一个类没有显式声明它的父类(即没有写extends xx),那么默认这个类的父类就是java.lang.Object。
- 类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。
- 如何理解根父类?
- (1)所有对象(包括数组)都实现这个类的方法。
- 换句话说Object类中声明的方法,所有引用数据类型(包括数组)中都有
- (2)所有类的对象的实例化过程,都会调用Object的实例初始化方法
- (3)所有的对象都可以赋值给Object的变量
- 或者说Object类型的变量,形参,数组可以接收任意类型的对象。
toString()
java.lang.Object类型的方法:
- (1)public String toString()
-
用于返回对象的信息,类似于我们原来写的getInfo(),建议所有子类重写。
-
如果没有重写:返回的字符串由类名(对象是该类的一个实例)、at 标记符“@”和此对象哈希码的无符号十六进制表示组成。
- 如果你直接打印一个对象,或者用对象与字符串进行拼接,默认情况下会自动调用这个对象的toString()
- 如何重写? Alt + Shift + S 选择Generate toString。。。。
getClass()
java.lang.Object的方法:
- (2)public final Class getClass():返回此 Object 的运行时类。
public class TestMethod2 {
public static void main(String[] args) {
Father f = new Son();
//此时f就有两个类型,编译时类型,Father,运行时类型,Son
Class c = f.getClass();
System.out.println(c);
Object obj = 12;//Integer
System.out.println(obj.getClass());
}
}
class Father{
}
class Son extends Father{
}
protected void finalize()
java.lang.Object的方法:
- (3)protected void finalize():
- 当垃圾回收器确定不存在对该对象的更多引用时,由对象的垃圾回收器(GC)调用此方法。 即不是程序员手动调用
- 子类重写 finalize 方法,以配置系统资源或执行其他清除。
- 什么情况下调用?
- ①某个对象确定要被回收了,比喻成“留临终遗言”
- ②Java程序员是否无法确定具体哪个时间点会调用
- ③它是由GC调用的
- ④每一个对象,finalize()只能被调用一次。
- 如果某个对象在被GC回收之前复活了,那么再死的时候,就不会调用finalize()
- 当我们在finalize()方法中又让一个引用指向了当前对象this,那么这个对象就复活。
- 面试题:final,finalize,finally的区别?
hashCode(), equals(Object obj)
java.lang.Object的方法:
- (4)
- public int hashCode():返回该对象的哈希码值。支持此方法是为了提高哈希表的性能。
-
哈希码值是用这个对象的信息(属性值),通过某种算法,计算出来的一个int值。就好比我们身份证号码代表一个人的信息。
-
理想状态下,那么每一个对象都应该有一个唯一的哈希码值。
-
现实中,两个不同的对象,可能它的哈希码值相同。
-
认为:
-
如果两个对象的哈希码值不同,就可以认为这个两个对象一定不“相等”,
-
但是,如果两个对象的哈希码值相同,我们不能认为这个两个对象就一定“相等”,可能相同,也可能不同。
- public boolean equals(Object obj):指示其他某个对象是否与此对象“相等”。
-
换句话说,如果最终要确定两个对象是否“相等”要依据equals方法。
- 默认情况下,Object类中实现的equals方法,即如果我们自己写的类,没有重写equals方法的话,那么它的比较是等价于“==”,比较的是对象的“地址值”
- 我们可以选择进行重写:
- (1)当此方法equals被重写时,通常有必要重写 hashCode 方法
- 为什么?
- 因为:
- Java中规定 ①如果两个对象调用equals方法返回true,那么这两个对象的hashCode值必须相同
-
②如果两个对象的hashCode值不同,那么调用equals方法必须是false
-
③如果两个对象的hashCode值相同,那么调用equals方法可能true也可能false
- (2)重写equals方法时,要遵循几个原则
- ①自反性: x.equals(x)一定true
- ②对称性:x.equals(y) 和y.equals(x)结果一样
- ③传递性: x.equals(y)是true,y.equals(z)也是true,那么x.equals(z)一定true
- ④一致性:只要参与equals比较的属性值没有修改过,那么无论何时调用,结果都应该一样
- ⑤对于任何非空引用值 x,x.equals(null) 都应返回 false
public class TestMethod4 {
public static void main(String[] args) {
/* String s1 = "Aa";
String s2 = "BB";
System.out.println(s1.hashCode());//2112
System.out.println(s2.hashCode());//2112
*/
Circle c1 = new Circle();
c1.radius = 1;
Circle c2 = new Circle();
c2.radius = 1;
System.out.println(c1 == c2);//false
System.out.println(c1.equals(c2));//false(重写前) true(重写后)
//回忆
String str1 = new String("hello");
String str2 = new String("hello");
System.out.println(str1 == str2);//false
System.out.println(str1.equals(str2));//true 因为String类型重写了equals方法
System.out.println("----------------------------");
String s1 = "hello";//特殊,因为s1和s2指向同一个常量对象,地址值是同一个
String s2 = "hello";
System.out.println(s1 == s2);//true
System.out.println(s1.equals(s2));//true
}
}
class Circle{
double radius;
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
long temp;
temp = Double.doubleToLongBits(radius);
result = prime * result + (int) (temp ^ (temp >>> 32));
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Circle other = (Circle) obj;
if (Double.doubleToLongBits(radius) != Double.doubleToLongBits(other.radius))
return false;
return true;
}
}