史上最精炼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字节    160~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开发代码性能优化总结
下一篇java集合类(Map)
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭