- 基本类型的包装类
final修饰- 变量 不允许重新赋值
- 方法 子类不能覆盖
- 类 不能派生子类
abstract 抽象类：多个类的模板
interface 接口：多类应该遵守的规范
lambda表达式
enum枚举类：不能自由创建对象的类，对象在定义类时已固定（class季节，能创建的实例有限且确定）
- 包装类可实现基本类型变量和字符串之间的转换
字符串 -> 基本类型
使用包装类的方法
- 静态方法 parseXxx(String s) 除了Character
- 构造器 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种成员
- 成员变量
- 方法
- 构造器 ×
- 初始化块
- 内部类（接口，枚举）
除了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方法）
使用接口：
不能创建实例，但可以用于声明引用类型变量，指向其实现类的对象
接口用途：
- 定义变量，进行强制类型转换
- 调用接口中定义的常量
- 被其他类实现
- 实现接口方法时，必须用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
