目录
心情感悟
今天东西是真的多，碎片知识点难记又难懂，今天是真的费脑，困的不行了。。。那也得学完，我一想象到周日的考试，心就拔凉。
内容整理
代码块
static静态
外部类
内部类
设计模式：单例模式
箭头函数
知识点
代码块
类的内部结构
五大类：属性。方法、构造器、代码块、内部类
- 代码块又称为初始化块，属于类的成员，它是将一些逻辑语句封装在大括号（体）里。
//代码块
{
}特点
1.代码块没有名字，没有返回值，只有大括号{}，不需要通过对象或者类显示的调用，它会在类加载过创建对象是主动隐式调用。
2.代码块里可以和方法一样进行创建对象等操作
静态代码块
- 一个类被加载时会调用一次，用来做一些初始化操作
- 一个类可以有多个静态块，开发中一般写一个
//静态代码块
static {
System.out.println("静态代码块");
}实例代码块
- 有对象（实例）时才能被执行，每次创建对象（实例）都会被调用一次。
- 一个类可以有多个实例代码块。
//实例代码块
{
System.out.println("实例代码块");
}面试题（高频）
- 当没有继承关系时，执行顺序为：静态块----实例块----构造器
1. 在继承关系中，：父类静态块----子类静态块----父类实例块----父类构造器----子类实例块----子类构造器
2.父类的内容永远比子类的内容先执行，静态块比实例块先执行
static静态
- 可以修饰属性、方法、代码块
- static修饰的结构，不属于任何一个对象，可以用（类名.）直接调用static修饰的属性、方法等
- 其实用对象也可以调用static修饰的结构,但开发中都不用，连提示都没有。
static内存解析
（方法区又叫常量池、：和堆类似的储存空间，储存static修饰的结构等，方法区的结构不会被当成垃圾删除）
1.静态的变量或者静态方法存在于方法区，静态的结构不会被当成垃圾回收
2.不属于任何一个实例的对象，只存在于方法区，调用静态结构直接用类名调用
实例方法（非静态方法）与静态方法之间的相互调用
1.静态方法中！！不可以！！直接调用实例方法，需要创建对象，用（对象.方法名）调用方法
2.实例方法中！！可以！！直接调用静态方法。
- 静态的结构的加载随着类的加载而加载(有类就可以加载)
- 实例方法的加载随着对象的建立而加载（有对象才可以加载）
- 在Java中调用实例方法，必须要有主体，有时候省略了this.
- 实例方法不是一等公民，不能直接嗲用
- 静态方法无论在哪里，都是（类名.方法名）的形式调用，同一个类的静态方法之间可以省略
什么时候需要写静态方法？
工具类
public class Demo01 {
public static void plus(int i,int j){
}
public static void sub(int i,int j){
}
}
填坑
- 接口的常量默认不是只有public，还有static、final
- 开发中，基本上常量的声明几乎都是public、static、final
public interface Inter01 {
//接口的常量默认不是只有public，还有static、final
//开发中，基本上常量的声明几乎都是public、static、final
String STR = "哈哈";
void show();
default void fun(){
}
static void sta(){
}
}
填坑
- 静态方法是没有重写这个概念的，抽象类和接口里的静态方法不能重写
填坑
this 和 super
- 无论是this还是super，都不能再静态结构中使用
原因：
- this.方法、super.方法看上去就是对象调用方法
- 静态结构是属于类的，静态结构是优先于对象就存在的
- this和super必须奥有实例（对象）才能出现
public class Ch04 {
public static void show() {
System.out.println();
}
}
static 静态代码
public class Ch03 {
static String name = "里奥，梅西";
//java中，当变量用完（打印后）会当成垃圾被JNM回收，但static修饰的变量不会被回收。
int age = 20;
String str = "哈哈";
public void fun(){
show();
}
//实例代码块
{
fun();//必须要用对象调用。这里省略了this.
show();
System.out.println(age);
System.out.println(name);
}
//静态代码块
static {
show();
}
public static void show(){
//静态方法
System.out.println("静态方法");
new Ch03().fun();
}
public static void main(String[] args) {
System.out.println(Ch03.name);
//类名.静态方法，即可调用
Ch03.show();
//用对象调静态方法
Ch03 ch03 = new Ch03();
ch03.show();
}
}外部类
定义
- 把两个类写在一个.java文件
- 两个类中有一个public声明的类，类名必须和.java文件的文件名相同。
- 外部类就是两个类
- 生成的.class文件是两个独立的.class
- 开发中尽量不要写外部类，代码可读性极低
public class Ch05 {
int i = 10;
public static void main(String[] args) {
}
}
//外部类
class Outer{
public static void main(String[] args) {
}
}内部类
定义
- 在一个类中进行其他类结构的嵌套操作
- 之前写链表时写过的Node类，主要就是给SuperLinked。我们可以吧Node类定义在SuperLinked类中
内部类是残缺不全的
实例内部类中不可有静态结构，其他的可以
静态内部类不能访问外部类的非静态结构
public class Ch01 {
static {
System.out.println("外部类被加载");
}
//Ch01的 实例内部类
public class Inner{
{
System.out.println("实例内部类被加载");
}
}
//Ch01的 静态内部类
public static class InnerStatic{
static {
System.out.println("静态内部类被加载");
}
}
public static void main(String[] args) {
//实例内部类的对象
Inner inner = new Ch01().new Inner();
//静态内部类的对象
InnerStatic innerStatic = new Ch01.InnerStatic();
}
}设计模式
- 设计模式是人们为软件开发抽象出可重新利用的解决方案，是软件开发工程师之间沟通的行话
面向对象的设计原则
1.开闭原则（Open Close Principle）
对扩展开放，对修改关闭（继承，实现接口）
我们可以通过“抽象约束，封装变化”来实现开闭的原则
通过接口或者抽象类为软件定义一个相对稳定的抽象层
将相同的可变因素封装在相同的具体实现类中，派生一个实体类就可以
2.里氏代换原则
在子类继承父类时，除了子类添加新的方法完成新的功能外，尽量不要重写父类的方法
3.依赖倒转
尽量面向接口编程，不要面向实现类编程
a.每个类尽量提供接口或抽象类，过着两者兼备
b.变量的类型尽量是接口或者是抽象类
c.任何类都不应该从具体的类派生（尽量用多态创建对象）
d.使用继承时，要遵循里氏代换原则
4.接口隔离原则
使用多个隔离的接口（多写接口，别在一个接口中写很多方法
5.迪米特法则
6.合成复用原则
7.单一原则：一个类只做一件事
最简单的设计模式
单例模式
一个类只有一个实例。
思路：
1.别人不能new，构造器私有化,就不能在类的外面同股哟new去实例化
2.在改类的内部产生一个唯一的实例化对象，把它封装成static类型
饿汉式单例模式：
不管以后会不会使用到该实例化对象，先创建了再说，很着急的样子
实现的办法就是直接new实例化
//饿汉式单例模式
public class Ch03 {
//创建一个永远是同一个的对象，可以加final更严谨,也可不加
private static final Ch03 ch03 = new Ch03();
private Ch03(){
}
public static Ch03 getInstance(){
return ch03;//返回的永远是同一个
}
}懒汉式单例模式（延迟加载）
- 什么时候调用getInstance方法，什么时候new实例化
- 懒汉式在多线程环境中是完全错误的，根本不能保证单例的状态。
- 《加锁》后可用
public class Ch04 {
//将自身实例化对象设置为一个属性，现在是没有赋值的
private static Ch04 ch04;
//构造器私有化
private Ch04(){
}
public static Ch04 getInstance(){
if (ch04 == null){
//如果在此处第一次调用时卡了。第二次调用没卡，结果一起进行了new Ch04，变成了多例。 ch04 = new Ch04(); } return ch04;
}
}
面试题（常见）
手写单例模式
内部类实现单例
- 也是懒汉式的一种但是这种懒汉式没有多线程（卡了）的问题
- 结合了饿汉式和懒汉式的优点
- 只要不调用getInstance方法，就不会使用内部类
- 内部类一旦被使用,只会被初始化一次，以后一直用的是INSTANCE静态常量
public class Ch05 {
//构造器私有化
private Ch05(){
}
public static Ch05 getInstance(){
return SingLetonHolder.INSTANCE;
}
private static class SingLetonHolder{
private static final Ch05 INSTANCE = new Ch05();
}
}箭头函数：JDK8的新特性
- 以下内容为JDK8之后的新内容
函数式接口：
- 如果一个接口只有一个抽象方法（可以有其他方法），这个借口就叫函数式接口
- 用注解@FunctionalInterface标注的接口就是函数式接口。
箭头函数这个结构可以分为三部分
- 第一部分，小括号包裹形参，类型不要
- 第二部分，->
- 第三部分，->方法体
() ->System.out.println("重写的show方法...")
当重写的方法体只有一句话时，可以精简到这种
() -> "你好"
当重写的方法只是有一句返回值时，可以精简到这种test(() -> "你好");
箭头函数的几种写法
1.有参数，有返回值
（ i , j ） - > { return i + j ;}
2、有参数，无返回值
( i , j ) - > {
// 方法体
}
- 如果方法体只有一句话 ( i , j ) - >
3、无参数
( ) - > {
方法体
}
public class Ch06 {
public static void test (Inter01 integer01){
System.out.println();
}
public static void main(String[] args) {
// 多态，向上转型
// 接口 对象 = new 实现类
// Inter01 inter01 = new Impl01();
// test(inter01);
// test(new Inter01() {
// @Override
// public String show(int i,int j) {
// return i + "," + j + "匿名实现类重写的show方法...";
// }
// });
}
}