最近学习Java的总结

Java关键字final有“这是无法改变的”或者“终态的”含义，它可以修饰非抽象类、非抽象类成员方法和变量。

final 用法：

final 修饰属性，表示属性【只能赋值一次】，（1）基本类型：值不能被修改；（2）引用类型：引用不可以被修改该。

final 修饰方法，表示方法不可以重写，但是可以被子类访问（如果方法不是 private 类型话）。

final 修饰类，表示类不可以被继承。

final不能用于修饰构造方法。

static 含义：静态的，被 static 修饰的方法和属性只属于类不属于类的任何对象。

static 用法：

static 可以修饰【内部类】、方法和成员变量。

static【不可以修饰外部类】、【不可以修饰局部变量】（因为 static 本身就是定义为类级别的，所以局部级别的变量是不可以用 static 修饰的）。

static修饰的属性和方法是共享的，属于类所有的

调用：static修饰的属性或方法可以通过类名.去调用

非静态的方法可以访问静态的属性或方法

静态方法中不能访问非静态属性或方法，静态的可以访问静态的类名. 或直接问

垃圾回收机制（GC garbage collection）

静态的属性或方法在垃圾回收时是不能够自动释放的

用public修饰的static成员变量和成员方法本质是全局变量和全局方法，当声明它类的对象市，不生成static变量的副本，而是类的所有实例共享同一个static变量。

static表示不要实例化就可以使用

四个访问修饰符

ublic 同类 子类 同包 不同包 不同类

Protected 同包或者子类中访问

默认的（default） 同包中调用

Private 同一类中使用（最严格的）

面向对象的三大特性：封装 继承 多态

封装：

属性私有化对外提供共有的访问方法

封装的类包括：

私有属性 共有get set方法 无参构造 全参构造

继承：

作用：解决代码重复性问题，把公有的属性和方法提取出来

格式：使用extends关键字

如果子类继承了父类，那么子类具有父类的属性和方法，父类不能访问子类的属性和方法

特性：

1）一个子类只能有一个父类，（单继承特性），一个父类可以有多个子类

2）创建子类对象的时候会把父类的对象一并创建出来

从顶级的对象依次往下创建，最后创建的是最底层的对象

如果不写，在子类的构造方法里会首先调用父类的无参构造方法

3）继承具有可传递性（孙子课可以访问爷爷的属性或方法）

4）任何一个类都有一个继承关系，如果没写默认继承自object，Object是超类，是所有类的父类

5）父类的私有方法或属性子类无法访问。

方法的重载和重写

方法的重载：

定义：方法名相同，参数列表不同

1）参数个数

2）参数类型

3）参数的顺序（参数数据类型）

与返回值无关

意义（作用）：方便方法的调用者记忆方法的名称，在调用者看来相同的方法名干同一件事情。代码上的复杂实现使用的方便

一个类必须有一个构造方法

构造函数不写返回值不代表没有返回值由于返回值类型单一（返回的是本类的类型），所以不用写

作用：1）创建对象，2）并给属性初始化

构造函数的重载的意义：

构造函数只能和构造函数重载和普通函数不可以重载

重载overload，一般是用于在一个类内实现若干重载的方法，这些方法的名称相同而参数形式不同。

方法的重写：（父子类之间）

概念：父类的方法无法满足子类的需求，子类会对父类的方法重写overide

方法的重载和重写的对比

重载 重写

类 同一个类中 有继承关系的父子类中

修饰符 没有要求 父类的修饰符必须比子类的修饰符要严格

返回值类型 没有要求 必须相同

方法名 必须相同 必须相同

参数列表 必须不相同 必须相同

方法体 没有要求 一般不相同

类的加载顺序

同一个类中的加载顺序：（从类到对象的过程）

1.静态属性

2.静态代码块

3.非静态属性

4.非静态代码块

5.构造方法

public class Demo {

public int age;

public static int agg;

public static void Demo(){

System.out.println(“我是静态方法”);

}

public Demo(){

System.out.println(“我是构造方法”);

}

{

System.out.println(“我是非静态属性”+age);

System.out.println("我是非静态块");

}

static {System.out.println(“我是静态属性”+agg);

System.out.println(“我是静态块”);

}

public static void main(String[] args) {

Demo d=new Demo();

}

}

属性加载先于块，块的加载先于构造方法，静态的先于非静态的

有继承关系的两个类的加载顺序

父类静态属性

父类的静态代码块

3.子类的静态属性

4.子类的静态代码块

5.父类的非静态属性

6.父类的非静态块

7.父类的构造方法

8.子类的非静态属性

9.子类的非静态块

10.子类的构造方法

class ParentTest{

public static String PARENT_STATIC_FIELD= “父类-静态属性”; // 父类-静态块

static {

System.out.println(PARENT_STATIC_FIELD);

System.out.println(“父类-静态代码块”);

}

public static String parentField = “父类-非静态属性”; // 父类-非静态块

{

System.out.println(parentField);

System.out.println(“父类-非静态代码块”);

}

public ParentTest() {

System.out.println(“父类—无参构造函数”);

} }

public class InitOderTest extends ParentTest {

public static String STATIC_FIELD = “静态属性”; // 静态块

static { System.out.println(STATIC_FIELD);

System.out.println(“静态代码块”);

}

public String field = “非静态属性”; // 非静态块

{ System.out.println(field);

System.out.println(“非静态代码块”);

}

public InitOderTest() {

System.out.println(“无参构造函数”);

}

public static void main(String[] args) {

InitOderTest test = new InitOderTest();

}

}

设计模式：

23种设计模式 单例设计模式 工厂设计模式 装饰者模式 生产者模式

单例设计模式三步走：

1.构造方法私有化（目的：不能在外部通过new随意创建对象）

2.在类内部创建对象，作为私有静态属性

3.对外提供公有静态的get方法

饿汉模式

//当做属性去

private static SingleDemo sd=new SingleDemo();

private SingleDemo(){

}
//返回singleDemo对象
public static SingleDemo getSingleDemo(){
return SingleDemo.sd;
}

懒汉模式

//当做属性去

private static SingleDemo sd;

private SingleDemo(){

}
//返回singleDemo对象
public static SingleDemo getSingleDemo(){
if(sd==null){
sd=new SingleDemo();
}
return sd;
}