java--面向对象高级

一.类变量与类方法

类变量也叫静态变量由static修饰；

->会被此类所有对象共享的变量

1.在jdk内存的哪里?

->加载类信息时，在堆中生成class实例的最后，放在堆空间，被所有对象指向->jdk8以后

->加载类信息时，在方法区的静态域 ->jdk8以前

2.共识

->被同一类所有对象共享

->在类加载时生成，所以没有创建对象实例也能访问

3.语法

定义：访问修饰符 static 数据类型 名称；

访问：类名.类变量名；对象名.类变量名

遵守相关访问权限。

4.细节

->实例变量不能用类名.类变量名访问。

->类变量随着类消亡而消亡。

5.类方法

调用：满足访问规则后，通过类.类方法名或者对象名.类方法名

->静态方法就可以访问静态属性、方法。

->方法不涉及对象成员

注意：

->结构信息储存在方法区

->类方法中无this参数等与对象相关的关键字

二.理解main方法语法

理解：

->main方法时java虚拟机在调用，所以访问权限是public ；

->java虚拟机执行main方法时不需要创建对象，所以是static的

->执行程序时，通过命令行，传入String类型的数组参数

->虚拟机不需要返回什么

->可以直接使用静态成员

三.代码块

定义

->属于类中的成员，类似于方法，将逻辑语句封装在方法体中，{}围起来

->加载类时、创建对象时隐式调用。

（static）{

​ 代码

​ };(分号可以省略)

->分为静态的和非静态的

理解

->对构造器补充机制，可以做初始化操作

->如果多个构造器都有重复语句，可以抽取到初始化块中，提高代码重用性

->创建对象时加载代码块内容。

四.单例设计模型

1.静态方法、属性的经典使用

2.设计模式（23）是大量的实践总结和理论优化之后优选的代码结构、编程风格，解决问题的思考方式–套路

->是什么？

项目系统中对某类只有一个对象实例，该类只提供一个取得其对象实例的方法

->饿汉式

1.）构造器私有化—防止直接new

2.) 在类的内部创建对象—static

3.）向外暴露一个静态的公共方法-getInstance,静态的才保证不用再new ,直接类名.方法名调用

类一旦加载，对象就创建好了—可能造成资源 浪费

->懒汉式

->构造器私有化

->定义一个static静态属性对象–q

->定义静态公共方法，如果q指向null就new一个对象

->存在线程安全问题（线程）

五.final关键字

修饰：类、属性、方法、局部变量

使用情景

->类不希望被继承

->不希望方法被子类重写、覆盖

->不希望某属性，某局部变量被修改

细节

->字母一般为大写，字母间用_连接

->定义赋值/构造器赋值/代码块赋值

->修饰静态属性时，不能在构造器中赋值

->final类可以实例化对象

->非final类里的final方法不能被重写可以被继承

->不能修饰构造器

->final\static搭配使用不会导致类的加载，底层优化

->包装类，String是final的，不能被继承

->可以修饰方法的参数

六.抽象类

介绍

对于父类方法不确定性—>设置为没有方法体的抽象方法、抽象类(abstract)

一般抽象类被继承，子类来冲写方法

在设计模式相关地方使用

细节

1.不能被实例化

2.可以没有abstract方法，却有实现的方法

3.只修饰类、方法

4.抽象类还是类，可以有成员、构造器、静态属性、静态方法

5.一个类继承了抽象类，这个类需要实现（重写）他所有的抽象方法，除非他自己也是抽象类

6.抽象方法不能让private、final、static修饰

7.抽象方法中有不抽象的方法时调用查找满足动态绑定，所以从子类开始找。

使用场景

模板设计模式

七.接口

介绍

定义

给出一些没有实现的方法，封装到一起，到某个类要使用的时候，把这些情况写出来

语法

interface 接口名{

​ 属性

​ 方法

}

class 类名 implement 接口{

​ 自己的属性

​ 自己的方法

​ 必须实现接口的抽象方法------在接口中抽象方法可以省略abstract关键字

}jdk8以后接口可以有默认方法、静态方法的具体实现，需要default关键字修饰

场景介绍

比较规范，使用、管理统一

细节

1.接口不被实例化

2.接口所有方法是public方法

3.一个普通类实现接口，就必须将接口的所有方法实现

4.抽象类实现接口时，可以不把所有的方法实现

5.一个类可以实现多个接口class implements iv,ic;

6.接口的属性，只能是final的，而且是public static final修饰符

7.接口不能继承其他类，但是可以继承多个别的接口

8.接口修饰符只能是public或者默认

接口的实现->对单继承的补充

“like a”的逻辑关系“实现解耦？集合源码理解”

接口与多态

9.方法的形参是接口时，实现接口的类的对象实例可以被传入。—多态参数

10.接口类型变量可以指向实现接口的类的实例

11.多态数组

12.接口多态传递：

接口a->接口b->类-----a可以引用类对象（类似于向上引用）

八.内部类*

基本介绍

一个类的内部完整嵌套了另一个类。被嵌套的类称为内部类，嵌套其他类的类称为外部类。

最大特点是可以访问私有属性，体现包含关系。

4种内部类

1.定义在方法的内部->(有无类名)局部内部类、匿名内部类

2.定义在外部类的成员位置上->（有无static）成员内部类、静态内部类

4.外部类仅仅能在方法创建内部类对象，然后调内部类的方法

1.局部内部类

1.可以访问外部类的所有成员，包括私有的

2.不能添加访问修饰符，因为他的地位为局部变量，但是可以用final修饰，不被继承。

3.作用域仅仅在定义他的方法中或代码块中

4.本质是类，遵从类的其他属性

5.外部其他类不能访问局部内部类，外部类在作用域内通过创建对象访问局部内部类

6.外部类和局部内部类重名时，默认就近原则，访问外部类成员===》外部类名.this.成员（外部类.this本质是外部类的对象）

2.*匿名内部类

1.语法：

new 类或接口(参数){

​ 类体；

}.方法**；**

2.类名是系统分配不能直接看到，同时是一个对象

3.使用一次，不再使用。

4.jdk底层立即马上创建实例，并把地址返回给引用的变量

5.匿名的内部类的参数列表会传递给构造器

6.动态绑定和运行类型一致

3.成员内部类

1.可以访问外部类所有成员，在外部类的方法中也可以创建成员内部类的对象

2.可以添加访问修饰符

3.外部类访问内部类：创建成员内部类对象、使用相关属性（包括私有的）、方法

4.外部其他类访问：

->outer.inner a = outer.new inner();

->在外部类写个方法，返回inner

的实例对象

5.重名，访问遵循就近原则。外部类属性：外部类名.this.成员

4.静态内部类

1.static修饰，可以访问外部类的静态成员，不能访问非静态成员

2.可以加访问修饰符

3.作用域：整个外部类体

4.外部其他类访问

->创建对象、通过类名直接访问

->写方法可以返回静态内部类的的对象实例：外部类名.方法

类的五大成员

属性、方法、构造器、代码块、内部类

九.Object类详解

1.equals方法

”==运算符“

->用于判断基本类型与引用类型

->基本类型的值相等->引用类型的地址是否相等(是不是一个对象)

”equals方法“

->用于判断引用类型

->判断内容是否相同

->“sdf”.equals(“sdf”);

->判断自己写的类的对象时需要在所在类重写equals()方法，否则使用Object类中方法则仍为==判断。

2.hashcode

六个小结：

1.）提高具有哈希结构的容器效率

2.）同一对象的不同引用哈希值一样

3.）引用不同对象，哈希值（整数）不一样

4.）哈希值主要根据地址来的，但不等价于地址

5.）哈希值是将内部地址转换成一个整数来实现

6.）集合中，学重写

3.toString

默认返回 -> 全类名（包名+类名）+@+哈希值的16进制(获得全类名：getClass().getName() 转换16进制Integer.toHexString()😉

重写后，默认把对象属性输出

直接输出对象时，toString方法被默认调用

4.finalize

1.）对象被回收时，系统自动调用finalize方法，可以重写

2.）对象没有任何引用时，jvm认为他是垃圾，会使用垃圾回收机制来销毁对象，销毁前会调用finalize方法。

3.）不是一旦变成垃圾，就会被回收，而是有自己的gc算法

4.）自己主动调用：System.gc();

十.其他

1.断点调试

1.）断点调试运行状态

2.)可以看Java底层源代码的执行过程，提高程序员水平

F7跳入方法

F8逐行执行

shift+F8跳出方法

F9执行到下一个断点

2.currentTimeMillis()

返回当前时间（返回long类型的）