final 关键字
final关键字
复习:局部变量没有初始值,需要程序员手动赋值,成员变量有默认值。
- final修饰的类无法继承。
- final修饰的方法无法覆盖。
- final修饰的变量只能赋一次值。
- final修饰的引用一旦指向某个对象,则不能再重新指向其它对象,该引用指向对象内部的数据是可以修改的。
内存图理解:
- final修饰的实例变量必须手动初始化,不能采用系统默认值。(赶在系统赋默认值之前修改也是可以的)
常量
- final修饰的实例变量一般和static联合使用,称为常量。常量在方法区中
public static final double PI = 3.1415926;
总结:final表示最终的,不可修改的。
抽象类与接口
抽象类
抽象类的理解:
- 抽象类怎么定义?
在class前添加abstract关键字就行了。
- 抽象类是无法实例化的,无法创建对象的,所以抽象类是用来被子类继承的。
- final和abstract不能联合使用,这两个关键字是对立的。
- 抽象类的子类可以是抽象类。也可以是非抽象类。
- 抽象类虽然无法实例化,但是抽象类有构造方法,这个构造方法是供子类使用的。
- 抽象类中不一定有抽象方法,抽象方法必须出现在抽象类中,且方法不能有方法体。
- 抽象方法怎么定义?
public abstract void doSome(); 不能有大括号{}
- (重点)一个非抽象的类,继承抽象类,必须将抽象类中的抽象方法进行覆盖/重写/实现。
- 到目前为止,只是学习了抽象类的基础语法,一个类到底声明为抽象还是非抽象,这个以后慢慢来吧。写代码多的时候,自然就理解了。
- 面试题(判断题):java语言中凡是没有方法体的方法都是抽象方法。
- 不对,错误的
- Object类中就有很多方法都没有方法体,都是以“;”结尾的,但他们都不是抽象方法,例如:
public native int hashCode();
这个方法底层调用了C++写的动态链接库程序。
前面修饰符列表中没有:abstract。有一个native,表示调用JVM本地程序。
接口
implements
- 接口的基础语法:
- 接口是一种“引用数据类型”
- 接口是完全抽象的。
- 接口怎么定义:[修饰符列表] interface 接口名{}
- 接口支持多继承。
- 接口中只有常量+抽象方法。(注意看jdk的版本,若为jdk8版本的话这句话不适用,接口中还有其它方法。)
- 接口中所有的元素都是public修饰的
- 接口中抽象方法的public abstract可以省略。
- 接口中常量的public static final可以省略。
- 接口中方法不能有方法体。
day21天 (笔记只体现核心的东西即可,方便以后复习)
- 接口在开发中的作用
- 重点:解耦合
- 面向接口编程,可以降低程序的耦合度,提高程序的扩展力,符合OCP开发原则。
- 接口的使用离不开多态机制。(接口+多态才可以达到降低耦合度。)
- 接口可以解耦合,解开的是谁和谁的耦合!!!
- 任何一个接口都有调用者和实现者。
- 接口可以将调用者和实现者解耦合。
- 调用者面向接口调用。
- 实现者面向接口编写实现。
- 以后进行大项目的开发,一般都是将项目分离成一个模块一个模块的,模块和模块之间采用接口衔接,降低耦合度。
- 注意:接口在开发中的作用,类似于多态在开发中的作用。
多态:面向抽象编程,不要面向具体编程,降低程序的耦合度,提高程序的扩展力。
/*
public class Master{
public void feed(Dog d){}
public void feed(Cat c){}
//假设又要养其它的宠物,那么这个时候需要再加1个方法。(需要修改代码了)
//这样扩展力太差了,违背了OCP原则(对扩展开放,对修改关闭。)
}
*/
public class Master{
public void feed(Animal a){
// 面向Animal父类编程,父类是比子类更抽象的。
//所以我们叫做面向抽象编程,不要面向具体编程。
//这样程序的扩展力就强。
}
}
- 接口在开发中的作用?
- 接口是不是完全的? 是
- 而我们以后正好要求,面向抽象编程。
- 面向抽象编程这句话以后可以修改为:面向接口编程。
- 有了接口就有了可插拔。可插拔表示扩展力很强。不是焊接死的。
- 主板和内存条之间有插槽,这个插槽就是接口,内存条坏了,可以重新买一个换下来。这叫做高扩展性。(低耦合度。)
- 接口在现实世界中是不是到处都是呢?
螺栓和螺母之间有接口
灯泡和灯口之间有接口
笔记本电脑和键盘之间有接口(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
- 注意事项:
- 第一:package出现在java源文件第一行。
- 第二:带有包名怎么编译? javac -d . xxx.java
- 第三:怎么运行? java 完整类名
补充:以后说类名的时候,如果带着包名描述,表示完整类名。如果没有带包,描述的话,表示简类名。
java.util.Scanner 完整类名
Scanner 简类名
- package语法:
- package 公司域名.项目名称.模块名.功能名称 ;
import
- import 什么时候不需要?
java.lang不需要。
同包下不需要。
其它一律都需要。 - 怎么用?
- import 完整类名;
- import 包名.; 只能到类名那一级,只能指定某个类的类名
import java.util.Scanner; // java.util.Scanner 完整类名。
Scanner 是 类名 java.util 是 包名
- 同学的疑问:包名.* 这样是不是效率比较低。
- 这个效率不低,因为编译器在编译的时候,会自动把 变成具体的类名,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 类
- JDK类库的根类
- 这个老祖宗类中的方法我们需要先研究一下,因为这些方法都是所有子类通用的。任何一个类默认继承Object。就算没有直接继承,最终也会间接继承。
- 目前为止我们只需要知道这几个方法即可:
- protected Object clone() // 负责对象克隆的。
- int hashCode() // 获取对象哈希值的一个方法。
- boolean equals(Object obj) // 判断两个对象里的内容是否相等
- String toString() // 将对象转换成字符串形式
- protected void finalize() // 垃圾回收器负责调用的方法
API
- 什么是API
- 应用程序编程接口。(Application Program Interface)
- 整个JDK的类库就是一个 javase 的 API 。
- 每一个API都会配置一套API帮助文档。
- SUN公司提前写好的这套类库就是API。(一般每一份API都对应一份API帮助文档。)
tostring()方法
- 以后所有类的toString()方法是需要重写的。
- 重写规则,越简单越明了就好。
- System.out.println(引用); 这里会自动调用 “引用” 的toString()方法。
- String类是SUN写的,toString方法已经重写了。
- 源代码长什么样?
- 源代码如下:
public String toString() {
return this.getClass().getName() + "@" + Integer.toHexString(hashCode());
}
- 源代码上toString()方法的默认实现是:类名@对象的内存地址转换为十六进制的形式
- SUN公司设计toString()方法的目的是什么?
- toString()方法的设计目的是:通过调用这个方法可以将一个“java对象”转换成“字符串表示形式”
- 其实SUN公司开发java语言的时候,建议所有的子类都去重写toString()方法。
toString()方法应该是一个简洁的、详实的、易阅读的.
- 写一个源代码重写tostring()的方法
equals(object obj)方法
- 以后所有类的equals方法也需要重写,因为Object中的equals方法比较的是两个对象的内存地址,我们应该比较内容,所以需要重写。
- 默认的equals方法的源代码如下:
public boolean equals(Object obj) {
return (this == obj);
}
- SUN公司设计equals方法的目的是什么?
- 以后编程的过程当中,都要通过equals方法来判断两个对象是否相等。
- equals方法是判断两个对象是否相等的。
- Object类给的这个默认的equals方法够不够用?
- 在Object类中的equals方法当中,默认采用的是“ == ”判断两个java对象内存地址是否相等。
- 而“ == ”判断的是两个java对象的内存地址,我们应该判断两个java对象的内容是否相等。所以老祖宗的equals方法不够用,需要子类重写equals。
- 判断两个java对象是否相等,不能使用“ == ”,因为“ == ”比较的是两个对象的内存地址。
- 重写Object类的equals方法:
怎么重写?
复制 粘贴 相同的返回值类型、相同的方法名、相同的形式参数列表。
- 重写规则:自己定,主要看是什么和什么相等时表示两个对象相等。
- 基本数据类型比较时用: ==
- 对象和对象比较:调用 equals 方法
- String类是SUN编写的,所以String类的equals方法重写了。
- 以后判断两个字符串是否相等,最好不要使用==,要调用字符串对象的equals方法。
注意:重写equals方法的时候要彻底。
- IDEA中生成tostring与equals方法: alt+insert 搜索 tostring 或者 equals
- 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 类
- String类已经重写了equals方法,比较两个字符串不能使用==,必须使用equals。equals是通用的。
- String类已经重写了toString方法。
- 总结:
- java中基本数据类型比较是否相等,使用 ==
- java中所有的引用数据类型,统一使用equals方法来判断是否相等。
以上是规矩
- 测试 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 的深层理解
- 重写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()方法 (了解内容)
- JDK 9 版本开始方法过时,了解即可
- 在Object类中的源代码:
protected void finalize() throws Throwable { }
- GC: 负责调用finalize()方法
- finalize()方法只有一个方法体,里面没有代码,而且这个方法是protected修饰的。
- 这个方法不需要程序员手动调用,JVM的垃圾回收器负责调用这个方法。不像equals toString,equals和toString()方法是需要你写代码调用的。
- finalize()方法的执行时机:当一个java对象即将被垃圾回收器回收的时候,垃圾回收器负责调用finalize()方法。
- finalize()方法实际上是SUN公司为java程序员准备的一个时机,垃圾销毁时机。
如果希望在对象销毁时机执行一段代码的话,这段代码要写到finalize()方法当中。 - 提示:
java中的垃圾回收器不是轻易启动的,垃圾太少,或者时间没到,种种条件下,有可能启动,也有可能不启动。 - 建议启动的方法:
// 有一段代码可以建议垃圾回收器启动。
if(i % 2 == 0){
System.gc(); // 建议启动垃圾回收器。(只是建议,可能不启动,也可能启动。 启动的概率高了一些。)
}
}
- 项目开发中有这样的业务需求:所有对象在JVM中被释放的时候,请记录一下释放时间!!!
静态代码块 可以记录类加载时机
finalize 可以记录销毁时机
hashcode(方法)【了解】
- 在Object中的hashCode方法是怎样的?
public native int hashCode();
- 这个方法不是抽象方法,带有native关键字,底层调用C++程序。
- hashCode()方法返回的是哈希码:实际上就是一个java对象的内存地址,经过哈希算法,得出的一个值。
所以 hashCode() 方法的执行结果可以等同看做一个java对象的内存地址。
- 测试 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:类没有名字,以后想重复使用,不能用。
匿名内部类
- 写个案例来验证匿名内部类
- 案例如下:
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);
}
}