史上最精炼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(线程安全，重量轻)