史上最精炼Java基础知识点总结

java知识点：

unix(window dos)

1. Java开发环境搭建

   • JDK（无脑）
     配置环境变量

            JAVA_HOME(新建)  
                C:\Program Files\Java\jdk1.7.0_67  
            Path(追加)  
                %JAVA_HOME%/bin;...  
            CLASSPATH  
                .;./bin

     本地类加载-->系统类加载----->扩展类加载

2. HelloWorld编写运行

   1. 顶级三要素

           package   
           import  
               不需要导包情况    
               1)需要的类和当前类在同一个包下  
               2)需要的类位于java.lang下  
           class

   2. 编译

           I:\ssh\day01    
           javac -d ./bin src/HelloWorld.java    
               -d 目录  将编译好的字节码文件放到指定目录

   3. 运行

           I:\ssh\day01  
           java [参数] 完整类名（包名+类名）  
               -classpath 路径  
               -cp 路径  
               指定类加载路径（CLASSPATH）  
           java -cp ./bin com.briup.day01.HelloWorld

   4. 打包

           I:\ssh\day01\bin
           jar

   5. 部署运行

           hello.jar
      
           java -cp hello.jar com.briup.day01.HelloWorld

   6. 扩展类加载库

           C:\Program Files\Java\jdk1.7.0_67\jre\lib\ext
           java com.briup.day01.HelloWorld

Java中重要的包

1. java.lang

                String
                Math
                包装器数据类型
                异常  
        java.util  
                集合
                Date  
        java.io      
                字节流
                字符流  
        java.net

简单梳理

• 数据类型

  1. 基本数据类型

      无符号整数
      char    2字节    16位
          0~2^15-1    
      有符号整数
      byte    1字节    8位
          -2^7~2^7-1
      short    2字节    16位
          -2^15~2^15-1
      int        4字节    32位
          -2^31~2^31-1
      long    8字节    64位
          -2^63~2^63-1
      有符号小数
       float    4字节
          8位有效整数
      double    8字节
          15位有效整数
     
      布尔类型
      boolean
          true/false

  2. 引用数据类型
     类类型

     包装器数据类型

      1.  扩展基本数据类型的功能
          int a = 3;
          Integer b = new Integer(3);
          Integer c = 3;
      2. 用于将字符串转换为基本数据类型
          String str = "123";
          int a = Integer.parseInt(str);
          long b = Long.parseLong(str);
          Double d = Double.parseDouble(str);
      3. 可以赋空值  
          int age = null;

     char Character
     byte Byte
     short Short
     int Integer
     long Long
     float Float
     double Double
     boolean Boolean

• 操作符

  1. 算数操作
     • • • / %
           += -= *= /= %=
  2. 逻辑运算符(短路运算符)
     exp1 || exp2
     || 当第一个表达式为真，整个表达式即为真
     && 当第一个表达式为假，整个表达式即为假
  3. 位运算符（后期）
     原码 反码 补码
     ^ | &

  4. 三目运算符
     exp1? exp2:exp3
     当exp1为真执行exp2,否则执行exp3

          if(exp1){
          exp2
      }else{
          exp3
      }
      int age = 14;
      String flag  = age>18?"成年人":"未成年人";

• 语句

  1. 分支语句

      switch(变量){
      case 常量1: {
              //
          break;
      }
      case 常量2: 
          //
      break;
      }

     变量

      1.6以及以下 ：byte short char int
      1.7以及以上 ：String enum(枚举)

  2. 循环语句
     三要素

      初始化条件
      结束条件
      迭代条件

     for(初始化;结束条件;迭代条件){

      //循环体

     }

     初始化
     while(结束条件){

      //循环体
      迭代条件

     }

     初始化
     do{

      //循环体
      迭代条件

     }while(结束条件)

面向对象

三大基本特性

封装

        属性的隐藏  
        实现细节的隐藏  
        原则：当相同功能的代码出现两次以及以上，就要提取封装  

        public class Student{
            private Long id;
            private String name;
            private Integer age;

            public void setId(Long id){
                this.id = id;
            }
            public Long getId(){
                return this.id;
            }
        }

        public class Paixu{
            public void maopao(){

            }
            public void charu(){

            }
        }

#继承

        子类继承父类

        public class Parent{
            private Long id;

            public Parent(long id){
                this.id = id;
            }
        }
        Parent p = new Parent();


        Public class Son extends Parent{

        }

Son son = new Son();（试回答该语句执行了几个构造方法）
当创建子类对象的时候要调用子类构造函数，在子类构造函数的第一行中会默认调用父类的无参构造函数，当父类中没有无参构造函数，子类必须显示调用父类的有参构造函数。

this
指向当前对象 this.id = id;
调用当前类中其他构造函数 this()
super
指向当前对象的父对象
调用当前类的父类的构造函数

多态

父类类型的引用指向子类对象，通过该引用只能调用父类中有的方法，而不能调用子类中特有的方法；如果子类重写了父类的方法，通过该引用调用父子类的共有的方法时体现子类的特点

• 重写：发生在父子类中，子类中的方法与父类中的方法方法名相同，参数相同，返回值也相同。方法修饰符不能被缩小，异常不能被放大。
• 重载：发生在同一个类中，两个方法名相同，参数不同（参数，个数，顺序），返回值类型可以相同也可以不同。方法修饰符不能被缩小，异常不能被放大。

高级部分

访问修饰符

                本类       同包     父子类   其他
    public        ok        ok        ok        ok
    protected    ok        ok        ok
    默认          ok        ok
    private        ok

特殊修饰符

static 静态：

• 方法：

            可以直接通过类名调用，静态方法中不能调用非静态方法，静态方法在类加载时初始化

• 属性：

            可以直接通过类名调用，静态属性在类加载时初始化  
  
            byte    0
            char    空格
            short    0
            int        0
            long    0L
            float    0.0F
            double    0.0D
            boolean    false
            引用    null

• 代码块：

            static{
            }
            类加载执行

• 内部类：(后期)

            public class Outer{
                public static class Inner{
  
                }
            }

  final

• final类 不能继承

• final属性

            只能初始化一次
            在使用这个final属性之前要先自定义初始化

  1. 非静态属性

      public final int age;
                  1)直接赋值
                  2)构造函数中初始化

  2. 静态属性

      public static final int age;
                  1)直接赋值
                  2)静态代码块中初始化

• final方法

            不能被重写

• final变量

            只能赋值一次
  
            全局变量  -- 属性
  
            局部变量
                final int a;
                a = 3;
                a = 5;
                syso(a);

  abstract

• 抽象类

            不能实例化
            当一个类中有抽象方法，这个类一定为抽象类，抽象类中不一定有抽象方法
  
            存在的意义是为子类提供标准和服务
  
            子类继承抽象父类，如果父类中有未实现的方法子类要么实现，要么自身也为抽象类。

• 抽象方法

            没有方法体

Interface 接口

        只允许存在
            公共的抽象方法
                public abstract
            公共的静态常量
                public static final

            add();

        抽象到极致的抽象类

数组

• 存放相同数据类型的集合，可以存放基本数据类型也可以存放引用数据类型
• 数组长度一旦指定不能修改

• 数组元素通过下标来访问，下标范围0~length-1，如果超过范围会报错 ArrayIndexOutOfBounds

    数据类型[] 变量名 ;
    变量名 = 初始化;
  
    初始化
        1)系统初始化
            int[] arr = new int[4];
        2) 自定义初始化
            float[] arr = new float[]{1,2,3.0};
            String arr = {"","",""};

集合

• 可以存放任意引用数据类型的集合

• 集合的长度可以自动扩展

    Collection
    （add remove clear isEmpty 【iterator】）
        List
            有序可以重复
            ArrayList    轻量级，线程不安全
            Vector        重量级，线程安全的
            LinkedList    双向链表
        Set
            无序不可以重复
            HashSet
                无序，哈希算法
            TreeSet
                可以排序，红黑树算法
    Map
    （keySet(),values(),entrySet()）
        键值对
        HashMap（线程不安全）
        TreeMap
        HashTable(线程安全，重量轻)