java编程自学记录（day08）

昨天的内容复习：

访问控制：封装，将数据封装到类的内部，将算法封装到方法中
 封装结果：存在但不可见。
public  ：任何地方可见，修饰：属性，类，方法，内部类
   跨包访问类。需要使用import语句导入
protected ：当前包中可见，子类中可见。只可以修饰类的成员
   只能在类体中使用，包括：属性，方法，内部类
默认的(无修饰词)：当前包中可见，修饰：类，属性，方法，内部类等
   在实际项目中比较少用。
private  ：仅在类内部可见。修饰：类的成员，包括属性，方法，内部类

static：静态的，只能在类内部使用，可以修饰：属性，方法，内部类，静态代码块等
 1）静态修饰的成员：属于类级别的成员，是全体类实例共享的资源。
 2）静态属性：只有一份，全体实例共享，类似于全局变量
 3）静态方法：属于类的方法，使用类名直接调用，不需要创建对象。而且静态方法中没有隐含参数this
 4）静态代码块：在类加载期间执行，只执行一次，可以用于资源加载。

final：最终的，可以修饰：类，方法，变量（属性，局部变量）
 1）final类：不能再继承
 2）final方法：不能再重写
 3）final方法和类，阻止了动态代理模式！
  因此企业中不允许使用final类和final方法。
 4）final变量：只能初始化一次，不能再修改。可以先定义再初始化。

常量：
 public static final double PI = 3.1415926595

（1）私有方法不能继承，自然也不能重写。
 在父类型定义一个私有方法，子类型重新定义一个同名同参数列表的方法，
 在实际使用时会调用引用变量类型所在类的方法，参见Demo02。
（2）数组的存储结构
 String[] s = {"A","B"};
 如上，数组元素存储在堆中，s是数组类变量，属于引用变量，分配在栈中，s指向的堆中数组的位置。
 有点类似于类的对象和引用变量的定义。
（3）对象数组
 1）概念：数组元素是对象的数组
 2）Point[] ps = new Point[3];
  上述语句执行后，引用变量ps（Point[]的引用）引用了Point[]类的对象数组，对象数
  组的每个元素都指向一个Point类型的对象。（注意区分Point[]类和Point类）
  上述语句执行后，ps实际上指向了一个空的数组，数组元素为null(自动初始化)。
 3）初始化对象数组时，要注意将其每一个元素进行实例化
 4）数组静态初始化只能用于定义和初始化一起进行的情况：
  Point[] ps2 = {new Point(3,4),new Point(5,5)};
 5）数组本身也是类型，类型是类名[]，如Point[]。
（4）在打印对象时会默认调用toString方法，这个方法是从Object类继承来的，因为每个类都默认
 继承Object类。调用以下两个语句效果一致：
 System.out.println(ps[0]);
 System.out.println(ps[0].toString());
 为了好看，可以在类中重写toString方法
（5）数组类型数组（二维数组）
 1）Java中没有真正的二维数组！Java的二维数组是元素是数组的一维数组。即实际上是若干个
 一维数组，其中一个一维数组的元素是其它一维数组。
 2）int[][] array = new int[2][3];
  array的类型是int[][]，指向堆中存储的类型为int[][]的一维数组A，这个一维数组的每
 个元素指向类型为int[]的一维数组B，B中的元素是int类型。
 
（6）抽象类
 1）包含抽象方法的类一定是抽象类
 2）抽象类可以定义变量，但是不能直接实例化，只能被继承。
 3）具体类在集成抽象类时必须实现全部的抽象方法
 4）抽象类可以定义引用变量，但是不能实例化，其定义的变量可以引用子类的对象，并调用子类中重
 写的方法。
（7）接口
 1）一个类中，所有方法都是抽象方法，所有量都是常量。就是彻底的抽象类
 2）interface替代了abstract class两个关键字
 3）接口中定义的常量和方法
  a.定义的常量之前可以省略public static final
  /*public static final */ int SPEED = 100;
  b.定义的方法之前可以省略public abstract
  /*public abstract */void run();
 4）接口之间是可以继承的，但是非常不建议使用
 5）接口类似抽象类，可以定义变量，不能实例化，即只能被“实现”（继承）
 6）具体类实现一个接口必须实现全部的抽象方法
 7）具体类可以同时实现多个接口，就是多继承现象
 8）具体类实现接口时用implements关键字，该关键字可以实现多个接口(多继承)，接口之间用
 逗号隔开
 9）接口定义的引用变量，可以引用具体类的对象。
 10）接口引用变量引用具体类对象时，接口变量只能调用接口定义过的方法，没定义过的不能调用，
 这是与之前说的方法动态绑定到对象一说有区别，要注意区分。Demo10
（8）实现与继承的区别
 1）本质上实现也是继承
 2）因为接口中的方法都没有方法体，具体类（不叫做子类了）继承时，增加了方法体，因此叫做实现
 了接口的功能。但是接口中的常量在子类中调用时，这个常量是继承过来的，而不是实现的。
（9）多继承
 指的是子类继承多个父类，通过接口实现。
（10）内部类(Inner class)
 1）定义：一个类可以定义在另外一个类的内部，定义在类内部的类称之为Inner，其所在的类称为
 Outer
 2）内部类主要用于封装一个类的声明在类内部，减少类的暴露，有利于提高类的封装性。
（11）匿名内部类(也叫匿名类anonymous):因为在main方法中，所以称作内部类
 1）定义：匿名内部类也就是没有名字的内部类，正因为没有名字，所以匿名内部类只能使用一次，它
 通常用来简化代码编写，使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口
 2）new Uoo(){};就叫匿名内部类。是继承于Uoo类的子类，并且同时创建了子类型实例。
 其中“{}”是子类的类体，这里面可以写任何正常的类的东西。
 3）在匿名内部类访问局部变量时，只能访问final局部变量（现在好像不是这样的）

其他知识：
（1）在企业项目中建议：所有类都是公有类。封装的类使用内部类。
（2）java文件规则：
 1）一个java文件中可以有多个类，但是只能有一个公有类！
 其他类只能是默认类（包中类），而且java的文件名一定与公共类类名一致。如果没有公有类，可以和
 任何一个类名相同。
 2）一般建议：一个文件一个公有类！一般不在一个文件中写多个类
（3）java没有全局变量这个概念，因为全局变量是破坏封装的
（4）静态代码块和代码块的区别
 1）代码块：在创建对象时执行，类似于构造器
 2）静态代码块：在类的加载期间执行，只执行一次
（5）动态代理模式：继承并重写
 广泛应用在：Spring Hibernate Struts2
（6）每个类尽量定义一个无参数构造器，为了写子类方便。子类创建时会自动调用父类无参数构造器，不定义
 可能会出错。
（7）数组扩容原理
 1）Java数组对象的大小是固定不变的，数组对象是不可扩容的。
 2）利用数组复制方法可以变通的实现数组扩容。
 3）System.arraycopy()可以复制数组。
 4）Arrays.copyOf()可以简便的创建数组副本。(内部调用了arraycopy)
 5）创建数组副本的同时将数组长度增加就变通的实现了数组的扩容。
（8）建议在高性能场合不建议使用二维数组，因为二维数组性能不好。
（9）java中定义变量、方法名之类的可以使用中文，因为其支持Unicode编码。但是不建议这样写。
（10）常量的名字一般使用大写字母表示
（11）软件上尽量使用接口，少使用抽象类。

用到的实例：
 贪吃蛇的实现。
 需求分析：
 1）蛇会在舞台上定时自动运行
 2）用键盘光标键控制蛇的运行
 3）蛇不能反向运行，反向运行没有动作发生
 4）蛇吃到食物后长度会增加一节
 5）食物被吃掉之后会随机生成新的食物
 6）蛇碰到边界或吃到自己会死亡