面向对象(下)

static关键字的使用

1. static：静态的

2. static可以用来修饰：属性、方法、代码块、内部类

3. 使用static修饰属性：静态变量（类变量）共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过的。 静态变量随着类的加载而加载，静态变量的加载要早于对象的创建。可以通过“类.静态变量”的方式进行调用，由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中

   	类变量	实例变量
   类	yes	no
   对	yes	no

4. 使用static修饰方法：静态方法

   1. 随着类的加载而加载，可以通过"类.静态方法"的方式进行调用。
   2. 静态方法中，只能调用静态的方法或属性，非静态方法中，既可以调用非静态的方法和属性，也可以调用静态的方法或属性

   	静态方法	非静态方法
   类	yes	no
   对象	yes	yes

5. static注意点：在静态的方法内，不能使用this关键字，super关键字。

6. 总结：开发中，如何确定一个属性是否要声明为static的?开发中如何确定一个方法是否要声明为static的？
   答： 属性是可以被多个对象所共享的，不会随着对象的不同而不同的。操作静态属性的方法，通常设置为static的。工具类中的方法，习惯上声明为static的。比如：Math、Arrays、Collections。

static关键字应用：单例（Singleton）设计模式

所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构造器的访问权限设置为private，这样，就不能用new操作符在类的外部产生类的对象了，但在类内部仍可以产生该类的对象。因为在类的外部开始还无法得到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象，静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象的变量也必须定义成静态的。

单例模式有点：由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决。
单例设计模式的两种写法：
第一种：饿汉式

private Bank{
	//1.私有化构造器
	private Bank(){
 
	}
	//2.内部创建类的对象
	private static  Bank instance = new Bank();
 
	//3.提供公共的方法，返回类的对象
	public static Bank getInstance(){
	 return instance;
	}
}

第二种：懒汉式

class Bank(){
	//1.私有化类的构造器
	private Bank(){
 
	}
	//2.声明当前类对象，没有初始化
	private staitc Bank instace  = null
 
	//3.声明public,static的返回类对象的方法
	public staic Order getInstance(){
		if(instance == null){
			instance = new  Order();
		}
		return instance;
	}
}

区分懒汉式与饿汉式：
懒汉式：好处：延迟对象的创建 坏处：目前写法不安全
饿汉式：坏处：对象加载时间过长。好处：线程安全的

理解main方法的使用：

1. main()方法作为程序的入口
2. main()方法也是一个普通的静态方法
3. main()方法可以作为我们与控制台交互的方式。

	public static void main(String[] args){//入口
		System.out.println("*****"+args[i]);
	}

javac MainDemo.java
java MainDemo "87" 89 85

代码块(初始化块)

1. 代码块的作用：用来初始化类、对象
2. 只能用static来修饰
3. 静态代码块：内部可以有输出语句，随着类的加载而执行。而且只执行一次。作用：初始化类的信息。如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行 静态代码块的执行优先于非静态代码块的执行。静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构 非静态代码块：内部可以有输出语句，随着对象的创建而执行，每创建一个对象，就执行一次非静态代码块，作用：可以在创建对象时，对对象的属性等进行初始化 。如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行 非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法

注：现在可以对属性可以赋值的位置：
1、默认初始化 2、显式初始化 3、构造器中初始化 4、有了对象以后，可以通过"对象.属性"或"对象.方法"的方式，进行复制 5、在代码块中赋值
赋值的先后顺序：1-2/5-3-4

final关键字

1. final可以修饰的结构：类、方法、变量

2. final用来修饰一个类：此类不能被其他类来继承，比如String类、System类、StringBuffer类

3. final修饰方法表示此方法不能被重写：比如Object.getClass()：获取当前对象所属的类

4. final 用来修饰变量：此时的“变量”就成为一个常量

   final修饰一个属性：可以考虑的位置有：显式初始化、在代码块中初始化、构造器中初始化

   final修饰局部变量：尤其是使用final修饰形参时，表明形参是一个常量，当我们调用此方法时，给常量形参赋值一个实参，一旦赋值以后，就只能在方法体内使用此形参，但不能重新赋值

补充：static final 用来修饰属性：全局常量

抽象类与抽象方法

概念：随着继承层次中一个个新子类的定义，类变得越来越具体，而父类则更一般，更通用。类的设计应该保证父类和子类能够共享特征。有时将一个父类设计得非常抽象，以至于它没有具体的实例，这样的类叫做抽象类

1. abstract:抽象的

2. abstract可以用来修饰的结构：类，方法

3. abstract修饰的类叫做抽象类

   此类不能实例化
   抽象类中一定有构造器，便于子类实例化的调用(涉及：子类对象实例化的全过程)
   开发中，都会提供抽象类的子类，让子类对象实例化，完成相关操作

4. abstract修饰的方法叫做抽象方法

   抽象方法只有方法声明，没有方法体
   包含抽象方法的类一定是一个抽象类,反之，抽象类中可以没有抽象方法
   若子类重写了父类中的所有抽象后，此类方可实例化
   若子类没有重写父类中所有的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰

abstract使用沈阳的注意点：
1、abstract不能用来修饰：属性、构造器等结构
2、abstract不能用来修饰私有方法、静态方法、final的方法、final的类

抽象类的匿名子类：

abstract class Person(){
	public void eat();
}
class test(){
	Person person = new Person(){
		@Override
		public void eat(){
 
		}
	}
}

接口（interface)

1、接口使用interface来定义
2、Java中，接口和类是并列的两个结构
3、如何定义接口：定义接口中的成员，jdk7之前只能定义全局常量和抽象方法（public static final的常量，但是书写时可以省略不写和public abstract的方法）jdk8除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法
4、接口中不能定义构造器！意味着接口不可以实例化
5、Java开发中，接口通过让类区实现(implements)的方式来使用。如果实现类覆盖了接口中所有的抽象方法，则此实现类就可以实例化。如果类没有覆盖接口中的所有的抽象方法，则此实现类仍为一个实现类。
6、Java类可以实现多个接口--->弥补了Java单继承性的局限性 格式class A extends BB implements CC,DD,EE
7、接口与接口之间是多继承
8、接口的具体使用，体现多态性
9、接口，实际上可以看作是一种规范。

接口应用一：代理模式、工厂设计模式（实现创建者与调用者的分里，即将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的）

Java8中，你可以为接口添加静态方法和默认方法。从技术角度来说，是完全合法的，只是它看起来违法接口作为一个抽象定义的概念。

知识点一：接口中定义的静态方法，只能通过接口来调用
知识点二：通过实现类的对象，可以调用接口中的默认方法。如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法。知识点三：如果子类（或实现类）继承的父类和实现的接口中声明了同名同参数的方法。那么子类在没有重写此方法的情况下，默认调用的是父类中的同名同参数的方法-->类游侠你原则。

内部类

当一个事物的内部，还有一个部分需要一个完整的机构进行描述，而这个内部的完整结构又值位外部事物提供服务，那么整个内部的完整结构最好使用内部类
在java中，允许一个类的定义位于另一个类的内部，前者称为内部类，后者称为外部类
Inner class一般用在定义它的类或语句块之内，在外部引用它时必须给出完整的名称
Inner class的名字不能与包含它的外部类类名相同
分类：成员内部类（static成员内部类和非static成员内部类），局部内部类（不谈修饰符）、匿名内部类

成员内部类：一方面作为外部类的成员，调用外部类的结构，可以被static修饰，可以被四种不同的权限修饰。一方面作为一个类，可以定义属性、方法、构造器，可以被final修饰，表示此类不能被继承。可以被abstract修饰。

重点：（主要关注以下三个问题）

1. 如何实例化成员内部类的对象
   静态成员内部类：外部类.内部类 对象名 = new 外部类.内部类();
   非静态成员内部类：外部类 外部类对象名 = new 外部类(); 外部类.内部类 内部类对象名 = 外部类对象名.new 内部类对象名();
2. 如何在成员内部类中区分调用外部类的结构
   非冲突：直接调
   冲突：外部类的属性：外部类.this.name 内部类的属性： this.name
3. 开发中局部内部类的使用 创建一个接口的实现类并返回该类的对象
   例子：

方式一：
public Comparable getComparable(){
	//class MyComparable implement Comparable{
	//@Override
	//public int compareTo(Object o){
	//	return 0
	//}
	//return new Mycomparable
	//}
	//方式二
	return new Comparable(){
	@Override
	public int compareTo(Object o){
		return 0
	}
}
}