美文网首页JAVAJava后端开发
史上最精炼JAVA知识点基础总结

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

作者: 清枫_小天 | 来源:发表于2016-06-28 20:52 被阅读10934次

    licy@briup进可攻,退可守 (ThinkPad T460P)
    SSH 智联招 聘(android)Struts2 Spring Hiber
    笔试(计算机基础):面向对象,算法,数据库 sql
    面试:(逻辑思维) 项目经验
    人事面试
    Servlet/jsp ---Struts2
    JDBC ---Hibernate
    BeanFactory -----Spring (控制反转,面向切面编程,)

    java知识点:

    unix(window dos)

    1. Java开发环境搭建
    • JDK(无脑)
      配置环境变量
      JAVA_HOME(新建)
      C:\Program Files\Java\jdk1.7.0_67
      Path(追加)
      %JAVA_HOME%/bin;...
      CLASSPATH
      .;./bin

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

    • 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(线程安全,重量轻)

    相关文章

      网友评论

      本文标题:史上最精炼JAVA知识点基础总结

      本文链接:https://www.haomeiwen.com/subject/gcitjttx.html