Java基础学习--第一弹

目录

1. 8大基本数据类型

2. 面向对象的三大特征

3. 接口和抽象类

4. final 关键字

---

1. 8大基本数据类型

 

基本数据类型

	存储字节	默认值	包装类
byte	1 ≈ 8bit	0	Byte
short	2	0	Short
int（整型默认数据类型）	4	0	Integer
long	8	0	Long
float	4	0.0	Float
double（浮点型默认数据类型）	8	0.0	Double
char	2	null	Character
boolean	1	false	Boolean

    基本数据类型和包装类的区别：

        1） 包装类是对象，拥有方法和字段，通过引用对象的地址进行对象的调用

        2） 包装类型是引用传递，基本类型是值传递

        3） 存储位置：包装类创建出的对象存储在堆中，而基本数据类型直接将值存储在栈中

        4） 声明方式：包装类需要new一个新的对象，基本数据类型不需要new关键字

        5） 初始值：包装类的初始值全部为null

 

Integer.valueOf() 方法的作用：

    Integer.valueOf() 可以将基本数据类型转换为包装类型Integer，或者将String转换为Integer，String如果为null或“”则报错。

    以下是Integer的一部分源码

public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
}

private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];

        static {
            // high value may be configured by property
            int h = 127;
            String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                try {
                    int i = parseInt(integerCacheHighPropValue);
                    i = Math.max(i, 127);
                    // Maximum array size is Integer.MAX_VALUE
                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                } catch( NumberFormatException nfe) {
                    // If the property cannot be parsed into an int, ignore it.
                }
            }
            high = h;

            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);

            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }

        private IntegerCache() {}
}

    从上述源码可得，在静态代码块中已经将值在[-128，127]之间的整数创建出对象并存入堆中，因此当再次创建值在[-128，127]之间的整数时，会直接拿缓存而不会创建一个新的Integer对象。

public static void main(String[] args) {
        
        Integer a = new Integer(1);
        Integer a1 = new Integer(1);
        System.out.println(a == a1); // false
        System.out.println(a.equals(a1)); // true
        
        Integer b = 2; // 等价于 Integer b = Integer.valueOf(2);
        Integer b1 = 2;
        System.out.println(b == b1); // true
        
        Integer c = 128;
        Integer c1 = 128;
        System.out.println(c == c1); // false
        
        Integer d = new Integer(3);
        int d1 = 3;
        System.out.println(d == d1); // true
}

---

2. 面向对象的三大特征

    封装

        把客观事物封装成类，类中封装了事物的属性以及对这些属性的操作方法。

    继承

         通过继承可以让子类获得父类的所有非私有成员变量和方法。当子类中有与父类同名的成员变量时，子类成员变量会覆盖父类的成员变量，而不会继承。子类可以对父类的方法进行重写。

    多态

        同一个操作在不同的对象中，会产生不同的语义，从而有不同的效果。多态机制使不同内部接口的对象可以共享外部的接口。

        多态的两种表现形式：

            方法重写：方法名和参数列表完全相同的方法

            方法重载：方法名相同但参数列表不同的方法，返回值不同不可以作为方法重载的条件

---

3. 接口和抽象类

    接口：接口是抽象方法定义的集合，是一种特殊的抽象类。接口中只能包含方法的定义，不能有方法的实现，接口中所有方法都是抽象的。接口的成员作用域修饰符都是public，接口常量默认使用static final 修饰。一个类可以实现多个接口，因此可以采用实现多个接口的方式间接达到多重继承的目的。

    抽象类：只要有一个抽象方法就要声明为抽象类。抽象类除了不能实例化之外与具体类没有什么区别，抽象类可以有部分实现，他不能有构造器和抽象静态方法。抽象类可以实现接口也可以继承具体类。

接口与抽象类的区别

	Abstract class	Interface
实例化	不能	不能
类	一种继承关系，一个类只能使用一次继承关系	一个类可以实现多个接口，间接达到多重继承的目的
数据成员	可以有自己的	数据成员只能用static final 修饰
方法	可以私有，也可以有非抽象方法	不可私有，默认public abstract （JDK1.8后，被default修饰的方法可以有方法体）
变量	可以私有，默认是friendly，其值可以在子类中重新定义，也可以重新赋值	不可私有，默认是public static final ，且必须给定初始值，实现类中不能修改和重新定义
设计理念	is a	like a
实现	需要继承，extends	实现，implements

---

4. final 关键字

    1） 被final修饰的类不能被继承，如String类（不可变类）

    2） 被final修饰的方法不能被重写和重载

    3） 被final修饰的变量为常量，经过初始化后不能更改。如果final修饰的是引用类型的变量，那么是它的引用地址不可更改，但是内容可以更改。

---

菜鸡第一弹总结完成，欢迎大家指正！