static

  1. static：静态的
  2. 可以修饰哪些：属性、方法、内部类、代码块
  3. 有了static之后，变量可以分为静态变量和非静态变量

    • 非静态变量：我们又称之为实例变量，每一个对象都会有一套完全独立的非静态变量，每个对象里面的非静态变量若发生更改 ，不会影响到其他对象的非静态变量

    • 静态变量：我们又称之为类变量，这个是跟类相关，与类的对象没有关系，这个静态变量将会在当前这个类的所有对象中共享（独此一份）,可以通过类名调用

    • 静态变量的初始化时机：在类加载（使用类）的时候就会进行初始化

4.修饰方法

  • 静态方法也是可以直接通过类名调用
  • 静态方法也是在加载类的时候会提前加载方法

注意：

静态方法不能访问非静态属性,或者调用非静态方法

普通方法是可以调用静态属性和静态方法的

5.什么时候用

  • 什么时候用静态变量：

    假如某个变量是不随对象更改而更改的，那就可以采用静态的
    常量一般也是设置成静态的

  • 什么时候用静态方法：

    一般在工具类中，方法一般是设置成静态的，Math、Arrays…
    在类中如果说要设计操作一个静态属性的方法，那这个方法一般我们也是设置成静态的

final

  • final可以修饰变量（常量），一般常量会被设置成：static final

  • final可以修饰方法，方法不可重写

  • final可以修饰类，类不可继承

  • final修饰局部变量

abstract（抽象）

abstract修饰的类的称之为抽象类。

  1. 抽象类里面可以定义属性、方法（普通或者抽象的）；

  2. 抽象类里面可以定义构造方法；

  3. 抽象类不能创建对象，只能由子类去继承；

  4. 若一个类中有抽象方法，那么这个类必须是抽象类，子类中要实现该方法(抽象子类不用实现)；

    抽象方法不包含方法体，不能被private、final修饰。

    1
    修饰符 abstract 返回值类型 方法名([参数列表]);

  5. 抽象类和抽象方法是不能设置成final的；

  6. 抽象类里面不一定要包含抽象方法。

当我们在设计的时候，对于当前类的某些行为不能在类中确定，可能要在其子类中进行具体的实现，那么此时就可以考虑将当前类设置抽象类，对应的方法就是抽象方法

interface（接口）

  1. 接口和类是同等级的

  2. 关键字：interface

  3. 接口里面可以定义什么：

    公共的抽象方法

    公共的静态常量，通过接口名调用

    不能定义构造方法，接口不能创建对象

    JDK1.8:可以定义静态方法、默认方法

  4. 一个类可以同时实现多个接口

    • 实现多个接口时：calss A implements B,C,D..
    • 既有继承又有实现接口：class A extends B implements C,D,…

  5. 接口与接口之间也是可以继承，并且可以多继承

    接口可以多继承：interface A extends B,C,…

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public interface Fly {

	public static final int MAX_HEIGHT = 10000;
	int MIN_HEIGHT = 100;
	
	// 接口中的方法都是公共抽象方法
	public abstract void fly();
	// 即便不写也会默认为公共的抽象方法
	void f();
	
	// 接口不能定义构造方法，接口不能创建对象
	// public Fly() {}
	
	static void show() {
		System.out.println("静态方法");
	}
	
	default void print() {
		System.out.println("默认方法");
	}
	
}

对于接口的理解认识：

java里面的继承单继承，但是有的时候难免一个类要继承多个类，这可以通过接口去实现多继承

哈士奇 extends 狗，加菲猫 extends 猫，
哈士奇是不是狗？ 是
加菲猫是不是猫？ 是
继承表现出来的是 is-a关系，“是不是”

接口是对一些方法的抽象，接口表现出来的就是“能不能”

接口本质，就是一套规范，使用它的类必须遵守这套规范

单例模式

设计模式

设计模式代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。
总结： “套路”

单例模式

所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例。

实现：
1.私有化构造方法
2.内部创建对象
3.提供公共的方法返回该对象

饿汉模式
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 饿汉模式：上来就给你把对象创建出来
public class Wife {

// 2.内部创建对象
private static Wife wife = new Wife();	

// 1.私有化构造方法
private Wife() {
  
}

// 3.提供公共的方法返回该对象
public static Wife getInstance() {
	return wife;
}

}
懒汉模式
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// 懒汉模式：在使用的时候创建对象，在用的时候去创建
public class Wife2 {

  // 2、先不创建
  private static Wife2 wife2 = null;

  // 1.私有化构造方法
  private Wife2() {

  }

  //3、提供公共的方法返回该对象
  public static Wife2 getInstance() {
      // 先去判断wife2是否为null
      if(wife2 == null) {
          wife2 = new Wife2();
      }
      return wife2;
}

}
	
}

包装类

实际使用中基本数据类型可能会需要一些特殊操作，例如与String相互转换，比大小，转换成其他进制等等，像这样常规思路就是定义一些方法来实现这些，Java的开发者已经将这些情况提前考虑到了，所以就设计了基本数据类型对应的一些类，这些类我们称之为包装类，包装类中提供了一些功能方法。

常用的方法

  • parsexxx():将字符串转换成对应的基本类型

  • valueof():将字符串转换成对应的包装类

  • toString():转换成字符串

自动装箱与自动拆箱

jdk1.5后提供了自动装箱与自动拆箱

1
2
Integer in3 = 500; //自动装箱, new Integer(500)		
int data6 = in3; //自动拆箱