文章目录

关键字
- static
- main方法说明
- 设计模式
- - 单例设计模式
  - 面试题
  - - 写一个Singleton实例
类的成员
- 代码块（四）
关键字final
关键字abstract
- 抽象类的匿名子类
- 多态的应用：模板方法设计模式（TemplateMethod）
关键字：interface
- 接口应用：数组排序
- 接口应用：代理模式
- 接口应用：工厂模式
- - 面向对象的设计原则
  - 工厂模式的分类
  - - 1. 无工厂模式
    - 2. 简单工厂
    - 3. 工厂方法
    - 4. 抽象工厂
- JDK8接口新特性
内部类

关键字

static

有些时候需要不产生对象，就可以直接使用。
无论，是否产生对象，无论多少对象，某些特定数据在内存空间中只有一份

static ：属性，方法，代码块，内部类

static 修饰属性
静态变量（类变量） vs 非静态变量（实例变量）
- 实例变量：多个对象，各有一套非静态属性
- 静态变量：多个对象共享同一个静态变量
其他说明：
- 静态变量随着类加载，早与对象（可以通过类名.的方式调用）
- 类只加载一次，所以类变量只有一份，存在方法区的静态域中
类变量，实例变量内存解析
static 修饰方法
- 随着类的加载而加载（可以通过类名.的方式调用）
- 静态方法中: 只能调用静态属性和方法
- 非静态方法中：可以调用静态和非静态
- 静态方法中：不可使用this,super

开发中如何确定一个属性是否要声明为static

属性：可以被多个对象共享的，不会随着对象不同而不同
方法：操作静态属性的方法通常都设置为静态，工具类中方法习惯声明为static

main方法说明

main() 方法作为程序的入口

main() 方法也是一个普通的静态方法

main() 方法可以作为我们与控制台交互的方式。

设计模式

设计模式：是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。
创建型模式：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式
结构型模式：适配器模式、装饰器模式、代理模式、外观模式、组合模式、享元模式
行为型模式：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、被网络模式、状态模式、访问这模式、中介者模式、解释器模式。

设计模式电子书
链接: https://pan.baidu.com/s/1wf4VjR2HDrZwalBnv-HaYQ 提取码: ioim
–来自百度网盘超级会员v4的分享

单例设计模式

定义：保证整个系统中，某个类只能存在一个对象实例

饿汉式

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

懒汉式

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

单例应用场景

面试题

写一个Singleton实例

饿汉式：直接创建对象，不存在线程安全问题，java的类加载机制保证(clinit方法)

直接实例化饿汉式（提供公共静态变量）

/*** 1. 私有化构造* 2. 自行创建并用公共静态变量保存* 3. 强调这是一个单例，用final修饰*/
class Singleton1{public static final Singleton1 INSTANCE = new Singleton1();private Singleton1(){}
}
//获取方式
Singleton1 s = Singleton1.INSTANCE;

枚举版（提供公共静态变量）

/**
1. 枚举：该类型对象是有限的几个，限定为一个，就成了单例
2. 枚举中重写了toString，枚举中构造器是私有的
*/
public enum Singleton2 {INSTANCE
}//获取方式
Singleton2 s = Singleton2.INSTANCE;

简单版（提供公共静态方法）

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

静态代码块饿汉式（适合复杂实例化）

public class Singleton3 {public static final Singleton3 INSTANCE;static {INSTANCE = new Singleton3();}private Singleton3(){};
}

复杂饿汉式单例，实例

/**
使用复杂单例初始化，数据，读取配置文件中的信息
*/
public class Singleton3 {//共有静态final变量public static final Singleton3 INSTANCE;private String info;//存配置信息//私有构造private Singleton3(String info){this.info = info;}//创建对象static {try {Properties pro = new Properties();//由类加载器获取文件流pro.load(Singleton3.class.getClassLoader().getResourceAsStream("single.properties"));INSTANCE = new Singleton3(pro.getProperty("info"));//创建对象} catch (IOException ioException) {throw new RuntimeException();}}public String getInfo() {return info;}public void setInfo(String info) {this.info = info;}@Overridepublic String toString() {return "Singleton3{" +"info='" + info + '\'' +'}';}
}class temp{public static void main(String[] args) {Singleton3 s = Singleton3.INSTANCE;System.out.println(s);}
}

懒汉式

线程不安全（适用单线程）

/*** 懒汉式：延迟创建这个类的实例对象* 1. 私有构造* 2. 私有静态变量保存唯一实例对象* 3. 共有静态方法获取实例对象*/
public class Singleton4 {private static Singleton4 instance;private Singleton4(){}public static Singleton4 getInstance(){if (instance == null){instance = new Singleton4();}return instance;}
}

测试线程不安全

public class Singleton4 {private static Singleton4 instance;private Singleton4(){}public static Singleton4 getInstance(){if (instance == null){try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}instance = new Singleton4();}return instance;}
}class TestDemo{public static void main(String[] args) throws ExecutionException, InterruptedException {Callable<Singleton4> c = new Callable<Singleton4>() {@Overridepublic Singleton4 call() throws Exception {return Singleton4.getInstance();}};ExecutorService es = Executors.newFixedThreadPool(2);Future<Singleton4> f1 = es.submit(c);Future<Singleton4> f2 = es.submit(c);Singleton4 s1 = f1.get();Singleton4 s2 = f2.get();System.out.println(s1 == s2);es.shutdown();}
}

线程安全的(适用多线程)

public class Singleton4 {private static Singleton4 instance;private Singleton4(){}public static Singleton4 getInstance(){if (instance == null){synchronized (Singleton4.class){if (instance == null){try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}instance = new Singleton4();}}}return instance;}
}

静态内部类（适用多线程）

/*** 1. 内部类加载和初始化时，才创建INSTANCE实例对象* 2. 静态内部类不会自动随着外部类的加载和初始化，它是要单独去加载和初始化的* 3. 因为是在内部类加载和初始化时，创建的，因此使用的是类加载器，是线程安全的*/
public class Singleton4 {private Singleton4(){};private static class Inner{private static final Singleton4 INSTANCE = new Singleton4();}public static Singleton4 getInstance(){return Inner.INSTANCE;}
}

类的成员

代码块（四）

作用：用来初始化类，对象
只能使用static修饰：静态，非静态

静态 vs 非静态

静态代码块

内部可以有输出语句

随着类的加载而执行，只执行一次

作用：初始化类的信息

定义了多个静态代码块，按照声明先后顺序执行

静态只能调静态的属性、方法，不能调非静态的结构

静态优先与非静态执行

非静态代码块

内部可以有输出语句

随着对象的创建而执行，每创建一个对象就执行一次

作用：创建对象时，对对象的属性等进行初始化

定义了多个非静态代码块，按照声明的先后顺序执行

非静态代码块内可以调用静态的属性、方法、非静态属性、方法

对属性可以赋值的位置

默认初始化

显示初始化 / 代码块中赋值

构造器初始化

对象.属性，对象.方法进行赋值

先加载静态代码块，由父及子
再加载非静态代码块
最后执行构造器

实际运用：如jdbc工具类

public class JDBCUtil {private static DataSource dataSource = null;//创建数据库连接池static {InputStream is = null;try {is = DBCPTest.class.getClassLoader().getResourceAsStream("dbcp.properties");Properties pros = new Properties();pros.load(is);//调用BasicDataSourceFactory的静态方法，获取数据源dataSource = BasicDataSourceFactory.createDataSource(pros);} catch (Exception e) {e.printStackTrace();}finally{if (is != null){try {is.close();} catch (IOException e) {e.printStackTrace();}}}}//使用DBCP数据库连接池实现数据库连接public static Connection getConnection2() throws SQLException {Connection conn = dataSource.getConnection();System.out.println(conn);return conn;}
}

关键字final

final 可以修饰：类，方法，变量

类：被修饰的类不能被继承
方法：被修饰方法不能被重写
变量：被修饰变量，称为常量
- 修饰属性：赋值位置有[显示初始化、代码块中初始化、构造器中初始化（每个构造器中都需要赋值）]
- 局部变量：修饰形参时，在方法体内不能被修改

static final 用来修饰属性：全局常量，随这类的加载而加载

关键字abstract

abstract 修饰类：抽象类

此类不能实例化

抽象类是一定有构造器，便于子类实例化调用（涉及：子类对象实例化的全过程）

提供抽象类的子类，让子类对象实例化，完成相关操作

abstract 修饰方法：抽象方法

抽象方法只有方法的声明，没有方法体

包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法

若子类重写父类中所有的抽象方法后，此子类方可实例化

若子类没有重写父类中所有抽象方法，此子类也是抽象类，需要使用abstract修饰

abstract 使用上注意点：

不能修饰：属性、构造器等结构

不能修饰：私有方法、静态方法、final方法

抽象类的匿名子类

Person p = new Person(){@Overridepublic void eat(){System.out.println("吃东西");}@Overridepublic void breath(){System.out.println("好好呼吸");   }
}

多态的应用：模板方法设计模式（TemplateMethod）

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

public abstract class Template {//计算某段代码执行所需要花费的时间public void spendTime(){long start = System.currentTimeMillis();//不确定部分this.code();long end = System.currentTimeMillis();System.out.println("花费的时间为：" + (end - start));}public abstract void code();
}
class SubTemplate extends Template{@Overridepublic void code() {for (int i = 2; i <= 1000; i++) {boolean isFlag = true;for (int j = 2; j <= Math.sqrt(i); j++) {if (i % j == 0){isFlag = false;break;}}if (isFlag){System.out.println(i);}}}
}
class TestTemplate{public static void main(String[] args) {SubTemplate t = new SubTemplate();t.spendTime();}
}

//抽象类的应用：模板方法的设计模式
public class TemplateMethodTest {public static void main(String[] args) {BankTemplateMethod btm = new DrawMoney();btm.process();BankTemplateMethod btm2 = new ManageMoney();btm2.process();}
}
abstract class BankTemplateMethod {// 具体方法public void takeNumber() {System.out.println("取号排队");}public abstract void transact(); // 办理具体的业务 //钩子方法public void evaluate() {System.out.println("反馈评分");}// 模板方法，把基本操作组合到一起，子类一般不能重写public final void process() {this.takeNumber();this.transact();// 像个钩子，具体执行时，挂哪个子类，就执行哪个子类的实现代码this.evaluate();}
}class DrawMoney extends BankTemplateMethod {public void transact() {System.out.println("我要取款！！！");}
}class ManageMoney extends BankTemplateMethod {public void transact() {System.out.println("我要理财！我这里有2000万美元!!");}
}

关键字：interface

接口定义使用 interface
接口和类是两个并列结构
如何定义接口：定义接口中的成员
3.1. JDK7以前：只能定义全局常量和抽象方法

全局常量：public static final 的（只能是，默认可略）
抽象方法：public abstract 的（只能是，默认可略）

3.2. JDK8：添加了静态方法、默认方法
接口中不能定义构造器，不能实例化
接口让子类implements。覆盖重写接口中的方法
java类可以实现多个接口
接口与接口之间可以多继承
接口的具体使用体现多态性
接口，实际上可以看做一种规范
父类和接口中属性重名，
- 子类在使用是调父类中要用super.属性
- 子类调用接口中属性用接口名.属性
接口继承了多个接口，多个接口中存在同名方法，

接口应用：数组排序

接口应用：代理模式

静态代理

//接口
public interface NetWork {void browse();
}
//被代理类
public class Server implements NetWork{@Overridepublic void browse() {System.out.println("真实的服务器访问网络");}
}
//代理类
public class ProxyServer implements NetWork {private NetWork work;public ProxyServer(NetWork work){this.work = work;}public void check(){System.out.println("上网之前的检查工作");}@Overridepublic void browse() {check();work.browse();//利用接口多态调用被代理类的方法}
}public class NetWorkTest {public static void main(String[] args) {Server server = new Server();ProxyServer proxyServer = new ProxyServer(server);proxyServer.browse();}
}/**********************
上网之前的检查工作
真实的服务器访问网络
**********************/

接口应用：工厂模式

工厂模式：实现了创建者与调用者的分离，即将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。

面向对象的设计原则

OCP：开闭原则，对扩展开放，对修改关闭
DIP：依赖倒转原则，要针对接口编程，不要针对实现编程
A中关联B，尽量使得B实现某个接口，然后A与接口发生关系，不与B实现类发生关联关系
解耦调用和被调用者
LOD：迪米特法则，只与直接的朋友通信，避免与陌生人通信
要求尽量的封装，尽量独立

工厂模式的分类

简单工厂：用来生产同一等级结构中的任意产品（对于增加新的产品需要修改已有代码）
工厂方法：用来生产同一等级结构中的固定产品（支持增加任意产品）
抽象工厂：用来生产不同产品族的全部产品（对于增加新的产品，无能为力；支持增加产品族）

1. 无工厂模式

public interface Car {void run();
}class BYD implements Car {public void run() {System.out.println("比亚迪在跑");}
}class Audi implements Car {public void run() {System.out.println("奥迪在跑");}
}public class Client01 {public static void main(String[] args) {Car a = new Audi();Car b = new BYD();a.run();b.run();}
}

2. 简单工厂

public interface Car {void run();
}class BYD implements Car {public void run() {System.out.println("比亚迪在跑");}
}class Audi implements Car {public void run() {System.out.println("奥迪在跑");}
}//工厂类
public class CarFactory {//方式一public static Car getCar(String type){if ("奥迪".equals(type)) {return new Audi();} else if ("比亚迪".equals(type)) {return new BYD();} else {return null;}}//方式二// public static Car getAudi() {// return new Audi();// }//// public static Car getByd() {// return new BYD();// }
}public class Client02 {public static void main(String[] args) {Car a = CarFactory.getCar("奥迪");a.run();Car b = CarFactory.getCar("比亚迪");b.run();}
}

分工，多出了一个专门生产 Car 的实现类对象的工厂类。把调用者与创建者分离。

缺点：对于增加新产品，不修改代码的话，是无法扩展的。违反了开闭原则（对
扩展开放；对修改封闭）。

3. 工厂方法

简单工厂模式只有一个（对于一个项目或者一个独立的模块而言）工厂类，而工厂方法模式有一组实现了相同接口的工厂类

public interface Car {void run();
}class BYD implements Car {public void run() {System.out.println("比亚迪在跑");}
}class Audi implements Car {public void run() {System.out.println("奥迪在跑");}
}//工厂接口
public interface Factory {Car getCar();
}//两个工厂类
class AudiFactory implements Factory{public Audi getCar(){return new Audi();}
}
class BydFactory implements Factory{public BYD getCar(){return new BYD();}
}public class Client {public static void main(String[] args) {Car a = new AudiFactory().getCar();Car b = new BydFactory().getCar();a.run();b.run();}
}

在工厂方法模式中，要么将判断逻辑留在抽象工厂角色中，要么在客户程序中将具体工厂角色写死（就像上面的例子一样）。而且产品对象创建条件的改变必然会引起工厂角色的修改。面对这种情况，Java 的反射机制与配置文件的巧妙结合突破了限制——这在Spring 中完美的体现了出来。

4. 抽象工厂

抽象工厂模式和工厂方法模式的区别就在于需要创建对象的复杂程度上。

抽象工厂模式是三个里面最为抽象、最具一般性的。
抽象工厂模式的用意为：给客户端提供一个接口，可以创建多个产品族中的产品对象。
而且使用抽象工厂模式还要满足一下条件：

系统中有多个产品族，而系统一次只可能消费其中一族产品。
同属于同一个产品族的产品以其使用。

JDK8接口新特性

jdk8中除了定义静态属性，抽象方法外，新增了静态方法，默认方法

知识1：接口中定义的静态方法，只能通过接口调用，实现类无法使用（相当于工具类）
知识2：通过实现类对象，可以调用接口中的默认方法（可以被子类重写）
如果实现类重写了接口中的默认方法，任然调用的是重写以后的方法
知识3：实现类，继承的父类与实现的接口中声明了同名同参数的默认方法
子类没有重写的情况下，默认调用的是父类中同名同参数的方法（类优先原则）
知识4：实现类，实现多个接口，而接口中存在同名同参的默认方法，子类不重写的情况下会报错–>接口冲突，这就必须在实现类中重写默认方法
知识5：实现类中调用接口的默认方法，接口名.super.默认方法

public interface AA {double PI = 3.14;public default void method() {System.out.println("北京");}default String method1() {return "上海";}public static void method2() {System.out.println(“hello lambda!");}
}

内部类

内部类：一个类定义在类一个类的内部
分类：

成员内部类（static 成员内部类和非static成员内部类）
局部内部类（方法内、代码块内、构造器内）

静态内部类不会自动随着外部类的加载而初始化，他需要单独去加载和初始化

成员内部类
作为外部类成员

调用外部类的结构（外部类.this.外部类方法()）

可以被static修饰

可以被4中权限修饰
作为一个类
类内可定义属性、方法、构造器等

可被final修饰。不使用final修饰就可继承
可被abstract修饰，该内部类不能被实例化(抽象内部类)，需要使用内部类方法用static
//抽象内部类可以间接的实现多继承
public class InnerTest{public static void main(String[] args){A.B b = new D();b.show();}
}abstract class A{//抽象内部类，需要使用static修饰才可以调用内部的方法static abstract class B{public abstract void show();}public abstract void showit();
}
class C extends A{public void showit(){System.out.println("show我的");}
}
class D extends A.B{public void show(){System.out.println("show");}
}

如何实例化成员内部类的对象

静态成员内部类
- 外部类.内部类变量名 = new 外部类.内部类();
- 变量名.内部类方法();

非静态成员内部类
- 外部类外部 = new 外部类();
- 外部类.内部类内部 = 外部.new 内部类();
- 内部.内部方法();

如何在成员内部类中区分调用外部类的结构

内部类属性：this.属性

外部类属性：外部类.this.属性（同名情况下这样用）

开发中局部内部类的使用

public Comparable get Comparable(){class MyComparable implements Comparable{@Overridepublic int compareTo(Object o){return 0;}}return new MyComparable();//return new Comparable(){//   @Override//    public int compareTo(Object o){//       return 0;// }//}
}

懒汉式单例（线程安全版）

/**
* 1. 内部类加载和初始化时，才创建INSTANCE实例对象
* 2. 静态内部类不会自动随着外部类的加载和初始化，它是要单独去加载和初始化的
* 3. 因为是在内部类加载和初始化时，创建的，因此使用的是类加载器，是线程安全的
*/
public class Singleton4 {private Singleton4(){};private static class Inner{private static final Singleton4 INSTANCE = new Singleton4();}public static Singleton4 getInstance(){return Inner.INSTANCE;}
}

调用局部变量

   public void method(){int num = 10;int finalNum = num;class AA {public void show(){System.out.println(finalNum);}}num = 20;}

安卓开发中一个按钮的事件监听等

public void onCreate(){int number = 10;View.OnClickListern listener = new View().OnClickListener(){public void onClick(){System.out.println("hello!");System.out.println(number);}}button.setOnClickListener(listener);
}

第六章 ---- 面向对象（三）相关推荐

【JAVA SE】第六章面向对象、对象和类以及封装
第六章面向对象.对象和类以及封装文章目录第六章面向对象.对象和类以及封装一.面向对象 1.概念 2.面向对象的三大特征二.对象和类 1.基本概念 2.Java中的对象 3.Java 中的类 ...
《疯狂Java讲义》学习笔记第六章面向对象（下）
<疯狂Java讲义>学习笔记第六章面向对象(下) 6.1包装类基本数据类型包装类 byte Byte short Short int Integer long Long char ...
Java基础学习——第六章面向对象编程(下)
Java基础学习--第六章面向对象编程(下) 一.关键词:static 1. static关键字的引入当我们编写一个类时,其实就是在描述其对象的属性和行为,而并没有产生实质上的对象,只有通过new ...
第六章贪心(三)：排序不等式、绝对值不等式
第六章贪心(三):排序不等式.绝对值不等式.推公式 AcWing 913:排队打水题目有 n 个人排队到 1 个水龙头处打水,第 i 个人装满水桶所需的时间是 ti,请问如何安排他们的打水顺序才能 ...
《编程机制探析》第六章面向对象
<编程机制探析>第六章面向对象面向对象(Object Oriented)是命令式编程的主流编程模型,其概念极其重要.可以说,命令式编程几乎就是面向对象的天下. 面向对象(Object ...
第六章面向对象(下)
除前一章所介绍的关于类.对象的基本语法之外,本章将会继续介绍Java面向对象的特性.Java为8个基本类型提供了对应的包装类,通过这些包装类可以把8个基本类型的值包装成对象使用,JDK1.5提供了自动 ...
Java基础编程\第四-六章(面向对象编程)
Java面向对象学习的三条主线: (第4-6章) 文章目录面向对象的举例属性(成员变量)和局部变量类中方法的声明和使用 Train(圆面积) ==Train(对象数组)== ==对象数组的内存解 ...
第六章面向对象编程基础总结
目录面向过程与面向对象的区别一.面向对象概述 1.对象 2.类 3.面向对象程序设计的特点 (1).封装 (2).继承 (3).多态二.类与对象 1.成员变量 2.成员方法 3.构造方法 4.局 ...
第六章面向对象(2)
Java学习笔记面向对象(2) Java8 增强的包装类 Java的8种基本数据类型不具备对象的特性.为解决基本数据类型变量不能当成Object类型变量使用的问题,Java提供了包装类的概念,为8种 ...

第六章 ---- 面向对象（三）