Java 复习笔记day1- 加深理解

主要用于对于自己以前不太熟悉的知识加深印象

1. extends 和 implements 的区别：
从程序的角度来说：
extends 和 implements 之间的区别好像也只有 extends 是单根继承 而 implements 是可以有多个的实现类
而从语义上来讲：
extends: 表达的是 “是什么”。如果 A 继承于 B 那么表达的是 B 是一个更大的类型，也就是 A 是 B。举例来说: 比如 bird 类继承于 animal 表达的语意是 bird 是 animal
implements: 表达的是能力。如果 A 有 B 的接口，表达的是 A 可以做 B 的事情。举例来说：bird 类 继承于 flyable 表达的语意是 bird 有 fly 的能力

2. 容器和数组:
数组一般用于定长的情况

3. 静态方法的适合使用的情况：

• 本身来说静态方法在java中是不推荐使用的：
  首先，它在程序初始化运行时候就会加载到内存中，后期只要调用，调的都是同一个方法(同理于静态变量)，一直都不会被释放，占用内存。
  其次，在高并发问题中也存在问题。
• 但是不代表没有它适用的场合：
  在大量的重复使用一个方法时候。如果它是一个非静态方法，正常操作就是会实例化很多的对象，从而调用这个方法。要知道实例化的过程是分配内存的过程，非常消耗时间，因此在这种情况下可以考虑使用静态方法。
  比如实战过程中假设有server包下的AppServer类，显然这个类下的方法是要非常经常调用的，但是有可能这个类下有大量的方法，存为静态过于消耗内存，因此会有Spring框架的出现

4. 方法传参
不同于C ， java 传递的是引用，而非仅仅传值

5. .equals() 和 == !=
在默认的情况下，.equals() 比较的是引用而非值，因此如果我们自己构建了一个类， 并且没有override equals 方法，那么就会发现尽管生成了两个存放值一样的对象，使用 equals方法 结果仍然是false。
但是，.equals() 被大多数的Java的类 override 了，用于判断其值是否一致
而 == 和 != 本身就是用于比较值是否相等的

6. java 中仍然存在短路语句

7. break continue goto
goto语句由于会使得程序难以理解因此不推荐使用
但是我们会有这种情况，多重循环中的内层循环中达到某一个条件时候跳出所有的循环，这种情况常见，但是没有goto语句在C等语言中不好处理，因此，java 的解决方法是，在外层循环上一行加一个标签，比如label1：，使用时候 break label1

8. JavaBean
一种遵循的写法，将变量都设置成private，接触该变量的方式是暴露给外界的方法：setter getter

9. 重载
构造器和方法都可以重载，名称相同，返回值相同（理论上是可以用返回值来重载的但是并不推荐），参数列表不同
一般用于对不同的事物做类似但方法不同的操作。
比如： 吃饼干，吃水果，。。。 动作都是 吃，但是对象不同，吃法不同，因此要重载

10. 构造器的重载
要知道在Java中如果一个类没有构造器是不可以生成对象的。在我们没有显式的创建构造器时候，java会自动生成一个默认构造器，其传入参数为空。但是如果我们显式的创建了构造器，那么默认构造器就不会生成。
因此，我们会发现，如果创建一个参数列表非空的构造器，而没有创建参数列表为空的构造器，那么className temp = new className() 不能生成对象

11. this 的使用
最简单的是 用this表示是当前的对象
还有就是 在构造器中想要调用自己这个类的别的构造器时候： this(参数列表)

12. 可变参数列表
约束 返回值 函数名(Object... args)
代表 args 是一个Object类型数组
但是传入参数时候不用写成 new Object[]{.., ..,...} 的形式
只需要正常传参数就好
当然 不一定非要是 Object 类型 String Character ... 都是可以的
但是： 要注意的是，由于可变参数列表的出现，方法重载很难让编译器分清究竟哪一个是调用的方法，解决方法是，在可变参数列表前加入非可变参数

13. enum
用法：

public class Demo{
    private enum job{
        Doctor, nurse, teacher
    }
    public static void main(String[] args) {
        job person1 = job.Doctor;
    }
}

笔者之前从来不用enum 但是enum还是有很好的用处：
它结合switch语句可以使得程序具有更好的自注释特性

enum 应该是和 class interface 同级的
其生成类 job
job 生成实例 person1

14. 包的权限控制
包的权限只有两种选择: public 和 包访问权限
public 就是 别的包可以引这个包里的这个类
包访问权限 就是 只有本包可以引用这个类

15. 单例设计模式
如果在设计一个类时候，不希望使用者直接获得该类的实例
可以将构造器设置为私有的，然后通过内部的静态方法调用构造器返回出去
如果希望在生成的过程中前前后后一直是一个实例，那么可以是在这个静态方法中设置一个私有静态变量，调用构造器，返回该静态变量的值

public class Demo{
    private static Demo temp = new Demo();
    private int a = 0;
    public void setA(int value){
        a = value;
    }
    public int getA(){
        return a;
    }
    private Demo(){
    }
    public static Demo createDemoInstance(){
        return temp;
    }
}

class test{
    public static void main(String[] args) {
        Demo temp1 = Demo.createDemoInstance();
        Demo temp2 = Demo.createDemoInstance();
        System.out.println(temp1.equals(temp2));
    }
}

结果：

true

16.在每一个主要的类中加一个main方法
在没有完成整个项目之前也不需要删除，便于单元测试

17. 在子类实例化一个对象的时候，它的父类先实例化一个对象

class Animals{
    private Animals(){
    }
}
class birds extends Animals{

}

发生报错，因为父类无法实例化对象

18. final 的作用
final的含义：限制变量不变

• 作用于 基本数据类型，使数值恒定不变

• 作用于 引用类型，使引用不变，也就是说，这个引用不能再指向另一个对象

• 同时被static 和 final 限制的变量，很好理解代表 编译时常量 ，存储在一块不能改变的存储空间，这个时候一般将变量大写

• 作用于 函数声明中参数（非基本类型），代表这个参数引用不能指向其他的对象

• 作用于 函数声明中参数（基本类型）， 代表这个参数是只读的，不可修改

• 作用于 方法，这个方法不可以被override

• 作用于 类，代表这个类不可以有子类

19. interface 和 extends

public class Demo{
    public void act(Runable animals1, Animals animals2){
        animals1.run();
        animals2.feed();
    }

    public static void main(String[] args) {
        Runable animals1 = new Bird();
        Animals animals2 = new Bird();
        Demo demo = new Demo();
        demo.act(animals1, animals2);

    }
}

interface Runable{
    public void run();
}
class Animals{
    public void feed(){
        System.out.println("Animal feed");
    }
}
class Bird extends Animals implements Runable{
    @Override
    public void run() {
        System.out.println("bird can run");
    }

    @Override
    public void feed() {
        System.out.println("bird feed");
    }
}
class Bear extends Animals implements Runable{
    @Override
    public void run() {
        System.out.println("bear can run");
    }

    @Override
    public void feed() {
        System.out.println("bear feed");
    }
}

结果：

bird can run
bird feed

尽管传入的是接口类 或者 父类，但是 编译器仍然能够分清它是什么具体实现类
interface 类中的方法声明不需要限制 public 因为它本身就是public的

20. 工厂模式
抽象产品类（定义所有产品都需要有的接口）
多个实现产品类继承于该抽象类
抽象工厂类（定义所有工厂需要有的动作，不具体到实现产品类）
实现工厂类

21. 接口中存放的域是 static 和 final 的
22. 内部类
笔者没怎么用过内部类，但是，内部类有很多的优势：
可以将一些有关系的类连接到一起
可以将代码写的更加优雅

部分细节

Random rand = new Random(12);//放入种子（即一个数），没放就是根据当前时间来生成
for(int i = 0;i<10;i++)
     System.out.println(rand.nextInt(100));//生成0到100的随机数