java入门学习笔记

当前保持更新和修改，欢迎在评论区指正和添加重点 

• java的发展简史

   Java之父:詹姆斯高斯林  sun公司

   1991年  java问世

   2004年  jdk1.5更名jdk5.0

   2010年  sun公司被Oracle公司收购了

一、java中常见的几个名词
   JDK: java development kit            java开发工具
  JRE: java  runtime  environment    java运行环境
  JVM: java virtual machine              java  虚拟机
  GC： garbage connection             垃圾回收器
 

二、java的特点
   1、跨平台，移植性好（虚拟机）
   2、简单易学（面向对象）
   3、安全性较高
   4、可扩展性
   5、动态性等

三、标识符的命名规范
   1、只能由数字、字母、下划线及$符组成
   2、不能以数字开头
   3、不能是保留字关键字
   4、区分大小写
   5、支持中文，但不推荐 
     
    程序员之间墨守成规的编码规范
    1、见名知意
    2、遵循驼峰命名法（第一个单词首字母小写，后面每个单词首字母都大写：helloWorld）
    3、命名长度不宜过长，一般不超过三个单词
    
四、java中的注释
    1、 //表示单行注释
    2、/*内容*/多行注释
    3、/**内容*/文档注释

    
五、变量
   定义：可变得量 
   变量的声明 1、 int a ; a = 5;
                      2、 int a = 5;
                            必须初始化；
    同一个main方法中变量名不能重复
    
六、8种基本数据类型和引用数据类型(待完善)
 基本数据类型
    字节第一位为符号位  0代表正数、1代表负数
    一个字节  八位  取值范围为：-128~127 
    1、整型数据（整数类型默认为int型） 
    byte : 1字节   8位    取值范围：-128~127
    short：2字节   16位   取值范围：-2^15~2^15-1
    int  : 4字节   32位   取值范围：-2^31~2^31-1
    long : 8字节   64位   取值范围：-2^63~2^63-1
    备注：byte,short取值若超过自身范围会自动转成int型
             若表示long类型数据，要在数值后面加上l或L
          
    2、浮点型
    float: 4字节   32位  表示float类型需要在数值后面加上F或f
    double 8字节   64位
    默认类型为double类型
    
    3、字符型
    char:  2字节   16位
      3.1、没有符号位   取值范围：0~2^16-1
      3.2、java中字符表现形式为单引号‘内容’，且内容只能为单个字符，可以为中文。
      3.3、可以当整数来用（对照ASCII表 A:65 a:97）
      3.4、字符类型参与算数运算会自动转换为int类型
    4、布尔类型
    boolean 1字节 只有true,false

 

备注：byte/short/char/这三种类型在运算时，
         都会被首先提升为int型（就算两个是两个byte运算也是先被提升为in）然后再计算
    
  引用数据类型
  String类  为字符串类，在java中一切以双引号引起来的称为字符串。
    1.String  str = "123";
    2.String  st = new String("123");
    
    
七、基本数据类型之间的相互转换
   1、取值范围从小到大实现自动转换
    byte->short（char）->int->long->float->double 
             char->（参与算数运算自动转换成int类型）

●经典问题：short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 +=1;有什么错?
答：对于short s1=1;s1=s1+1来说，在s1+1运算时会自动提升表达式的类型为int，那么将int赋予给short类型的变量s1会出现类型  转换错误。对于short s1=1;s1+=1来说 +=是java语言规定的运算符，java编译器会对它进行特殊处理，因此可以正确编译。

   2、取值范围从大到小需要强制转换
       强制转换符：()
       整型强转可能会导致数据溢出，浮点型强转会导致精度丢失

八、java中的运算符
    算数运算符、关系运算符、条件运算符、逻辑运算符、按位运算符、赋值运算符    
    
    算术运算符： + - * / % ++ --
             +：既可以做加法操作，也可做拼接操作
                当+两边为数值类型的时候是加法操作，
                当有一边为字符串的时候做拼接操作（*拼接后自动转为字符串类型）
                （运算顺序从左到右）
             /: 取整操作  （表示浮点类型则需至少一个数为浮点型）
             %：取余操作
             ++:自增运算符 分前++与后++ 例：++i与i++；
                ++i:先自身加一再参与运算
                i++:先参与运算再自增
            --：自减运算符规则与自增类似
            扩展运算符：+= -= *= /= %=  用法以+=为例：i += 1; 等价于 i = i + 1;
                  
    关系运算符：>  <  >=  <= !=(不等于)  ==（恒等于 注： '=' 为赋值运算符） 
               == 比较的不是两边的值是否相等，而是比较两边数值存储在计算机内存的地址值是否相等
               当==两边为基本数据类型时可以当做值来比较，因为基本数据类型数据在计算机内存中具有数据共享性
               String s1 = "123";//直接让创建的对象先存储在字符串常量池中，然后赋值给引用是s1
               String s2 = "123";//先从字符串常量池遍历是否有"123"存在，有赋值给引用s4，没有则重新创建对象放入常量池
            
    条件运算符(三目运算符)：语法： 布尔表达式 ? 值1 ：值2； 
                            布尔表达式为ture运算结果为值1，反之为值2 例：3 > 4 ? 1 : 2; 结果为2    
     
    逻辑运算符：逻辑与 &&   逻辑或 ||   非 ！  
                逻辑与存在短路功能（只要有一个表达式为false,则后面的不参与运算）
                逻辑或存在短路功能（只要有一个表达式为true,则后面的不参与运算）
    
    按位运算符：按位与 &  按位或 |  
                作用：1、可以当做算数运算   算数运算：  5 & 2：   0101                 5 | 2：   0101                                         
                           2、关系运算 : 运算规则与逻辑运算一样         0010                               0010
                                没有短路功能！与逻辑运算不一样            ———                           ———
                                                                                                   0000   结果为：0            0111   结果为：7
                                                                 
    移位运算符：>>  <<  移位运算符操作的对象是二进制的位
                >>:左移运算符，将运算符左边的对象向左移动运算符右边指定位数（在低位补0）
                <<:右移运算符，将运算符左边的对象向右移动运算符右边指定位数,如果值为正，则在高位补0，负则补1

九、数据结构
    顺序结构  分支结构  循环结构

    顺序结构：按顺序一步一步执行称为顺序结构，如main（）方法

    分支结构：单分支 多分支    
              单分支：  if (布尔表达式){语句块};                  布尔表达式为真执行语句块假则不执行
                        if(布尔表达式){语句块一};else{语句块二};  布尔表达式为真执行语句块一假则执行语句块二
    
              多分支： if(布尔表达式){语句块1}; else if(布尔表达式){语句块2}; else {语句块3};
                       哪个布尔表达式为正则执行哪个语句块
                       
                       switch case语法：    switch(key) {
                                                    case k1:{语句块};
                                                       break;
                                                       ...
                                                  case k8: {语句块};
                                                        break;
                                                  default:{语句块}   
                                                        break；                                                  
                                                 }
                        备注：key的类型在JDK1.7之前只支持整数类型和枚举，JDK1.7之后还支持String类型
                        switch case 中break关键字在这里的作用是防止case 渗透如果没有case中没有break
                        程序会自动往下执行，知道跳出switch case
                        
                        default:当所有case 都不执行时执行default，default也可以省略;
                        
              循环结构：while  do while  for
              
                       while语法：
                       while(布尔表达式)  //布尔表达式为true时执行循环体内容，直到false时终止循环
                       {
                        循环体内容       //包含退出循环的条件
                       }
    
                       do while 语法：
                       do{
                         循环体内容
                       }while(布尔表达式);  //先执行后判断，布尔表达式为真继续执行，为假则跳出
                         注：与while的区别是至少执行一次
               
                      for(表达式一；表达式二；表达式三) //表达式一：声明初始化变量（只执行一次）
                      {                                 //表达式二：判断是否循环的条件
                         循环体内容                     //表达式三：控制循环次数条件
                      }
                      for循环特点：表达式一可以写在循环外：变量变成全局变量
                                   表达式一、二、三也可不写，但容易进入死循环
                                   
                                   
    随机数：Math    Random
                        
           Math:数学中的理论
           生成随机数的方法：Manh,random()；生成【0.0~1.0）的随机数（左闭右开）
           注意：默认double类型，得到int型需要强制转换。
           使用数据类型强制转换和数学操作可以得到我们想要的随机数区间（默认还是左闭右开）
                        
            Random :官方提供的类,要写包，使用必须“new”(Random randon) = new Random();)
            生成随机数的方法： 
            randon.nextInt();        //生成int取值范围内的任意一个整数(左闭右开)
            randon.nextInt(int i);   //生成0~i之间的任意一哥整数(左闭右开            )
                            
    循环中的两个关键字：  break   continue                
                      break:跳出循环的作用 
                                   
                      continue:跳过当次循环(如果执行到continue语句，则continue后面的语句不执行)，继续执行下一次循环
                                  
    循环的嵌套：    备注：在以后的循环嵌套使用时for() 循环尽量使用两层嵌套，其余尽量少使用或不用                           
                    for(表达式;表达式2;表达式3)
                        {
                          for(表达式4;表达式5;表达式6)
                          {
                          循环体内容;
                          }
                        }                    
                                   
                    总循环次数等于：外层循环次数 * 里层循环次数        

十、数组

    备注：数组也属于引用数据类型
    定义：将具有相同数据类型的数据集中在一个容器中，称为数组                    
    数组的声明：
        1、数据类型[] 数组名 = new 数据类型[数组的长度];
           例： int[] arr = new int[3];   //声明一个长度为3的int类型数组
        2、数据类型[] 数组名 = {};        //声明一个空数组           
           例：int[] arr = {1,2,3};
        3、数据类型[]  数组名 = new 数据类型[]{}; //中括号不能指定长度
            例： int[]  arr = new int[]{1,2};    
        
        []位置可以在数据类型后面，也可以在数组名后面 

    数组的操作：
        1、通过下标来操作数组，下标从0开始，arr[0]是数组的第一个元素；
        2、用length来获取数组的长度
     
    数组中的默认值：
    整型：0
    浮点类型：0.0
    字符类型：\u0000
    布尔类型：false
    String:   null
    
    数组中的注意事项：
    数组的长度大小一旦确定将不能发生改变，通过数组的扩容缩容可改变，但是地址会发生改变
    只是将新的地址值赋值给了原数组的引用。
    
    数组的扩容，缩容：
    Arrays.copyOf(arr,newlength) newlength为arr.length加减数字
    arr:你扩容或缩容的对应数组
    newlength：扩容或缩容后新数组的长度
    备注： newlength 往往我们以原数组为基准，扩容后就用arr.length +扩容长度（缩容同理）
     不管是扩容还是缩容都是对原数组的最后一个元素进行操作
    输出数组： System.out.println(Arrays.toString(arr));     
    
    数组的复制：
    System.arraycopy(src,srcIndex,des,desIndex,length)
    src:原数组
    srcIndex:从原数组的哪个位置开始复制
    des:目标数组
    desIndex：从目标数组哪个地方开始插入
    length：插入长度或复制元素的个数
    备注：复制时，复制的元素个数不能超过目标数组的长度
                                   
    掌握几种排序的算法
     冒泡排序法，选择排序法，插入排序法

十一、方法
      方法的定义：能够实现某种特定功能的代码块
      语法：权限修饰符  返回值类型 方法名（参数列表）{
             方法体                                       
      }
      权限修饰符：（前期）public static
      返回值类型：1.有返回值，返回值的相应类型
                  2.没有返回值-->void表示
      方法名：标识符，遵循驼峰命名法
      参数列表：由0到多个数据类型加变量组成，多个参数之间用逗号隔开
      方法体：实现具体业务逻辑代码
      例：public static int sum(int a,int b){
           int sum = a + b;
           return sum;
      }
       retur  关键字的作用  1.将方法中的运算结果返回给调用该方法的变量
                            2.结束方法的调用
      备注：方法里面不能嵌套方法！！不过可以调用。  
    
      方法的重载：overload
      方法名相同，参数个数不同或参数类型不同称为方法的重载(返回值不同没有用)

十二、面向对象   
 
      面向过程：凡事都得亲力亲为
      面向对象：不是所有的事情都自己做
      面向对象由类、引用、对象构成  面向对象就是针对类而言的
      类：描述事物的一个抽象概念
      引用：用来操作类创建的对象
      对象：类的实例化个体
      类  引用 = new 类();  Scanner类 Random类都是面向对象的思想

          
      成员变量：有默认值，与数据类型在数组中的默认值一样     
      成员变量：声明在类下面,方法外的变量   作用域：整个类
      局部变量：方法里面声明的变量     作用域：当前方法内
      区别：1、定义位置上的区别 
                 2、作用域的区别
                 3、默认值的不同
                 4、内存位置不同
                       成员变量，跟随对象进入堆内存存储
                       局部变量，跟随自己的方法，进入栈内存
                5、生命周期不同
                      成员变量，跟随对象，字堆中存储，内存等待JVM清理，生命相对较长
                      局部变量，跟随方法，方法出栈 生命相对较短
            
      ●构造函数
       无参构造函数   有参构造函数  (构造函数的重载)
       无参构造函数(默认)语法：
         public 类名(){
           语句块
         }
        有参构造函数语法：
        public 类名(参数列表){
            语句块
        }
        备注：和普通方法的区别？
              没有static没有返回值类型也没有void，且方法名必须与类名一致。
        构造函数的作用：方便成员变量进行初始化操作，
        备注：若没写构造函数，系统默认无参构造函数，若写了有参函数，系统将不再默认添加无参构造函数     
         
      ●气球理论
        如果多个引用同时指向同一个对象的时候，若其中一个引用对对象做了操作，那么其他引用也会随之发生变化  

    一、java中的继承
        类与类之间的继承  用关键字extends  例： public 继承类 extends 被继承类
        继承的特点：
        1、继承父类拥有的非私有的成员变量和成员方法
        2、子类可以拥有自己的成员变量和成员方法
        3、如果子类重写了父类的方法，则执行方法的时候，执行的是重写后的成员方法
        4、类与类之间只能单继承，子类只能一个父类，父类可以多个子类
        5、类可以多重继承
      
      继承的由来：将多个类中共同的内容放在一个类中，然后其他类则不必重复定义所需内容，简化程序
      继承的好处：1、让类与类之间产生了关联，为多态提供了前提条件
                  2、提高了代码的复用性
      继承的弊端：违背了软件工程的理念：低耦合，高内聚
      构造函数并不能被继承
      
    二、super关键字
        子类调用父类相关的构造函数，如果子类中不写super那么系统会默认添加super()该方法(不管有参还是无参)
        super()会会去找父类中的无参函数；
        super关键字在使用时必须在构造函数的首行，当与this()关键字冲突时可以不写super()关键字，系统会默认解决
        用this()调用自身构造函数时，会间接调用父类的构造方法
        
        this关键字
       this关键字代表本类对象的一个引用，谁调用this所在的方法，this就代表谁  
       this的使用场景
        A:用于区分同名成员变量和局部变量；
        B:在定义函数时，该函数内部要用到调用该函数的对象时，因为此时对象还没建立，故this代表此对象
        B:构造函数间调用
            **这个时候，this(参数)必须作为第一条语句存在。

        this和super之间的区别？
         调用本类和父类

    三、static关键字
        1、static修饰成员变量，将成员变量变为静态变量(类变量)，可以直接用类名.变量名访问.而成员变量必须通过创建对象用引用访问
        2、static修饰成员方法，此时成员方法称为静态方法(类方法)，可以直接使用类名.方法名（）访问，而成员方法必须通过创建对象的引用访问        
        备注：静态方法只能访问静态变量，不能访问成员变量 
        3、static修饰代码块 语法：  static{
                                            代码块  
                                              }
             备注：静态代码块，执行优先级最高，在类加载的时候就已经执行了且只执行一次，通常用来加载视频图片等
                   
                   构造代码块：只有在main方法中创建对象的时候才能被访问，且可以被访问多次，优先级小于main方法
                   语法：
                   {
                   代码块
                   }
            思考：静态方法能不能被继承？答：可以被继承，但不能被重写
                
      ●权限修饰符
        public      公共的
        protected   受保护的
        默认
        private     私有的
        作用域范围：
                     本类    子类       同一个包中的类      其他类（和前面几个类不在同一个包中）
        public       √        √                √              √
        protected    √        √                √              ×
        默认         √        ×                √              ×
        private      √        ×                ×              ×

    四、封装 （方法，类，包装属于封装的一种）
        java中的核心思想中封装
        封装的好处
        1、提高代码的复用性
        2、隐藏实现细节，对外提供访问的方式
        3、提高了安全性
    
    五、java中的计算机存储内存    
    栈：存放的是基本数据类型对象和引用数据类型的引用
    堆：一切new 出来的对象
    方法区：存储静态变量和静态方法以及class文件
        
           
    六、多态
         同一事物在不同情况下显示出的不同的状态    例如：水
         java中：同一个对象在不同的环境下显示出不同的身份、
         实现多态的前提条件：1、必须有继承
                             2、有方法的重写
                             3、必须是父类的引用指向子类的对象
     
       多态的特点：                     
                  多态在执行的时候分为两个时期
                编译期   运行期
                父类 引用 = 子类对象;
        成员变量：编译期看类型，运行期看也看类型
        成员方法：编译期看类型，运行期看对象
        多态的局限性：只能够访问父类成员变量和成员方法，不能访问子类自身里面的成员变量和成员方法
        
        /*
        父类 Father  子类 Son
        //向上造型
        Father father = new Son();  //father引用  new了Son对象
        //向下造型
        Son son = (Son) father;    //将father强转为Son类型
        
        //备注:向下造型的时候需要注意转换的类型是否是需要的类型，可能会导致类型转换异常
        //可以通过instanceof关键字来避免类型转换异常
        //boolean b = 对象 instanceof 数据类型；
        */
        
    七、final关键字
       1、final修饰成员变量时，此时变量变为常量
       2、final修饰成员方法时，该方法不能被重写
       3、final修饰类时，该类不能被继承
        
    八、抽象类抽象方法
        关键字：abstract    
        在一个父类中，封装了子类都共同有的方法，但是方法体内容无意义，因为子类都会去重写父类中的方法，
        此时不写方法体，能够简化我们的代码，这里不写方法体的方法称为抽象方法，有抽象方法的类我们称为抽象类。
        
        抽象方法的语法： 权限修饰符 abstract void 方法名();  //么得方法主体
        
        抽象类的特点：
                    1、抽象类不能创建对象（不能new）
                    2、有抽象方法的类一定是抽象类
                    3、抽象类中可以没有抽象方法
                    4、子类继承抽象类，如果有抽象方法一定要实现(重写)全部抽象方法，
                       如果子类也是抽象类，可以不重写父类的抽象方法
        
        abstract和哪些关键字不能共存：
        final: final修饰的方法不能重写
        static：static修饰的方法可以直接通过类名访问，而抽象方法没有方法体，调用无意义
        private:private修饰的变量只能自己本类访问 ，但抽象类不能创建对象
        
    九、接口
          关键字：interface
          类语法： public interface 类名
          接口是一个特殊的抽象类。
      特殊性：1、接口中没有变量，有的只是常量                 (默认修饰符 public final)
              2、接口中的所有方法都是抽象方法，不能有成员方法 (默认修饰符 public abstract)
              3、接口没有构造函数
              4、接口不能创建对象
              5、接口可以多实现和多继承    //继承和实现多个类的时候用逗号隔开
              
        接口实现语法
        用关键字implements    public class 类名 implements 接口类名
              
         接口的特点：
        A:是对外暴露的规则
        B:是功能的扩展
        C:接口的出现降低耦合性。
            耦合(类与类之间的关系)
            内聚(类完成功能的能力)
            编程规范：低耦合，高内聚。
        D:接口可以多实现。如：CPU和主板、笔记本的USB插口、插座
        
        接口和抽象类的区别：
        A：抽象类只能被单继承
           接口可以多实现,接口的出现避免了多继承的局限性。
        B：抽象类中的数据特点：
                成员变量：可以是变量，也可以是常量
                成员方法：可以是抽象方法，也可以是非抽象方法
                构造方法：有构造方法
           接口中的数据特点：
                成员变量：是常量。默认修饰 public static final
                成员方法：都是抽象方法。都有默认修饰 public abstract
                构造方法：没有构造方法
        C：抽象类中定义的是继承体系中的共性功能。
           接口中定义的是继承体系中的扩展功能。
        D：抽象类被继承是"is a"关系:xx是yy的一种
           接口被实现是"like a"关系:xx像yy的一种
                                   
    十、单例模式(singleton)
         什么是单例模式？  一个类只能有一个对象
         如何使一个类只能拥有一个对象？
         用private修饰符修饰构造函数即可
         { 
           //保存本类的唯一实例
           private static 类名 引用 = null;
           //构造函数私有化
           //获取类的唯一实例的方法
          public static 数据类型(此处返回类的对象，所以类型为本类)  方法名(){

          }
         }
         
         java中单例模式有三种
         1、懒汉式 需要用到的时候才创建对象
         2、饿汉式 当类加载的时候，就创建对象
         3、登记式（不常用）
         
    十一、Object
        如果一个类没有去继承某个类的时候，默认继承Object类    
        Object类中的几个常用方法
        1、toString(); 返回该对象的字符串表示方式
        2、hashCode(); 返回该对象的哈希码值
        3、equals();指示其他对象是否与此对象："相等"。
        如果要比较两个对象是否相等，先需要重写hashCode()方法，然后再去重写equals()方法
        才能保证对象相等。
        为什么重写equals()方法必须要重写hashCode()方法？
        保证地址值相等！
        
    十二、内部类
          匿名内部类
          为什么要有匿名内部类？
          如果在一段程序中需要创建一个类的对象（通常这个类需要实现某个接口或
          者继承某个类），而且对象创建后，这个类的价值也就不存在了，
          这个类可以不必命名，称之为匿名内部类。
   
          实现匿名内部类的前提条件: 通常这个类需要实现某个接口或者继承某个类

         格式：
            new 父类名或者接口名()
            {
                重写父类方法或者实现接口中的方法。
                也可以自定义其他方法。
            };

          什么时候定义匿名内部类？
          匿名内部类只是为了简化书写，匿名内部类有局限，
          通常定义匿名内部类时，该类方法不超过3个
           匿名内部类的好处和弊端：
            好处：简化代码书写
            弊端：
                不能直接调用自己的特有方法
                不能执行强转换动作
                如果该类里面方法较多，不允许使用匿名内部类