一、Java中的对象基础（下）

一、关键字：static

1、类属性、类方法的设计思想

	类属性作为该类各个对象之间共享的变量。在设计类时,分析哪些属性不因对象的不同而改变，将这些属性
设置为类属性。相应的方法设置为类方法。
	如果方法与调用者无关，则这样的方法通常被声明为类方法，由于不需要创建对象就可以调用类方法，从
而简化了方法的调用。

2、使用范围

在Java类中，可用static修饰属性、方法、代码块、内部类

3、被修饰后的成员具备以下特点

1. 随着类的加载而加载；
2. 优先于对象存在；
3. 修饰的成员，被所有对象所共享；
4. 访问权限允许时，可不创建对象，直接被类调用。

二、类变量（class Variable）

1. 类变量（类属性）由该类的所有实例共享；
2. 没有对象的实例时，可以用类名.方法名()的形式访问由static修饰的类方法；
3. 在static方法内部只能访问类的static修饰的属性或方法，不能访问类的非static的结构；
4. 因为不需要实例就可以访问static方法，因此static方法内部不能有this。(也不能有super ? YES!)；
5. static修饰的方法不能被重写。

三、单例 (Singleton)设计模式

1、概念说明

	设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。设计
模式免去我们自己再思考和摸索。就像是经典的棋谱，不同的棋局，我们用不同的棋谱。”套路” 所谓类的单例
设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供
一个取得其对象实例的方法。
	如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构造器的访问权限设置为private，
这样，就不能用new操作符在类的外部产生类的对象了，但在类内部仍可以产生该类的对象。因为在类的外部
开始还无法得到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象，静态方法只能访问类中的
静态成员变量。所以，指向类内部产生的该类对象的变量也必须定义成静态的。

2、单例(Singleton)设计模式-饿汉式

// 饿汉式顾名思义，一开始就创建对象。
class Singleton {
	// 1.私有化构造器
	private Singleton() {
	}
	// 2.内部提供一个当前类的实例
	// 4.此实例也必须静态化
	private static Singleton single = new Singleton();
	// 3.提供公共的静态的方法，返回当前类的对象
	public static Singleton getInstance() {
		return single; 
	} 
}

3、单例(Singleton)设计模式-懒汉式

注意：懒汉式暂时还存在线程安全问题，通过多线程可修复。

// 懒汉式顾名思义，需要判断这个对象存在与否，再去看看是否要创建对象
class Singleton {
	// 1.私有化构造器
	private Singleton() {
	}
	// 2.内部提供一个当前类的实例
	// 4.此实例也必须静态化
	private static Singleton single;
	// 3.提供公共的静态的方法，返回当前类的对象
	public static Singleton getInstance() {
		if(single == null) {
			single = new Singleton();
		}
		return single; 
	} 
}

4、单例模式的优点：

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

5、单例(Singleton)设计模式-应用场景

1. 网站的计数器，一般也是单例模式实现，否则难以同步；
2. 应用程序的日志应用，一般都使用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为
只能有一个实例去操作，否则内容不好追加；
3. 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源；
4. 项目中，读取配置文件的类，一般也只有一个对象。没有必要每次使用配置文件数据，都生成一个对象去读取；
5. Application 也是单例的典型应用；
6. Windows的Task Manager (任务管理器)就是很典型的单例模式；
7. Windows的Recycle Bin (回收站)也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的
一个实例。

四、理解main方法的语法

	由于Java虚拟机需要调用类的main()方法，所以该方法的访问权限必须是public，又因为Java虚拟机在执
行main()方法时不必创建对象，所以该方法必须是static的，该方法接收一个String类型的数组参数，该数组
中保存执行Java命令时传递给所运行的类的参数。 又因为main() 方法是静态的，我们不能直接访问该类中
的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员。

五、类的成员之四：代码块

1、说明

代码块(或初始化块)的作用：

对Java类或对象进行初始化；

代码块(或初始化块)的分类：

	一个类中代码块若有修饰符，则只能被static修饰，称为静态代码块(static block)；
	没有使用static修饰的，为非静态代码块。 

static代码块通常用于初始化static的属性

class Person {
	public static int total;
	static {
		total = 100;//为total赋初值
	}
	…… //其它属性或方法声明
}

2、静态代码块：用static 修饰的代码块

1. 可以有输出语句；
2. 可以对类的属性、类的声明进行初始化操作；
3. 不可以对非静态的属性初始化。即：不可以调用非静态的属性和方法；
4. 若有多个静态的代码块，那么按照从上到下的顺序依次执行；
5. 静态代码块的执行要先于非静态代码块；
6. 静态代码块随着类的加载而加载，且只执行一次。

3、非静态代码块：没有static修饰的代码块

1. 可以有输出语句；
2. 可以对类的属性、类的声明进行初始化操作；
3. 除了调用非静态的结构外，还可以调用静态的变量或方法；
4. 若有多个非静态的代码块，那么按照从上到下的顺序依次执行；
5. 每次创建对象的时候，都会执行一次，且先于构造器执行。

4、总结：程序中成员变量赋值的执行顺序

六、关键字：final

在Java中声明类、变量和方法时，可使用关键字final来修饰,表示“最终的”

1. final标记的类不能被继承。提高安全性，提高程序的可读性；
	比如：String类、System类、StringBuffer类
2. final标记的方法不能被子类重写；
	比如：Object类中的getClass()
3. final标记的变量(成员变量或局部变量)即称为常量。名称大写，且只能被赋值一次；
4. final标记的成员变量必须在声明时或在每个构造器中或代码块中显式赋值，然后才能使用；
	final double MY_PI = 3.14;

七、抽象类与抽象方法

1、概念说明

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

2、应用说明

1. 用abstract关键字来修饰一个类，这个类叫做抽象类；
2. 用abstract来修饰一个方法，该方法叫做抽象方法；
	抽象方法：只有方法的声明，没有方法的实现。以分号结束：
		比如：public abstract void talk(); 
3. 含有抽象方法的类必须被声明为抽象类；
4. 抽象类不能被实例化。抽象类是用来被继承的，抽象类的子类必须重写父类的抽象方法，并提供方法体。
若没有重写全部的抽象方法，仍为抽象类；
5. 不能用abstract修饰变量、代码块、构造器；
6. 不能用abstract修饰私有方法、静态方法、final的方法、final的类。

八、多态的应用：模板方法设计模式(TemplateMethod)

	抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行
扩展、改造，但子类总体上会保留抽象类的行为方式。

解决的问题：

1. 当功能内部一部分实现是确定的，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。 
2. 换句话说，在软件开发中实现一个算法时，整体步骤很固定、通用，这些步骤已经在父类中写好了。但是某些
部分易变，易变部分可以抽象出来，供不同子类实现。这就是一种模板模式。

模板方法设计模式的应用

模板方法设计模式是编程中经常用得到的模式。各个框架、类库中都有他的影子，比如常见的有：
	1. 数据库访问的封装；
	2. Junit单元测试；
	3. JavaWeb的Servlet中关于doGet/doPost方法调用；
	4. Hibernate中模板程序；
	5. Spring中JDBCTemlate、HibernateTemplate等。

九、接口(interface)

1、概述

1. 一方面，有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，Java不支持多重继承。
有了接口，就可以得到多重继承的效果；
2. 另一方面，有时必须从几个类中抽取出一些共同的行为特征，而它们之间又没有is-a的关系，仅仅是具有相
同的行为特征而已；
	例如：鼠标、键盘、打印机、扫描仪、摄像头、充电器、MP3机、手机、数码相机、移动硬盘等都支持USB
		 连接。
3. 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要...则必须能...”的思想。继承是一个"是不是"
的关系，而接口实现则是 "能不能"的关系。；
4. 接口的本质是契约，标准，规范，就像我们的法律一样。制定好后大家都要遵守。

2、接口说明

1. 接口(interface)是抽象方法和常量值定义的集合
2. 接口的特点：
	1. 用interface来定义;
	2. 接口中的所有成员变量都默认是由public static final修饰的;
	3. 接口中的所有抽象方法都默认是由public abstract修饰的;
	4. 接口中没有构造器;
	5. 接口采用多继承机制。
3. 定义Java类的语法格式：先写extends，后写implements**
	class SubClass extends SuperClass implements InterfaceA{ }
4. 一个类可以实现多个接口，接口也可以继承其它接口
5. 实现接口的类中必须提供接口中所有方法的具体实现内容，方可实例化。否则，仍为抽象类；
6. 接口的主要用途就是被实现类实现。（面向接口编程）；
7. 与继承关系类似，接口与实现类之间存在多态性；
8. 接口和类是并列关系，或者可以理解为一种特殊的类。从本质上讲，接口是一种特殊的抽象类，这种抽象类
中只包含常量和方法的定义(JDK7.0及之前)，而没有变量和方法的实现。

3、接口的应用：代理模式(Proxy)

概述：

代理模式是Java开发中使用较多的一种设计模式。
代理设计就是为其他对象提供一种代理以控制对这个对象的访问。

应用场景：

1. 安全代理：屏蔽对真实角色的直接访问；
2. 远程代理：通过代理类处理远程方法调用（RMI）；
3. 延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象。
	比如：你要开发一个大文档查看软件，大文档中有大的图片，有可能一个图片有100MB，在打开文件时，
		 不可能将所有的图片都显示出来，这样就可以使用代理模式，当需要查看图片时，用proxy来进行大图
		 片的打开。

分类：

1. 静态代理（静态定义代理类）；
2. 动态代理（动态生成代理类）。
	JDK自带的动态代理，需要反射等知识

十、接口和抽象类之间的对比

十一、Java 8中关于接口的改进

1、概述说明

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

静态方法：

	使用 static 关键字修饰。可以通过接口直接调用静态方法，并执行其方法体。我们经常在相互一起使用的类中
使用静态方法。你可以在标准库中找到像Collection/Collections或者Path/Paths这样成对的接口和类。

默认方法：

	默认方法使用 default 关键字修饰。可以通过实现类对象来调用。我们在已有的接口中提供新方法的同时，还保持
了与旧版本代码的兼容性。
	比如：java 8 API中对Collection、List、Comparator等接口提供了丰富的默认方法。

2、接口中的默认方法

1. 若一个接口中定义了一个默认方法，而另外一个接口中也定义了一个同名同参数的方法（不管此方法是否是
默认方法），在实现类同时实现了这两个接口时，会出现：接口冲突。
	解决办法：实现类必须覆盖接口中同名同参数的方法，来解决冲突。
2. 若一个接口中定义了一个默认方法，而父类中也定义了一个同名同参数的非抽象方法，则不会出现冲突问题。
因为此时遵守：类优先原则。接口中具有相同名称和参数的默认方法会被忽略。

十二、类的成员之五：内部类

1、概述说明

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

2、成员内部类作为类的成员的角色：

1. 和外部类不同，Inner class还可以声明为private或protected；
2. 可以调用外部类的结构；
3. Inner class 可以声明为static的，但此时就不能再使用外层类的非static的成员变量；

3、成员内部类作为类的角色：

1. 可以在内部定义属性、方法、构造器等结构；
2. 可以声明为abstract类 ，因此可以被其它的内部类继承；
3. 可以声明为final的；
4. 编译以后生成OuterClass$InnerClass.class字节码文件（也适用于局部内部类）。

【注意】

1. 非static的成员内部类中的成员不能声明为static的，只有在外部类或static的成员内部类中才可声明static成员。
2. 外部类访问成员内部类的成员，需要“内部类.成员”或“内部类对象.成员”的方式
3. 成员内部类可以直接使用外部类的所有成员，包括私有的数据
4. 当想要在外部类的静态成员部分使用内部类时，可以考虑内部类声明为静态的。

4、如何声明局部内部类

class 外部类{
	方法(){
		class 局部内部类{...} 
	}
	{
		class 局部内部类{ ...} 
	} 
}

5、如何使用局部内部类

1. 只能在声明它的方法或代码块中使用，而且是先声明后使用。除此之外的任何地方都不能使用该类；
2. 但是它的对象可以通过外部方法的返回值返回使用，返回值类型只能是局部内部类的父类或父接口类型。

6、局部内部类的特点

1. 内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名
和$符号，以及数字编号；
2. 只能在声明它的方法或代码块中使用，而且是先声明后使用。除此之外的任何地方都不能使用该类；
3. 局部内部类可以使用外部类的成员，包括私有的；
4. 局部内部类可以使用外部方法的局部变量，但是必须是final的。由局部内部类和局部变量的声明周期不同所致；
5. 局部内部类和局部变量地位类似，不能使用public,protected,缺省,private；
6. 局部内部类不能使用static修饰，因此也不能包含静态成员。

7、匿名内部类

概述说明

1. 匿名内部类不能定义任何静态成员、方法和类，只能创建匿名内部类的一个实例。一个匿名内部类一定是
在new的后面，用其隐含实现一个接口或实现一个类。

格式：

new 父类构造器（实参列表）| 实现接口(){
	//匿名内部类的类体部分
}

匿名内部类的特点

1. 匿名内部类必须继承父类或实现接口；
2. 匿名内部类只能有一个对象；
3. 匿名内部类对象只能使用多态形式引用。

内部类示例代码：

interface A{
	public abstract void fun1();
}

public class Outer {

	public static void main(String[] args) {
	
		new Outer().callInner(new A(){
			//接口是不能new但此处比较特殊是子类对象实现接口，只不过没有为对象取名
			public void fun1() {
				System.out.println(“implement for fun1");
			}
		});// 两步写成一步了
		
	}
	
	public void callInner(A a) {
		a.fun1();
	}
	
}

练习测试内部类

public class Test {

    public Test() {
        Inner s1 = new Inner();
        s1.a = 10;
        Inner s2 = new Inner();
        s2.a = 20;
        Test.Inner s3 = new Test.Inner();
        System.out.println("--1-->" + s3.a);
    }
    
    class Inner {
        public int a = 5;
    }
    
    public static void main(String[] args) {
        Test t = new Test();
        Inner r = t.new Inner();
        System.out.println("--2-->" + r.a);
    }
    
}
============运行结果=================
--1-->5
--2-->5
============运行结果=================

对以前的知识回顾，加深基础知识！
学习来自：北京尚硅谷宋红康老师—Java核心基础2019年版
每天进步一点点，也许某一天你也会变得那么渺小！！！