第6章 面向对象（下）

• 基本类型的包装类
  final修饰
  • 变量 不允许重新赋值
  • 方法 子类不能覆盖
  • 类 不能派生子类
    abstract 抽象类：多个类的模板
    interface 接口：多类应该遵守的规范
    lambda表达式
    enum枚举类：不能自由创建对象的类，对象在定义类时已固定（class季节，能创建的实例有限且确定）

---

• 包装类可实现基本类型变量和字符串之间的转换
  字符串 -> 基本类型
  使用包装类的方法

1. 静态方法 parseXxx(String s) 除了Character
2. 构造器 Xxx（String s）
   基本类型 -> 字符串
   String.valueOf(x);
   基本类型+"";

String intStr = "123";
int it1 = Integer.parseInt(intStr);
int it2 = new Integer(intStr);
String s = String.valueof(true);
String str = 基本类型 + "";

系统把-128~127存在cache数组，所以不用新建对象。

//ina == inb
Integer ina = 2;
Integer inb = 2;
//biga != bigb
Integer biga = 128;
Integer bigb = 128;

所以包装类都有一个compare方法
Boolean.compare(true, false); true> false输出1

6.2处理对象

打印对象和toString方法
object类提供的toString方法返回“类名+@+hashCode”

string不能用==判断，要用equals
new String("hello");一用产生两个字符串对象（“hello”在常量池）
在编译时就能确定下来的，在常量池，不产生多个副本

6.3类成员

static修饰的成员：类变量，类方法，初始化块，不能修饰构造器

java类中只包含5种成员

1. 成员变量
2. 方法
3. 构造器 ×
4. 初始化块
5. 内部类（接口，枚举）
   除了3都可以用static修饰
   类成员不能访问实例成员

6.3.2单例类

只允许创建一个实例的类，构造器private

6.4final

final修饰的成员变量必须由程序员显式的指定初始值，系统不会隐式初始。
6.4.4可执行“宏替换”的final变量
final变量相当于一个常量：
使用final && 定义final变量时指定了初始值 && 该初始值在编译时就被确定下来了。

• fina方法不能被重写: Object getClass()
• final类不能有子类（不能被继承）

6.4.7不可变类

类中只有setter没有getter
但是类的组合的时候 a由b组成，需要new b 传入a，此时b改变了，会改变a的值（图
在a中
private final Name name；
构造函数 this.name = new Name(name.getName()) //new一个新的
getter中返回一个 return new Name(name.getName());防止把成员变量返回出去被修改。

6.4.8缓存实例的不可变类

codes\06\6.4\CacheImmututaleTest.java
codes\06\6.4\IntegerCacheTest.java

6.5抽象类 一种模板模式的设计

抽象类和抽象方法：抽象类里可以没有抽象方法，抽象方法必须在抽象类里。

• 抽象方法不能有方法体
• 抽象类不能被实例化
  得 抽象方法，失 创建实例

package six;

public abstract class Shape {
    {
        System.out.println("执行shape的初始化块");
    }
    public abstract double calPerimeter();
    public abstract String getTYpe();
    private String color;
    public Shape(){}
    public Shape(String color) {
        System.out.println("执行shape的构造器");
        this.color = color;
    }
}
-------------------------------------
package six;

public class Triangle extends Shape {
    private double a;
    private double b;
    private double c;
    public Triangle(String color, double a, double b, double c) {
        super(color);
        this.setSides(a, b, c);
    }
    public void setSides(double a, double b, double c) {
        this.a = a;
        this.b = b;
        this.c = c;
    }
    public  double calPerimeter() {
        return a + b + c;
    }
    public  String getTYpe() {
        return "三角形";
    }
    public static void main(String[] args) {
        Shape s1 = new Triangle("red", 3, 4, 5);
        System.out.println(s1.getTYpe());
        System.out.println(s1.calPerimeter());
    }
}

使用abstract修饰类时，表明这个类只能被继承，使用abstract修饰方法时，表明这个方法必须由子类提供实现（重写）
final永远不能和abstract同时使用。
static 和 abstract 不能同时修饰某方法。没有类抽象方法，但可以同时修饰内部类。
private和abstract不能同时修饰方法。

接口：修饰符 省略/public

不包含构造器，初始化块

• 成员变量（only静态常量）自动增加public static final修饰
  public static final int MAX_SIZE = 50;
• 方法 （only抽象实例方法，类方法，默认方法default修饰）public abstract
• 内部类（内部接口，枚举）public static
  接口可被当做一个特殊的类，java 源文件中最多只能有一个public接口。
  默认方法必须使用default修饰，不能用static修饰，不能直接使用借口来调用，使用接口的实现类的实例来调用。

package six.lee;

public interface Output {
    //接口里的成员变量默认public static final ！！！
    int MAX_CACHE_LINE = 50;
    //接口里的普通方法默认public abstract
    void out();
    void getData(String msg);
    //在接口中定义默认方法，需要使用default修饰
    default void print(String... msgs) { //神奇的用法...
        for (String msg : msgs) {
            System.out.println(msg);
        }
    }
    //在接口中定义默认方法，需要使用default修饰
    default void test() {
        System.out.println("默认的test（）方法");
    }
    //接口里定义的类方法，需要static修饰
    static String staticTest() {
        return "接口里的类方法";
    }
}
-----------------
package six.yeeku;

public class OutputFieldTest {
    public static void main(String[] args) {
        System.out.println(six.lee.Output.MAX_CACHE_LINE);
        //Output.MAX_CACHE_LINE = 20;   不能为final变量赋值
        System.out.println(six.lee.Output.staticTest());

    }
}
输出：
50
接口里的类方法

接口的继承

相当于继承了一个彻底的抽象类（除了默认方法，所有方法都是抽象abstract方法）

使用接口：

不能创建实例，但可以用于声明引用类型变量，指向其实现类的对象
接口用途：

1. 定义变量，进行强制类型转换
2. 调用接口中定义的常量
3. 被其他类实现

• 实现接口方法时，必须用public

package six.lee;

public interface Output {
    //接口里的成员变量默认public static final
    int MAX_CACHE_LINE = 50;
    //接口里的普通方法默认public abstract
    void out();
    void getData(String msg);
    //在接口中定义默认方法，需要使用default修饰，不能用static修饰，不能直接用接口调用，要用实现类的对象调用
    default void print(String... msgs) {
        for (String msg : msgs) {
            System.out.println(msg);
        }
    }
    //在接口中定义默认方法，需要使用default修饰
    default void test() {
        System.out.println("默认的test（）方法");
    }
    //接口里定义的类方法，需要static修饰
    static String staticTest() {
        return "接口里的类方法";
    }
}
-------------------------------
package six.lee;

interface Product {
    int getProduceTime();
}
public class Printer implements Output, Product{

    private String[] printData = new String[MAX_CACHE_LINE];
    private int dataNum = 0;

    //实现接口的方法必须加上public，不能省略
    public void out() {
        while (dataNum > 0) {
            System.out.println("打印机打印：" + printData[0]);
            System.arraycopy(printData, 1, printData, 0, --dataNum);
        }
    }
    public void getData(String msg) {
        if (dataNum >= MAX_CACHE_LINE) {
            System.out.println("输出队列已经满了，添加失败");
        } else {
            printData[dataNum++] = msg;
        }
    }
    public int getProduceTime() {
        return 45;
    }
    public static void main(String[] args) {
        Output o = new Printer();
        o.getData("猪猪侠");
        o.getData("中二少年");
        o.out();
        o.getData("我的");
        o.getData("什么是AJAX");
        o.out();
        o.print("白敬亭", "小白", "陆之昂");
        o.test();
        Product p = new Printer();
        System.out.println(p.getProduceTime());
        Object obj = p;


    }
}
输出：
打印机打印：猪猪侠
打印机打印：中二少年
打印机打印：我的
打印机打印：什么是AJAX
白敬亭
小白
陆之昂
默认的test（）方法
45

6.6.5接口和抽象类

接口总纲，抽象类中间产品

6.6.6面向接口编程

设计模式：对经常出现的软件设计问题的成熟解决方案，实际上是对特定问题的一种惯性思维。理解好必须要有代码积累量。

1. 简单工厂模式

2. 命令模式 interesting

某方法 完成 某行为，该行为的具体实现必须等执行时才确定。

• java8中通过Lambda表达式可以传入代码块作为参数。

public interface Command {
    //普通方法 public abstract
    void process(int[] target);
}
----------------------
public class ProcessArray {
    void process(int[] target, Command c) {
        c.process(target);
    }
}
------------------------
public class PrintCommand implements Command{
    public void process(int[] target) {
        for (int i : target) {
            System.out.println("迭代打印数组元素" + i);
        }
    }
}
-------------------------
public class AddCommand implements Command{
    public void process(int[] target) {
        int sum = 0;
        for (int i : target) {
            sum += i;
        }
        System.out.println("数组总和" + sum);
    }
}
-----------------------------
public class CommandTest {
    public static void main(String[] args) {
        ProcessArray p = new ProcessArray();
        int[] arr = {1, 2, 3, 4, 5};
        p.process(arr, new AddCommand());
        p.process(arr, new PrintCommand());
    }
}
输出：
数组总和15
迭代打印数组元素1
迭代打印数组元素2
迭代打印数组元素3
迭代打印数组元素4
迭代打印数组元素5