java_oop_类

类的初始化顺序
    再论类的组成
    类的初始化顺序详解
    
    变量
        实例变量（成员变量）
        类变量（静态变量）
    方法
        实例方法
        类方法
        构造方法
    初始化块
        实例初始化块
        静态初始化块
    内部类
    
    单个类的初始化顺序
        静态成员变量，静态代码块（与顺序有关）
        实例成员变量，代码块（与顺序有关）
        构造方法

方法重载
    重载的概念
    重载的调用
    重载与装箱/拆箱
    重载与可变长度参数
    
    方法重载是指在同一个类中,有相同名称但参数不同的方法
        参数不同:
            数量不同
            数据类型不同
            顺序不同
        只有能区分开方法,就是合法的
    一般方法的重载
    构造方法的重载
    
    优先级
        实参是基本类型
        实参是包装类

方法重写
    方法重写的概念
    方法重写的语法
    
    @override注解
    父类
    子类，重写父类的方法
    测试类，这是调用类
    
    方法的重载
    重写语法规则
    
    
        
        
this关键字
    指向当前的实例
    使用场景
        方法中使用
        构造方法中
    this不能用在static上下文中
    
    
super关键字
    指向父类的实例
    使用场景
        在一般的实例方法中使用
        在构造方法中使用
    在构造方法中使用必须是第一句代码
    
        
访问控制修饰符
    在java中，有4种访问控制修饰符
    可以放在方法与变量前，部分访问控制修饰符也可以放在类前
    目的是控制代码的访问权限
    
    public修饰方法，变量，和类
    protected,本包及子类
    默认，本包
    private，本类可以访问
    
    同一个类中调用
    同一个包中不同类调用
    不同包中不同类调用

final关键字
    final关键字在不同的使用场景下的意义
        如果修饰变量，该变量实际是常量，一旦初始化了就不可修改
        如果修饰方法，该方法不可被重写
        如果修饰类，表示该类不可被继承
        
        
向上转型与向下转型
    转型概念
    instanceof关键字
    
    
绑定
    绑定概念
    编译时绑定与运行时绑定
    
    编译时绑定
        由编译器在编译时就已经决定调用哪个方法或属性
        用于：
        所有类型的属性（静态或非静态）
        static方法
        非static的final方法（不可被子类重写的）
    运行时绑定
        由jvm在运行时才决定调用哪个方法或属性
        用于：
        非static，非final方法
        理论上讲有一点性能损失，但与其好处相比基本可以忽略，因为它可以帮助我们实现多态

包装类
    什么是包装类
    使用jdk api文档
    包装类的实例化
    
    基本数据类型的局限
    基本数据类型与引用类型不可互相赋值，不可相互比较
    有些java类只能处理引用数据类型（一些框架中使用）
    
    java在java.lang中提供了8个类代表8种基本数据类型
    把8种基本数据类型包装到8个类中，就变成了引用数据类型了
    基本数据类型    包装类
    byte            Byte
    int                Integer

https://docs.oracle.com/javase/8/docs/api/index.html
    
    包装类的实例化
    所有的包装类都是不可变的，不可变意思是说，不在原来的内存空间做修改，而是开辟新的空间，之前的String就是这样的（不可变）
    实例化的方式
        构造方法
            除了Character类，其它包装类都提供了两种构造方法（）
        valueOf()方法，这是一个静态方法
        这两种方法的区别
            new关键字总是会创建一个新对象
            valueOf()方法会缓存范围在-128至127之间的整形数值(byte,short,int,long)

package com.fgy.java8se;

public class Demo12 {

    public static void main(String[] args) {
        Integer i1=new Integer(200);
        Integer i2=new Integer("200");

        Short s1=new Short((short) 100);
        Short s2=new Short("200");

        Integer i3=Integer.valueOf(300);
        Integer i4=Integer.valueOf("200");
        Integer i5=Integer.valueOf("200", 8);
        System.out.println(i5);
        Integer i6=new Integer("100");
        Integer i7=new Integer("100");
        //i6肯定不等于i7,它们是不同的对象
        System.out.println(i6==i7);
        Integer i8=Integer.valueOf(100);
        Integer i9=Integer.valueOf(100);
        //因为范围在-128到127之间，所以它们是相等的
        System.out.println(i8==i9);
    }

}

包装类的使用
    数字包装类
        Byte,Short,Integer,Long,Float,Double
        xxxValue()
        parseXxx()
        包括常量，表示这些数字的范围
        java8在某些类中新增了几个方法：
            sum(),max(),min()主要用于lambda表达式处理集合。
    字符包装类
    布尔包装类

自动拆箱/自动装箱
        在基本数据类型与对应的包装类之间自动互相转换，该转换是在编译时执行的
        装箱：基本类型转换成对应的包装类    box
        拆箱：包装类转换成对应的基本类型    unbox
====================================================

8种基本类型，又分三种，boolean类型的，number类型的（integral和floatingpoint）
boolean,byte,char,short,int,long,float,double
java.lang中的类
Boolean,Byte,Character,Short,Integer,Long,Float,Double
一些特殊的类：Object,Class,Enum,String,Void

既然提供了基本类型，为什么还要使用封装类呢？
某些情况下，数据必须作为对象出现,此时必须使用封装类来将简单类型封装成对象。

比如，如果想使用List来保存数值，由于List中只能添加对象，因此我们需要将数据封装到封装类中再加入List。在JDK5.0以后可以自动封包，可以简写成list.add(1)的形式，但添加的数据依然是封装后的对象。
另外，有些情况下，我们也会编写诸如func(Object o)的这种方法，它可以接受所有类型的对象数据，但对于简单数据类型，我们则必须使用封装类的对象。

某些情况下，使用封装类使我们可以更加方便的操作数据。比如封装类具有一些基本类型不具备的方法，比如valueOf(),
toString(), 以及方便的返回各种类型数据的方法，如Integer的shortValue(), longValue(),
intValue()等。
基本数据类型与其对应的封装类由于本质的不同，具有一些区别：
基本数据类型只能按值传递，而封装类按引用传递。
基本类型在堆栈中创建；而对于对象类型，对象在堆中创建，对象的引用在堆栈中创建。基本类型由于在堆栈中，效率会比较高，但是可能会存在内存泄漏的问题。
===================================

object类-1
    java中的单根继承
    重写object类中的toString()方法
    
    java中的单根继承
        在java中不允许多继承，一个父可以有多个子，一个子只能有一个父
        所有的类，包括数组都是直接或间接继承自object类
    object类
        该类来自java.lang包
        可以将所有的引用类型值赋值给object类型声明的变量，包括null
        object实现了的且不允许子类重写的：
            getClass(),notify(),notifyAll(),wait()
        object实现了的且允许子类重写的：
            toString(),equals(),hashCode(),clone(),finalize()
    重写toString()
    重写equals()

重写HashCode()
        一段信息经过hash算法之后得到一个整数值（就叫哈希码）
        为何需要哈希码
            在基于哈希存储数据的集合或容器中，能通过哈希码高效获取数据
            HashSet,HashMap,HashCode等，
            如果存储的数据与hashcode没有关系，不需要重写hashcode()

package java_20180213_oo;

class User{
    String name;
    int num;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getNum() {
        return num;
    }
    public void setNum(int num) {
        this.num = num;
    }

    @Override
    public boolean equals(Object obj) {
        if (this==obj) {
            return true;
        }
        if (obj instanceof User) {
            User u=(User)obj;
            return u.getName().equals(name) && u.getNum()==num;
        }
        return false;
    }

}

public class ObjectsDemo {

    public static void main(String[] args) {
        int num1=20;
        int num2=20;
        System.out.println(num1==num2);
        System.out.println("========");
        User u1=new User();
        u1.setName("tom");
        u1.setNum(12);
        User u2=new User();
//        u2.setName("jack");
//        u2.setNum(13);
//        System.out.println(u1==u2);
        u2.setName("tom");
        u2.setNum(12);
        System.out.println(u1==u2);
        System.out.println(u1.equals(u2));
    }
}

抽象类
    概念
    声明抽象类与抽象方法的语法
    抽象类的特征与作用

内部类1
    内部类的概念
    内部类的分类
    内部类的实例化与使用
    
    分类
        成员内部类
        局部内部类
        匿名内部类
            没有名字与构造方法的类