Java复习笔记

在java中 将Int 转换为  boolean 1表示为true，而0表示为false。
3W1H ？？？
Why  what  where  How
这是什么  为什么使用  在什么时候使用  如何使用
多想 ， 少敲 ， 读概念



查看Arraylist和Linkendlist 实现原理和区别
HashSet 实现原理和区别
HashMap


1.初识面向对象

第一章：封装篇：

    有属性的类叫实体类
    有方法的类叫实现类
    
    什么是封装？：
        将类的特征和行为封装到一个集合中 通过特殊的接口进行调用
        封装 ：隐藏对内实现 对外调用接口
 

    构造方法：与类名相同，主要完成对象实例完成工作
            无返回值类型
    速成构造 Alt+Shift+S+O快捷键    
        
    重载： 同名 同类 不同参
    
    deBug：使用
        F5： 步进 进入方法中扫描中的内容
        F6： 步过 表名扫描执行
    
    
静态变量 与 实例变量的区别
    静态方法和变量可以在 静态方法类中和实例方法类中别调用
    静态中不能放实例方法
    静态类通过static修饰 通过类名.的方式调用
    
    封装属性 Alt+Shift+S+R快捷键    
    getter 可以直接获取其中的值 直接为他+-不会影响其中的结果
    setter 设置其中的值，可以set.num(get.num()+10) 既会影响一些值又会 知道其中调用的是那些值
    
    

    public  所有类都可以访问
    private  本类可以访问
    protected 本类和子类可以访问
    
    this.调用当前的成员变量

    重温变量作用域
        表示逻辑语句块中的内容{}  并且其中的内容不能到其他的逻辑语句块{}
        但是可通过特殊的媒介进行使用
        例：
        int a= 0;
        void print(){
            a = 0;            
        }
        想要使用 就必须声明他的临时变量 但是一定要明确
            (大括号){}的位置与所需要的位置不能出错
        例：
        判断 5>5 执行打印 在判断 5>2 在5>3
        循环 5>3 和 5>4中的打印语句 以下就出现的错误
        if(5>5){
            if(5>2){
                while(true){
                    if(5>3){
                        System.out.print()                    
                    }            
                }
                if（5>4）{
                    System.out.print()
                }
            }
        }




第二章：继承篇：

   什么是继承？：
        将多个含有相同特征的类抽取到一个父类中，并让需要特征的类进行继承这个具有相同特征的大类
        减少代码冗余 提高了程序的重用性
    extends；
    伊克斯疼的思
    在java中使用extends实现单继承
        并且也只能单继承 以及传递性
        
        
    private 只能本类中进行访问
    protected 本类和被继承的类才能访问
    public 所有类都可以访问
    
    子类重写父类方法：
        在继承的前提下，子类重写父类方法，使代码中相同的方法有共同的父类
        主要减少代码冗余；
        
        
    在子类中调用父类中共有的属性和方法使用super关键字进行调用
    this关键字的作用是 调用本类中的成员方法或者属性
    
    在调用构造方法的时候，使用Alt+shift+S+O
    调用父类构造方法的注意事项！！
        1.父类中有一个无参的默认构造函数
        2.子类继承父类的构造函数 可以共享其中的属性 子类实例的时候任然是子类的数据
        3.构造函数写在super关键字中的类型，顺序，名称最好不要改变；
        4.构造方法为该对象实例化的赋值使用的
        
    
    实例化对象的时候一定要记住其中被执行的构造方法是哪一个！！！
    最重要的是参数
    
    重温abstract方法，
    抽象方法没有方法体
    抽象方法以;号结尾
    抽象方法被继承时 必须被子类实现
    
    final[常量](最终)修饰的属性，方法，类 表示唯一的 一旦赋值之后 就不能重新赋值




第三章：多态篇：

    什么是多态？
        多态是具有多种形态的能力特征，同一个实现接口使用不同的实例而执行不同的操作
        一个接口，造成了多种不同的实现操作
        
        
    多态有哪些优点？
         在有继承关系前提 子类继承父类中的方法 并实现 其中的方法最终实现的多态
        减少了代码了冗余，比如 方法重名 在多个类中被定义，造成了很多方法的重复 所以使用多态的
        实现父类方法的形式 减少代码，而且删除了子类中被实现的代码，对于父类并没有什么影响！！
        从而提高了程序的可维护性
        
    实现多态方式有哪些？
        向上转型和向下转型
        有继承前提下，实现父类方法
        使用父类型当做形参
        使用父类当返回值类型
        父类当对象 
        把父类放入集合
        
        
        
    向上转型：
        父类型 实例子类； 父类引用指向子类实例 里氏替换原则
        Pet pet = new Dog(); 装箱操作
        
    向下转型：
        将父类强制转换为子类：不推荐，能使用向上转型，就一定不要使用向下转型
        他会损失一些数据
        Pet pet = new Pet();
        Dog dog = (Dog)pet;
        
        
    instanceof 判断此类是否是这个父类
         判断 pet instanceof Dog;
            反看判断子类是否属于父类 //返回true和false




第四章：接口篇:


接口的能力：
    是类继承接口后 拥有了接口中的特权
    
接口的约定：
    是类接继承口后 必须实现接口所有行为

所有的接口的方法 都使用 public abstract 默认修饰

接口特性：
    接口不能被实例化  不能开辟空间
    实现类必须实现接口的所有方法  接口的方法必须被实现
    实现类可以实现多个接口  在类中            可以 implements 多个接口
    接口中的变量都是静态常量  宁缺毋滥
    
接口中定义
    接口中所有属性和方法默认都是public
    以 ";" 
    号结尾


接口的实际运用
    一个类似于抽象类的一个 绝对抽象 绝对实现
    接口可以被多个类继承

接口有什么好处
    默认public
    接口可以多继承
    接口一旦继承就必须实现

接口与接口之间的继承
    接口与接口直接通过extends实现继承
    如果被继承的子类接口 那么实现这个子类接口的同时也会继承父类接口 并且不会实习其中的方法
    只会以重新展示其中方法的方式
    
接口的最大好处就是实现方法吗？
    是的没错;
    因为接口之中 只有方法是被强制实现的
    而属性是 是一个静态常量修饰的并且在接口要被赋值 通过类名调用很鸡肋
    接口中没有构造方法

接口之间可以通过extends关键字实现继承关系
    一个类可以继承多个接口
    一个接口可以继承多个接口 
    但接口不能继承类

类一旦继承了接口 就必须实现其中的方法
    接口同时也能定义常量
    interface 修饰接口  相同与 类的定义
       
接口被类实现
    别类实现的时候使用implements实现
    并且实现多个接口时可以通过 "," 实现继承多个接口
    
接口与抽象类的好处
    可以让继承或者实现的类强制 实现其中内容
    接口优势在于实现方法
    
    
为什么需要接口
    类被继承：有局限性，一类只能继承一个接口，而其中被实现的方法不一定是强制要求的
    但是他实用在 属性,构造！！
    
    接口被继承：类可以继承很多接口可以让继承或者实现的类强制 实现其中内容
    但是他实用 仅限于方法！！！
    
    
接口的好处
    比如可飞行类型不同 
例： 飞机会飞 小鸟会飞 但是他们不属于一个类所以使用接口的形式
    可以使用 接口的的形式 把东西实现 飞机implements(实现) 飞的接口
    小鸟实现飞的接口  


把属性放到一个类中叫 实现类
把方法放到一个类中叫 接口类
把接口中方法实现类中 实现类
接口的主要目的是 实现方法
    
    
    






第五章：异常篇:
第一，它允许你修正错误。

第二，它防止程序自动终止。
    大多数用户对于在程序终止运行和在无论何时错误发生都会打印堆栈信息，
    结果肯定对用户体验不好（至少可以这么说）
    幸运的是，这很容易避免

---------------------------------------------------------------------------------------------

what 这是么什 
    用于获取到异常以自己的形式提示 自定义提示异常
why 为什么使用
    摆脱异常的锁定性  让报错的信息提示，并且一般无try-catch的时候 报错不会执行下面的代码直接中断
    使用try-catch的时候 即使报错 也会有一段特殊的代码显示的执行
where 在什么时候使用 
    一般出现报错信息时候使用
    同时减少了多重的if else 代码块
    用于知道这个代码块保存了，但是还想执行下一段代码时执行
 
 how? 如何使用
     在不明确自己写代码时是否会报错时使用

---------------------------------------------------------------------------------------------    
try 
    第一个被执行的代码块
catch
    遇到错误执行的代码块       
            catch的异常展示类型：
                  返回类型void printStackTrace() 输入异常的堆栈信息
                  输出异常的堆栈信息
                  返回类型String getMessage() 返回异常信息描述的字符串
                       常见异常 中：
                           NullPointerException  空指针异常
                           ClassNotFountException  不能加载所需的类  "找不到类"
                           ClassCastException      对象强制类型转换出错
                           NumberFormatException    数字格式转换异常，如把"ABC" 转正数字
                        
                                         
                                                          
                                                                                            
多重catch
    本身条件比较多 利用这个条件 把异常执行 的代码块
    多重catch块最重要的是 catch中的异常Exception只能写在最后一个catch块中
    例:
          catch(ClassNotFountException  e){
            
        } catch(ClassCastException  e){
            
        } catch(Exception e){
            
        }
    
    
finally
    必须执行的代码块 无论return



throw 的作用
    就是把不好或者不正确的条件 以异常的方式展示
    
    
throws 声明异常
    用于在形参列表后
    将可能发生的异常到下一个调用的方法中
    谁调用谁处理
    
    只用遇到throw抛出都是异常 
throw 抛出异常
   在当前代码位置
   手动触发异常 可自定义异常信息
   就是重写getMessage() 方法
    
    
---------------------------------------------------------------------------------------------    

异常
    RunTime异常
        在运行时可能发生的问题，可以声明或使用try-catch处理的异常
    Checked异常
        在运行时可能发生的问题，必须声明或使用try-catch处理的异常
    





第六章：集合篇：



List和Map是否都继承自Collection接口？？
    不是，
    List<接口>继承于Collection<接口>
    Map<接口> 与Collectio同级<接口>
    
<?>   代表泛型集合的通配符    
    
    
和数据采用相同存储结构的集合类型是什么？
    LinkedList<接口>
    他是采用了双向链表的形式
    在插入和删除的效率比较快 因为内部链条上有两块空间



Collection<接口>：可重复，无序
   List<接口>不能实例化 不能new空间
   如果想要使用List接口的方法可以使用 List li = new ArrayList();
   使用自己本类方法可以使用 LinkedList ll = new LinkedList();
   List<接口>：可重复，有序
        ArrayList(类) 
            查找遍历速度相对较快
            插入和删除的效力较慢
            1.ArrayList是实现了基于动态数组的数据结构
            2.对于随机访问get和set，ArrayList觉得优于LinkedList，
                
        LinkedList(类)
            插入和删除的效力较高
            查找遍历速度相对较低
            1.LinkedList基于双向链表的数据结构,因为LinkedList要移动指针
            2.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。 
    
            
    set<接口>： 唯一， 无序
    
    boolean add(object) : 在最后一个元素上追加内容
    int size()  : 返回列表中的元素个数
    object get(int index)： 返回指定索引的元素，取出的元素是object类型
    boolean contains(Object obj) ：判断集合中是否存在这个元素(推荐比较字符串)
    Object remove(int index)： 从集合中删除 指定下标的元素


    
    

Map<接口>
    HashMap<k,y> k无序 唯一，y无序 允许重复
        在HashMap中 键是唯一的值是不唯一的
        他其中有顺序 遵从 哈希表的顺序 
        在其中的顺序又叫  "字典顺序"
    
        没有插入方法 (因为他插入没有顺序)
        所以每回put()的时候只会在上一个元素后添加
        在key值相同时，会覆盖之前置
    HashTable和HashMap

共性：都实现了Map接口。

区别：

(1)继承的父类不同

Hashtable继承自Dictionary类，而HashMap继承自AbstractMap类。

(2)线程安全性不同

Hashtable的方法是Synchronize的，而HashMap中的方法在缺省情况下是非Synchronize的。

(3)提供contains方法

HashMap把Hashtable的contains方法去掉了，改成containsValue和containsKey，因为contains方法容易让人引起误解。

Hashtable则保留了contains，containsValue和containsKey三个方法，其中contains和containsValue功能相同。

(4)key和value是否允许null值

Hashtable中，key和value都不允许出现null值。HashMap中，null可以作为键，这样的键只有一个；可以有一个或多个键所对应的值为null。

(5)两个遍历方式的内部实现上不同

HashMap使用了 Iterator；Hashtable使用 Iterator，Enumeration两种方式 。

(6)hash值不同

哈希值的使用不同，HashTable直接使用对象的hashCode。而HashMap重新计算hash值。

(7)内部实现使用的数组初始化和扩容方式不同

HashTable在不指定容量的情况下的默认容量为11，增加的方式是 old*2+1；而HashMap为16，Hashtable不要求底层数组的容量一定要为2的整数次幂，而HashMap则要求一定为2的整数次幂。



给集合提供了专属的遍历方式，而且遍历效果比较高
iterator 遍历其中内容
    hasnext判读是否有内容
    从0开始读取第一个数据next读取下一行内容

不是泛型 是 没有指定数据类型需要装箱拆箱

泛型集合 是 指定数据类型  追加数据                        






第七章：线程篇：

说明进程和线程的区别
    进程是线程  父线程
         进程中包含线程
         没有线程






什么是类，什么是接口，分为哪三个点！ 区别



h