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

本文涉及的产品
访问控制,不限时长
简介: 从本章节开始就是Java进阶部分内容,从本章节开始开发Java使用 IDEA 开发工具!

final 关键字


final关键字


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


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

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


常量


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



抽象类与接口


抽象类



抽象类的理解:




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


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

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


  1. 面试题(判断题):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父类编程,父类是比子类更抽象的。

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

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

  }

  }

  1. 接口在开发中的作用?


  • 接口是不是完全的? 是
  • 而我们以后正好要求,面向抽象编程。
  • 面向抽象编程这句话以后可以修改为:面向接口编程。
  • 有了接口就有了可插拔。可插拔表示扩展力很强。不是焊接死的。
  • 主板和内存条之间有插槽,这个插槽就是接口,内存条坏了,可以重新买一个换下来。这叫做高扩展性。(低耦合度。)
  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                      简类名


  1. package语法:


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


import


  1. import 什么时候不需要?
    java.lang不需要。
    同包下不需要。
    其它一律都需要。
  2. 怎么用?
  • import  完整类名;
  • import  包名.;           只能到类名那一级,只能指定某个类的类名
    import  java.util.Scanner; //  java.util.Scanner 完整类名。
    Scanner 是  类名      java.util 是  包名
  1. 同学的疑问:包名.*  这样是不是效率比较低。
  • 这个效率不低,因为编译器在编译的时候,会自动把 变成具体的类名,import java.util.类名;

day 22天



访问控制权限


访问控制权限


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


public     公开


protected 受保护


默认


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


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


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


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


访问控制修饰符

本类

同包

子类

任意位置

public(公开的)

可以访问

可以

可以

可以

protected(受保护的)

可以访问

可以

可以

不可以

默认

可以

可以

不可以

不可以

private(私有的)

可以

不可以

不可以

不可以


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



5.3 访问控制权限修饰符可以修饰什么?
属性(4个都能用)


方法(4个都能用)


类(public和默认能用,其它不行。)


接口(public和默认能用,其它不行。)

object 类


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


  1. 目前为止我们只需要知道这几个方法即可:
  • 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方法已经重写了。


  1. 源代码长什么样?
  • 源代码如下:

public String toString() {

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

}

  • 源代码上toString()方法的默认实现是:类名@对象的内存地址转换为十六进制的形式
  • SUN公司设计toString()方法的目的是什么?
  • toString()方法的设计目的是:通过调用这个方法可以将一个“java对象”转换成“字符串表示形式”
  • 其实SUN公司开发java语言的时候,建议所有的子类都去重写toString()方法。
    toString()方法应该是一个简洁的、详实的、易阅读的.
  1. 写一个源代码重写tostring()的方法


equals(object obj)方法


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

public boolean equals(Object obj) {

  return (this == obj);

  }

  1. SUN公司设计equals方法的目的是什么?
  • 以后编程的过程当中,都要通过equals方法来判断两个对象是否相等。
  • equals方法是判断两个对象是否相等的。
  1. Object类给的这个默认的equals方法够不够用?
  • 在Object类中的equals方法当中,默认采用的是“ == ”判断两个java对象内存地址是否相等。
  • 而“ == ”判断的是两个java对象的内存地址,我们应该判断两个java对象的内容是否相等。所以老祖宗的equals方法不够用,需要子类重写equals。
  • 判断两个java对象是否相等,不能使用“ == ”,因为“ == ”比较的是两个对象的内存地址。
  1. 重写Object类的equals方法:
    怎么重写?
    复制 粘贴  相同的返回值类型、相同的方法名、相同的形式参数列表。


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


  1. IDEA中生成tostring与equals方法: alt+insert  搜索  tostring  或者  equals
  2. 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方法来判断是否相等。
    以上是规矩
  1. 测试 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 { }

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

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

  if(i % 2 == 0){

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

  }

}


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

finalize  可以记录销毁时机


hashcode(方法)【了解】


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

public native int hashCode();

  • 这个方法不是抽象方法,带有native关键字,底层调用C++程序。
  • hashCode()方法返回的是哈希码:实际上就是一个java对象的内存地址,经过哈希算法,得出的一个值。
    所以 hashCode() 方法的执行结果可以等同看做一个java对象的内存地址。
  1. 测试 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. 什么是内部类?
    内部类:在类的内部又定义了一个新的类。被称为内部类。


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


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


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


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


匿名内部类

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


  • 案例如下:


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

}

}


相关实践学习
消息队列+Serverless+Tablestore:实现高弹性的电商订单系统
基于消息队列以及函数计算,快速部署一个高弹性的商品订单系统,能够应对抢购场景下的高并发情况。
云安全基础课 - 访问控制概述
课程大纲 课程目标和内容介绍视频时长 访问控制概述视频时长 身份标识和认证技术视频时长 授权机制视频时长 访问控制的常见攻击视频时长
相关文章
|
2月前
|
Java 索引
java基础(13)String类
本文介绍了Java中String类的多种操作方法,包括字符串拼接、获取长度、去除空格、替换、截取、分割、比较和查找字符等。
36 0
java基础(13)String类
|
14天前
|
Java 测试技术 开发者
Java零基础-indexOf(String str)详解!
【10月更文挑战第14天】Java零基础教学篇,手把手实践教学!
102 65
|
3月前
|
Kubernetes jenkins 持续交付
从代码到k8s部署应有尽有系列-java源码之String详解
本文详细介绍了一个基于 `gitlab + jenkins + harbor + k8s` 的自动化部署环境搭建流程。其中,`gitlab` 用于代码托管和 CI,`jenkins` 负责 CD 发布,`harbor` 作为镜像仓库,而 `k8s` 则用于运行服务。文章具体介绍了每项工具的部署步骤,并提供了详细的配置信息和示例代码。此外,还特别指出中间件(如 MySQL、Redis 等)应部署在 K8s 之外,以确保服务稳定性和独立性。通过本文,读者可以学习如何在本地环境中搭建一套完整的自动化部署系统。
69 0
|
1天前
|
存储 Java 程序员
Java基础的灵魂——Object类方法详解(社招面试不踩坑)
本文介绍了Java中`Object`类的几个重要方法,包括`toString`、`equals`、`hashCode`、`finalize`、`clone`、`getClass`、`notify`和`wait`。这些方法是面试中的常考点,掌握它们有助于理解Java对象的行为和实现多线程编程。作者通过具体示例和应用场景,详细解析了每个方法的作用和重写技巧,帮助读者更好地应对面试和技术开发。
19 4
|
14天前
|
Java 测试技术 开发者
Java零基础-indexOf(String str)详解!
【10月更文挑战第13天】Java零基础教学篇,手把手实践教学!
35 1
|
19天前
|
安全 Java 测试技术
Java零基础-StringBuffer 类详解
【10月更文挑战第9天】Java零基础教学篇,手把手实践教学!
19 2
|
1月前
|
Java
Java Object 类详解
在 Java 中,`Object` 类是所有类的根类,每个 Java 类都直接或间接继承自 `Object`。作为所有类的超类,`Object` 定义了若干基本方法,如 `equals`、`hashCode`、`toString` 等,这些方法在所有对象中均可使用。通过重写这些方法,可以实现基于内容的比较、生成有意义的字符串表示以及确保哈希码的一致性。此外,`Object` 还提供了 `clone`、`getClass`、`notify`、`notifyAll` 和 `wait` 等方法,支持对象克隆、反射机制及线程同步。理解和重写这些方法有助于提升 Java 代码的可读性和可维护性。
|
1月前
|
IDE Java 开发工具
Java“未封闭的 String 表达式”怎么解决
要解决Java中的“未封闭的 String 表示”问题,需检查并修正字符串字面量,确保每个字符串被正确地用双引号括起来。若字符串跨越多行,可使用字符串连接操作符(+)或引入文本块(JDK 13 及以上版本)。这能帮助避免语法错误,并使代码更整洁易读。
|
29天前
|
存储 安全 Java
【一步一步了解Java系列】:认识String类
【一步一步了解Java系列】:认识String类
24 2
|
2月前
|
安全 Java API
【Java面试题汇总】Java基础篇——String+集合+泛型+IO+异常+反射(2023版)
String常量池、String、StringBuffer、Stringbuilder有什么区别、List与Set的区别、ArrayList和LinkedList的区别、HashMap底层原理、ConcurrentHashMap、HashMap和Hashtable的区别、泛型擦除、ABA问题、IO多路复用、BIO、NIO、O、异常处理机制、反射
【Java面试题汇总】Java基础篇——String+集合+泛型+IO+异常+反射(2023版)