Java进阶部分详解（一）--->final 关键字、Object、String与内部类

final 关键字

final关键字

复习：局部变量没有初始值，需要程序员手动赋值，成员变量有默认值。

1. final修饰的类无法继承。
2. final修饰的方法无法覆盖。
3. final修饰的变量只能赋一次值。
4. final修饰的引用一旦指向某个对象，则不能再重新指向其它对象，该引用指向对象内部的数据是可以修改的。
   内存图理解：

5. final修饰的实例变量必须手动初始化，不能采用系统默认值。（赶在系统赋默认值之前修改也是可以的）

常量

1. final修饰的实例变量一般和static联合使用，称为常量。常量在方法区中
   public static final double PI = 3.1415926;
   总结：final表示最终的，不可修改的。

抽象类与接口

抽象类

抽象类的理解：

1. 抽象类怎么定义？
       在class前添加abstract关键字就行了。

2. 抽象类是无法实例化的，无法创建对象的，所以抽象类是用来被子类继承的。
3. final和abstract不能联合使用，这两个关键字是对立的。
4. 抽象类的子类可以是抽象类。也可以是非抽象类。
5. 抽象类虽然无法实例化，但是抽象类有构造方法，这个构造方法是供子类使用的。
6. 抽象类中不一定有抽象方法，抽象方法必须出现在抽象类中，且方法不能有方法体。
7. 抽象方法怎么定义？
   public abstract void doSome();    不能有大括号{}
8. 
   

• （重点）一个非抽象的类，继承抽象类，必须将抽象类中的抽象方法进行覆盖/重写/实现。
• 到目前为止，只是学习了抽象类的基础语法，一个类到底声明为抽象还是非抽象，这个以后慢慢来吧。写代码多的时候，自然就理解了。

9. 面试题（判断题）：java语言中凡是没有方法体的方法都是抽象方法。

• 不对，错误的
• Object类中就有很多方法都没有方法体，都是以“;”结尾的，但他们都不是抽象方法，例如：
  public native int hashCode();
  这个方法底层调用了C++写的动态链接库程序。
  前面修饰符列表中没有：abstract。有一个native，表示调用JVM本地程序。

接口

implements

• 接口的基础语法：

1. 接口是一种“引用数据类型”
2. 接口是完全抽象的。
3. 接口怎么定义：[修饰符列表] interface 接口名{}
4. 接口支持多继承。
5. 接口中只有常量+抽象方法。（注意看jdk的版本，若为jdk8版本的话这句话不适用，接口中还有其它方法。）
6. 接口中所有的元素都是public修饰的
7. 接口中抽象方法的public abstract可以省略。
8. 接口中常量的public static final可以省略。
9. 接口中方法不能有方法体。

day21天 （笔记只体现核心的东西即可，方便以后复习）

• 接口在开发中的作用

• 重点：解耦合

• 面向接口编程，可以降低程序的耦合度，提高程序的扩展力，符合OCP开发原则。

• 接口的使用离不开多态机制。（接口+多态才可以达到降低耦合度。）

• 接口可以解耦合，解开的是谁和谁的耦合！！！

• 任何一个接口都有调用者和实现者。
• 接口可以将调用者和实现者解耦合。
• 调用者面向接口调用。
• 实现者面向接口编写实现。

• 以后进行大项目的开发，一般都是将项目分离成一个模块一个模块的，模块和模块之间采用接口衔接，降低耦合度。

1. 注意：接口在开发中的作用，类似于多态在开发中的作用。
   多态：面向抽象编程，不要面向具体编程，降低程序的耦合度，提高程序的扩展力。

/*

  public class Master{

  public void feed(Dog d){}

  public void feed(Cat c){}

  //假设又要养其它的宠物，那么这个时候需要再加1个方法。（需要修改代码了）

  //这样扩展力太差了，违背了OCP原则（对扩展开放，对修改关闭。）

  }

  */

public class Master{

  public void feed(Animal a){

  // 面向Animal父类编程，父类是比子类更抽象的。

  //所以我们叫做面向抽象编程，不要面向具体编程。

  //这样程序的扩展力就强。

  }

  }

2. 接口在开发中的作用？

• 接口是不是完全的？ 是
• 而我们以后正好要求，面向抽象编程。
• 面向抽象编程这句话以后可以修改为：面向接口编程。
• 有了接口就有了可插拔。可插拔表示扩展力很强。不是焊接死的。
• 主板和内存条之间有插槽，这个插槽就是接口，内存条坏了，可以重新买一个换下来。这叫做高扩展性。（低耦合度。）

1. 接口在现实世界中是不是到处都是呢？
   螺栓和螺母之间有接口
   灯泡和灯口之间有接口
   笔记本电脑和键盘之间有接口（usb接口，usb接口是不是某个计算机协会制定的协议/规范。）
   接口有什么用？扩展性好。可插拔。
   接口是一个抽象的概念。

类型与类型之间的关系

is a（继承）、has a（关联）、like a（实现）implemen

is a（是一个）：
Cat is a Animal（猫是一个动物）
凡是能够满足is a的表示“继承关系”
A extends B

has a（有一个）：
I has a Pen（我有一支笔）
凡是能够满足has a关系的表示“关联关系”
关联关系通常以“属性”的形式存在。
A{
B b;
}

like a（像一个）:
Cooker like a FoodMenu（厨师像一个菜单一样）
凡是能够满足like a关系的表示“实现关系”
实现关系通常是：类实现接口。
A implements B

抽象类和接口有什么区别？

在这里我们只说一下抽象类和接口在语法上的区别。
至于以后抽象类和接口应该怎么进行选择，通过后面的项目去体会/学习。

• 抽象类是半抽象的。
  接口是完全抽象的。  
• 抽象类中有构造方法。
  接口中没有构造方法。
• 接口和接口之间支持多继承。
  类和类之间只能单继承。
• 一个类可以同时实现多个接口。
  一个抽象类只能继承一个类（单继承）。
• 接口中只允许出现常量和抽象方法。（应该jdk的版本，jdk1.8版本不适用）
• 这里先透露一个信息：

• 以后接口使用的比抽象类多。一般抽象类使用的还是少。
• 接口一般都是对“行为”的抽象。

chapter17

package和import

package

1. 注意事项：

• 第一：package出现在java源文件第一行。
• 第二：带有包名怎么编译？           javac  -d . xxx.java
• 第三：怎么运行？                 java  完整类名
  补充：以后说类名的时候，如果带着包名描述，表示完整类名。如果没有带包，描述的话，表示简类名。
  java.util.Scanner       完整类名
  Scanner                      简类名

2. package语法：

• package  公司域名.项目名称.模块名.功能名称 ;

import

1. import 什么时候不需要？
   java.lang不需要。
   同包下不需要。
   其它一律都需要。
2. 怎么用？

• import  完整类名;
• import  包名.;           只能到类名那一级，只能指定某个类的类名
  import  java.util.Scanner; //  java.util.Scanner 完整类名。
  Scanner 是  类名      java.util 是  包名

3. 同学的疑问：包名.*  这样是不是效率比较低。

• 这个效率不低，因为编译器在编译的时候，会自动把 变成具体的类名，import java.util.类名;

day 22天

访问控制权限

访问控制权限

5.1 访问控制权限都有哪些？ 4个。
private 私有

public     公开

protected 受保护

默认

5.2  以上的4个访问控制权限：控制的范围是什么？  可以看下面的表格
private 表示私有的，只能在本类中访问

public 表示公开的，在任何位置都可以访问

“默认”表示只能在本类，以及同包下访问。

protected表示只能在本类、同包、子类中访问。

访问控制修饰符

范围从大到小排序：public > protected > 默认 > private

5.3 访问控制权限修饰符可以修饰什么？
属性（4个都能用）

方法（4个都能用）

类（public和默认能用，其它不行。）

接口（public和默认能用，其它不行。）

object 类

1. JDK类库的根类

• 这个老祖宗类中的方法我们需要先研究一下，因为这些方法都是所有子类通用的。任何一个类默认继承Object。就算没有直接继承，最终也会间接继承。

2. 目前为止我们只需要知道这几个方法即可：

• protected Object clone()   // 负责对象克隆的。
• int hashCode() // 获取对象哈希值的一个方法。
• boolean equals(Object obj)       // 判断两个对象里的内容是否相等
• String toString()  // 将对象转换成字符串形式
• protected void finalize()  // 垃圾回收器负责调用的方法

API

1. 什么是API

• 应用程序编程接口。（Application Program Interface）
• 整个JDK的类库就是一个 javase 的 API 。
• 每一个API都会配置一套API帮助文档。
• SUN公司提前写好的这套类库就是API。（一般每一份API都对应一份API帮助文档。）

tostring()方法

1. 以后所有类的toString()方法是需要重写的。

• 重写规则，越简单越明了就好。
• System.out.println(引用);    这里会自动调用 “引用” 的toString()方法。
• String类是SUN写的，toString方法已经重写了。

2. 源代码长什么样？

• 源代码如下：

public String toString() {

  return this.getClass().getName() + "@" + Integer.toHexString(hashCode());

}

• 源代码上toString()方法的默认实现是：类名@对象的内存地址转换为十六进制的形式
• SUN公司设计toString()方法的目的是什么？

• toString()方法的设计目的是：通过调用这个方法可以将一个“java对象”转换成“字符串表示形式”
• 其实SUN公司开发java语言的时候，建议所有的子类都去重写toString()方法。
  toString()方法应该是一个简洁的、详实的、易阅读的.

3. 写一个源代码重写tostring（）的方法

equals（object obj）方法

1. 以后所有类的equals方法也需要重写，因为Object中的equals方法比较的是两个对象的内存地址，我们应该比较内容，所以需要重写。
2. 默认的equals方法的源代码如下：

public boolean equals(Object obj) {

  return (this == obj);

  }

3. SUN公司设计equals方法的目的是什么？

• 以后编程的过程当中，都要通过equals方法来判断两个对象是否相等。
• equals方法是判断两个对象是否相等的。

4. Object类给的这个默认的equals方法够不够用？

• 在Object类中的equals方法当中，默认采用的是“ == ”判断两个java对象内存地址是否相等。
• 而“ == ”判断的是两个java对象的内存地址，我们应该判断两个java对象的内容是否相等。所以老祖宗的equals方法不够用，需要子类重写equals。
• 判断两个java对象是否相等，不能使用“ == ”，因为“ == ”比较的是两个对象的内存地址。

5. 重写Object类的equals方法：
   怎么重写？
   复制 粘贴  相同的返回值类型、相同的方法名、相同的形式参数列表。

• 重写规则：自己定，主要看是什么和什么相等时表示两个对象相等。
• 基本数据类型比较时用： ==
• 对象和对象比较：调用 equals 方法
• String类是SUN编写的，所以String类的equals方法重写了。
• 以后判断两个字符串是否相等，最好不要使用==，要调用字符串对象的equals方法。
  注意：重写equals方法的时候要彻底。

6. IDEA中生成tostring与equals方法： alt+insert  搜索  tostring  或者  equals
7. equals（object o）方法重新格式如下：

public boolean equals(Object obj) {

    // 如果obj是空，直接返回false

    // 如果obj不是一个MyTime，没必要比较了 ，直接返回false

if(obj == null || !(obj instanceof MyTime)){

  return false;

}

  // 如果this和obj保存的内存地址相同，没必要比较了，直接返回true。

// 内存地址相同的时候指向的堆内存的对象肯定是同一个。

if(this == obj){

  return true;

}

    // 程序能够执行到此处说明什么？

// 说明obj不是null，obj是MyTime类型。

MyTime t = (MyTime)obj;

return this.year == t.year && this.month == t.month && this.day == t.day ;

}

}

• 当方法体中只有一行代码时，大括号可以省略
• 用IDEA开发不需要写，可以快捷生成。

String 类

1. String类已经重写了equals方法，比较两个字符串不能使用==，必须使用equals。equals是通用的。
2. String类已经重写了toString方法。
3. 总结：

• java中基本数据类型比较是否相等，使用 ==
• java中所有的引用数据类型，统一使用equals方法来判断是否相等。
  以上是规矩

4. 测试 string 类中的 equals、tostring方法有没有重写

public class Test03{

public static void main(String[] args){

// 大部分情况下，采用这样的方式创建字符串对象

String s1 = "hello";

String s2 = "abc";

// 实际上String也是一个类。不属于基本数据类型。

// 既然String是一个类，那么一定存在构造方法。

String s3 = new String("Test1");

String s4 = new String("Test1");

// new两次，两个对象内存地址，s3保存的内存地址和s4保存的内存地址不同。

// == 判断的是内存地址。不是内容。

System.out.println(s3 == s4); // false

// 比较两个字符串能不能使用双等号？

// 不能，必须调用equals方法。

// String类已经重写equals方法了。

System.out.println(s3.equals(s4)); // true

// String类有没有重写toString方法呢？

String x = new String("动力节点");

// 如果String没有重写toString()方法，输出结果：java.lang.String@十六进制的地址

// 经过测试：String类已经重写了toString()方法。

System.out.println(x.toString()); //动力节点

System.out.println(x); //动力节点

}

}

equals 的深层理解

1. 重写equals方法要彻底的例子：（看懂原理，自己能够写出来）

public class Test05{

public static void main(String[] args){

 

// 多态（自动类型转换。）

Object o1 = new String("hello world!");

Object o2 = new User();

Object o3 = new Address();

User u1 = new User("zhangsan", new Address("北京","大兴区","11111"));

User u2 = new User("zhangsan", new Address("北京","大兴区","11111"));

System.out.println(u1.equals(u2)); // true

User u3 = new User("zhangsan", new Address("北京","朝阳区","11112"));

System.out.println(u1.equals(u3)); // false

}

}

class User{

// 用户名

String name;

// 用户的住址

Address addr;

public User(){

}

public User(String name, Address addr){

this.name = name;

this.addr = addr;

}

// 重写equals方法

// 重写规则：当一个用户的用户名和家庭住址都相同，表示同一个用户。

// 这个equals判断的是User对象和User对象是否相等。

public boolean equals(Object obj){

// 用户名和用户名相同，住址和住址相同的时候，认定是同一个用户。

if(obj == null || !(obj instanceof User)) return false;

if(this == obj) return true;

 

User u = (User)obj;

if(this.name.equals(u.name) && this.addr.equals(u.addr)){

  return true;

}

return false;

}

}

class Address{

String city;

String street;

String zipcode;

public Address(){

 

}

public Address(String city,String street,String zipcode){

this.city = city;

this.street = street;

this.zipcode = zipcode;

}

// 注意：这里并没有重写equals方法。

// 这里的equals方法判断的是：Address对象和Address对象是否相等。

public boolean equals(Object obj){

if(obj == null || !(obj instanceof Address)) return false;

if(this == obj) return true;

// 怎么算是家庭住址相同呢？

// 城市相同，街道相同，邮编相同，表示相同。

Address a = (Address)obj;

if(this.city.equals(a.city)

  && this.street.equals(a.street)

  && this.zipcode.equals(a.zipcode)){

  return true;

}

return false;

}

}

finalize()方法 （了解内容）

1. JDK 9 版本开始方法过时，了解即可
2. 在Object类中的源代码：

protected void finalize() throws Throwable { }

3. GC： 负责调用finalize()方法
4. finalize()方法只有一个方法体，里面没有代码，而且这个方法是protected修饰的。
5. 这个方法不需要程序员手动调用，JVM的垃圾回收器负责调用这个方法。不像equals toString，equals和toString()方法是需要你写代码调用的。
6. finalize()方法的执行时机：当一个java对象即将被垃圾回收器回收的时候，垃圾回收器负责调用finalize()方法。
7. finalize()方法实际上是SUN公司为java程序员准备的一个时机，垃圾销毁时机。
   如果希望在对象销毁时机执行一段代码的话，这段代码要写到finalize()方法当中。
   
8. 提示：
   java中的垃圾回收器不是轻易启动的，垃圾太少，或者时间没到，种种条件下，有可能启动，也有可能不启动。
9. 建议启动的方法：

  // 有一段代码可以建议垃圾回收器启动。

  if(i % 2 == 0){

  System.gc(); // 建议启动垃圾回收器。（只是建议，可能不启动，也可能启动。    启动的概率高了一些。）

  }

}

10. 项目开发中有这样的业务需求：所有对象在JVM中被释放的时候，请记录一下释放时间！！！
    静态代码块   可以记录类加载时机

finalize  可以记录销毁时机

hashcode(方法)【了解】

1. 在Object中的hashCode方法是怎样的？

public native int hashCode();

• 这个方法不是抽象方法，带有native关键字，底层调用C++程序。
• hashCode()方法返回的是哈希码：实际上就是一个java对象的内存地址，经过哈希算法，得出的一个值。
  所以 hashCode() 方法的执行结果可以等同看做一个java对象的内存地址。

2. 测试 hashcode（） 方法的案例：

public class Test07{

public static void main(String[] args){

Object o = new Object();

int hashCodeValue = o.hashCode();

// 对象内存地址经过哈希算法转换的一个数字。可以等同看做内存地址。

System.out.println(hashCodeValue); //798154996

MyClass mc = new MyClass();

int hashCodeValue2 = mc.hashCode();

System.out.println(hashCodeValue2); //1392838282

MyClass mc2 = new MyClass();

System.out.println(mc2.hashCode()); // 523429237

}

}

class MyClass

{

}

内部类

注意：能看懂别人写的程序即可，尽量不要使用匿名内部类进行开发，使用类实现接口的方式进行开发

1. 内部类

1. 什么是内部类？
   内部类：在类的内部又定义了一个新的类。被称为内部类。

2. 内部类的分类：
   静态内部类：类似于静态变量
   实例内部类：类似于实例变量
   局部内部类：类似于局部变量
3. 使用内部类编写的代码，可读性很差。能不用尽量不用。

4. 匿名内部类是局部内部类的一种。因为这个类没有名字而得名，叫做匿名内部类。

5. 学习匿名内部类主要是让大家以后在阅读别人代码的时候，能够理解。并不代表以后都要这样写。

6. 匿名内部类有两个缺点：
   缺点1：太复杂，太乱，可读性差。
   缺点2：类没有名字，以后想重复使用，不能用。

匿名内部类

7. 写个案例来验证匿名内部类

• 案例如下：

class Test01{

// 静态变量

static String country;

// 该类在类的内部，所以称为内部类

// 由于前面有static，所以称为“静态内部类”

static class Inner1{

}

 

// 实例变量

int age;

// 该类在类的内部，所以称为内部类

// 没有static叫做实例内部类。

class Inner2{

}

// 方法

public void doSome(){

// 局部变量

int i = 100;

// 该类在类的内部，所以称为内部类

// 局部内部类。

class Inner3{

}

}

public void doOther(){

// doSome()方法中的局部内部类Inner3，在doOther()中不能用。

}

// main方法，入口

public static void main(String[] args){

// 调用MyMath中的mySum方法。

MyMath mm = new MyMath();

/*

Compute c = new ComputeImpl();

mm.mySum(c, 100, 200);

*/

 

//合并（这样写代码，表示这个类名是有的。类名是：ComputeImpl）

//mm.mySum(new ComputeImpl(), 100, 200);

 

// 使用匿名内部类，表示这个ComputeImpl这个类没名字了。

// 这里表面看上去好像是接口可以直接new了，实际上并不是接口可以new了。

// 后面的{} 代表了对接口的实现。

// 不建议使用匿名内部类，为什么？

// 因为一个类没有名字，没有办法重复使用。另外代码太乱，可读性太差。

mm.mySum(new Compute(){

  public int sum(int a, int b){

  return a + b;

  }

}, 200, 300);

}

}

// 负责计算的接口

interface Compute{

 

// 抽象方法

int sum(int a, int b);

}

// 你自动会在这里编写一个Compute接口的实现类

/*

class ComputeImpl implements Compute{

// 对方法的实现

public int sum(int a, int b){

return a + b;

}

}

*/

// 数学类

class MyMath{

// 数学求和方法

public void mySum(Compute c, int x, int y){

int retValue = c.sum(x, y);

System.out.println(x + "+" + y + "=" + retValue);

}

}