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;
}
}