CS-Notes打卡第三天、运算、关键字

最近同事陆陆续续都开始离职了，心情复杂，高不成低不就或许就是最可怕的。
CS-Notes

运算

引用传值

在Java当中对象就等同于C++中的指针，当我们向一个方法传递一个对象，实际上是将对象的地址以值得形式传递到方法中得形参。
例如一下代码:

public static void main(String[] args) {
       List<Integer> arryas = new ArrayList<>();
        arryas.add(1);
        arryas.add(2);
        System.out.println(arryas.hashCode());
        doArray(arryas);
        System.out.println(arryas.get(2));
    }

   public static void doArray(List<Integer> a){
        System.out.println(a.hashCode());
        a.add(3);
    }

输出结果:

可以从两点获取前后操作得Arryalist是同一个值
1.两个输出得hashCode值一致
2.在方法中add的3可以在doArray下面获取到

注，因为是将对象的地址当作值传递到方法中的形参，因此当形参中改变了引用不会修改到外面的值，例如:

public static void main(String[] args) {
        List<Integer> arryas = new ArrayList<>();
        arryas.add(1);
        arryas.add(2);
        System.out.println(arryas.hashCode());
        doArray(arryas);
        System.out.println(arryas.get(1));
        System.out.println(arryas.get(2));
    }

public static void doArray(List<Integer> a){
    a  = new ArrayList<>();
    a.add(1);
     System.out.println(a.hashCode());
 }

可以看到，前后的hashcode改变了，同时不影响之前新增的2，在get index=2的时候报数组越界。

隐式类型转换

Java中不能够隐式的向下转型，因为这样会降低精度
例如float f = 1.1在编译器中就会提示失败
float f = 1.1f就不会报错，但是需要注意当给short类型赋值的时候
short s = 1 不会报错,s = 32767也不会报错当赋值超过short的范围就会报错例如:

当使用+=或者++操作的时候会进行隐式类型转换如

short b = 32767;
int intA = 999999;
b++;
b = b+intA;
b+=intA;

如上的写法编译器会提示报错，同时32767是short的上限++也不会报错只不过会溢出变成负数

小结:Java不会隐式的向下类型转换，但是当使用++或者+=操作的时候会进行隐式类型转换相当于向下强转

switch操作

1. Jdk1.7之前 只支持int,short,byte,char以及包装类
2. Jdk1.7之后 也支持String
   当用switch(1.1)的时候编译器会提示
   Incompatible types. Found: ‘double’, required: ‘char, byte, short, int, Character, Byte, Short, Integer, String, or an enum’
   可见只支持char,byte,short,int,Character,Byte,Short,Integer,String或者枚举这些类型

关键字

final

表示常量

数据

1. 针对基本类型，使基本类型数据不变
2. 针对对象，引用不变，不能够引用其他对象，但是引用的对象的值是可以改变的

情况1，如图当第二次对常量基本类型或者常量对象赋值报错

但是常量对象的引用值还是可以修改，例如

 static class Pojo{
        int a;
        Pojo(int a){
            this.a = a;
        }
    }
public static void main(String[] args) {
        ObjectTest objectTest = new ObjectTest();
        final Pojo p = new Pojo(1);
        Pojo c = p;
        c.a = 2;
        System.out.println(p.a);
    }

最后的输出为2

方法

常量方法不可以被重写

private方法隐式的被指定成final，如果在子类中定义的方法和基类中的一个private方法签名相同，此时子类的方法不是重写基类方法，而是在子类中定义了一个新的方法

类

声明的类不可以被继承

static

表示静态

变量

1.静态变量:又称之为类变量，也就是说这个变量属于类，类所有的实例都共享静态变量，也可以通过类名直接访问。静态变量在内存中只存在一份
2.实例变量:实例变量:每创建一个实例就会产生一个实例变量，与实例同生同死
例如下面int a 就是实例变量伴随实例的创建而创建，static int b就是静态变量，在Pojo类加载的时候就创建了

static class Pojo{
        int a;//实例变量
        static int b;//静态变量
        Pojo(int a){
            this.a = a;
        }
    }

方法

1.静态方法在类加载的时候就创建了，不需要依赖任何实例。所以静态方法必须有实现，不能是抽象方法
2.因为使用this和super关键字必须要依赖于实例，而静态方法是在类加载的时候就创建了，这个时候还不存在实例，因此静态方法不能够有this和super关键字

静态语句块

静态语句块只会在类加载的时候运行一次

静态内部类

因为静态内部类不需要依赖外部类，因此静态内部类可以直接new ,而非静态内部类需要依赖外部类，因此先需要new 外部类的实例，然后通过外部类的实例new 内部类例如

public class ObjectTest {
    class Jojo{

    }

    static class Pojo{
        int a;
        static int b;
        Pojo(int a){
            this.a = a;
        }
    }


    public static void main(String[] args) {
        ObjectTest objectTest = new ObjectTest();
        final Pojo p = new Pojo(1);
        Jojo jojo = objectTest.new Jojo();
    }
}

初始化顺序

1. 静态变量和静态语法块优先于实例变量和普通语法快
2. 静态变量，静态语法块初始化的先后顺序取决于代码中的顺序
   

关键字的xmind
运算的xmind