javaSE学习笔记

javaSE学习笔记知识总结：包含：面向对象，类中是默认有构造器的：，如果没有定义带有参数的构造器，那么存在不带参数的默认构造器；，如果定义了带有参数的构造器，那么默认的构造器就会被覆盖，在定义了参数的基础上要使用无参数的构造器必须显式的将无参构造器定义出来等等

Java SE学习笔记

• 第五章：面向对象
  • 构造器
    • 作用：创建对象，给对象赋值
    • 构造器本身是一个方法（又称为构造方法）
    • 构造器没有返回值，也不用写void
    • 构造器的方法名必须和类名一致
    • 类中是默认有构造器的：
      • 如果没有定义带有参数的构造器，那么存在不带参数的默认构造器；
      • 如果定义了带有参数的构造器，那么默认的构造器就会被覆盖
      • 在定义了参数的基础上要使用无参数的构造器必须显式的将无参构造器定义出来
      • 默认构造器的类型是protect
    • 构造器的语法：
      • private/public/protect + 类名 +（参数类型 + 参数名）
  • this关键字
    • this关键字和构造器放在一起使用，谁调用构造器this指的就是谁。
    • 在重载构造器的相互调用时，this关键字必须是构造器的第一条语句
  • static关键字
    • static关键字修饰属性
      • 语法： static + 数据类型+数据名
      • 使用static修饰的属性认为是类属性；不使用static关键字修饰的属性认为是对象属性
        • 类属性的生命周期：一直存在，除非虚拟机关闭
        • 对象属性的生命周期：主函数的结尾也即是对象属性生命的结尾
      • 访问方式：
        • 类名.类属性（推荐）
        • 对象实例.类属性（不推荐）
    • static关键字修饰方法
      • 语法：public static void[返回值类型] 方法名（参数类型 参数名）｛｝
        • void表示无返回值
        • 返回值类型可以是基本数据类型，也可以是引用数据类型
      • 使用static修饰的方法认为是类方法；不使用static修饰的方法认为是对象方法
      • 调用方式（访问方式）
        • 类名.类方法（推荐）
        • 对象实例.类方法（不推荐）
      • 注意：
        • 类方法只能使用类属性
        • 类方法无论是类访问还是对象访问都不能直接访问对象属性
          • 因为类方法是静态的，对象属性是非静态的。不能从静态上下文中访问非静态变量
        • 对象属性和方法只能通过 ;对象实例.对象属性、对象方法 ;来访问
        • 类方法和类属性即可以通过 ;类名.类属/类方法 ;来访问，也可以通过 ;对象实例.类方法、类属性 ;来访问
        • 静态方法中不可以使用this关键字
        • font color= ;#c41230 ;>不能将方法体内的局部变量声明为
• 第六章：类的继承
  • 单例模式懒汉模式
    • 创建步骤：
      • 将默认的构造器私有化
        • 也就是权限修饰符为private
      • 在单例类的内部创建一个自己本身的对象
        • 创建的对象是静态的，否则不能咋静态方法中调用非静态对象
        • 权限修饰符为private
      • 创建静态方法获得对象
        • 权限修饰符：public
          • 因为这是其他类唯一可以访问的方法
    • 在类一创建完成只有，在类二中通过”引用数据类型 对象名 =类名.类方法 ”进行创建对象调用，无论创建多少个对象，返回值都是类一自己本身创建的对象
  • 饿汉模式
    • 和懒汉模式的区别
      • 懒汉模式是直接初始化
      • 饿汉模式只是创建了对象而没有初始化，只有在用的时候才初始化对象。
  • 继承
    • 使用情况：如果几个类有相同的方法和属性那么就可以使用继承来设计
      • 子主题
    • 继承关键字：extends
    • 语法：class 子类名 extends 父类名{< 子类独有的属性< 子类独有的方法 }
    • 特点：
      • 继承后子类会获得父类的所有的属性和方法（暂时不final）
      • 父类更通用，自雷更具体；
      • 子类不能继承父类权限修饰符为privte的属性或方法
        • private:只能在本类中被访问
        • 如果想要继承就得提供公共的set()和get()方法
      • java只能单继承。
        • 单继承就是A只能继承B，不能季继承B又继承C
      • java可以多级继承
        • 多级继承是指B继承了A，C也继承了A。
  • super关键字
    • 在子类中隐藏的调用了super super();
      • super表示调用了父类的构造方法
      • 子类实例化的过程中父类的构造方法先于子类的构造方法被调用
        • 所谓子类实例化就是创建子类并继承父类
      • 子类被调用的时候父类的默认构造器就会被调用(父类如果存在有参数的构造器，一定要把默认的无参构造器显示的表示出来)
      • 子类在调用父类的有参构造器时使用“super(参数列表)”，这时父类的默认构造器就不会被调用了
    • super的调用必须放在方法的第一行
    • super的其他用法
      • super可以表示父类的引用
        • 可以使用super和this关键字来区分子类和父类同名的属性
        • 在子类中访问属性和方法的顺序是先在子类中查找，子类中没有的话再去父类中查找。所以当子类和父类有相同名字的方法时访问的是子类的方法（如果在这种情况下要调用父类的方法时可以super关键字来实现。）
    • super关键字和this关键字的关系
      • super关键字表示对父类的调用
      • this关键字表示谁调用我，我指的就是谁
    • this关键字
      • 代表当前类的指定实例的引用
      • 可以区分同名的属性和局部变量
        • 子主题
      • 通过this可以调用同类中的构造器(this(),this(参数列表))
      • 调用本类里面的属性： this.属性名；this.方法名();
  • 方法的重写
    • 概念：在子类继承父类时，子类的方法和父类的方法相同（相同指的是权限修饰符、返回值类型、方法名、参数列表都相同。方法帖可以不一样），子类的方法就会在将父类的方法覆盖。<b>这种方式叫做重写<
    • 重写和重载的区别
      • 重写：在父类和子类有相同的方法，唯一不同的就是方法体。一般是因为父类的方法体满足不了需求才发生重写。
      • 重载：重载是在同一个类中，有着相同的方法名但参数的数据类型或参数个数不同的两个或几个方法就是重载。 重载的目的：节省类中的命名资源和提高方法的可读性。
  • final关键字：
    • 修饰在方法上
      • final修饰的方法不能被复写
      • 语法： 权限修饰符 final 返回值类型 方法名 （参数列表）{方法体}；
    • 修饰在属性上
      • 语法：权限修饰符 【static】 final 数据类型 属性名 = 值 ；
        • 属性名一般采用大写，多个词采用下划线来分隔。
        • 这种常量大多定义在接口中。
    • 修饰在类上
      • 语法： final class 类名{< 属性< 方法}
      • 使用final修饰的方法是不能被继承的。
  • 抽象类
    • 概念：
      • 当多个具体的实体类存在着共同的行为，但是有不同的表现，我们在父类继承过程中父类的方法具体实现不能确定，但是能确定的是他们都有这种行为。将这种行为方法叫做抽象方法。
    • 语法：
      • 抽象方法语法：public abstract [返回值][void] 方法名 (参数列表)；
      • i>抽象方法没有方法体</i><
      • 如果一个类中存在一个抽象方法，那么这个类一定是抽象类。这个类以一定要有abstract关键字
        • 抽象类语法： abstract class 类名{< 属性< 方法 }
        • 注：<i><b>抽象类可以没有抽象方法，但是有抽象方法的的类一定是抽象类。< </i>
    • 特点
      • 抽象类不能被实例化
      • 抽象类必须被子类继承才能使用子类实例化
      • 继承类抽象类的非抽象类必须实现抽象类的所有抽象方法。
      • 抽象类也可以继承抽象类，这样不需要实现父抽象类的方法。
      • 抽象类的抽象方法不能和private、final、static共存。
• 第七章 ：接口和多态
  • 接口
    • 定义
      • 定义：如果一个抽象类中所有的方法的都是抽象的，那么就可以定义为一个接口。
      • 语法：interface 接口名{< 方法的定义< ..... }
      • 接口与抽象类的差别
        • <b>接口是对行为的抽象，类是对属性和行为的抽象<
    • 在接口里定义方法
      • 在接口里，每一个方法都是抽象的，因此可以省略abstract.
      • 实现接口的类必须要实现接口里的每一个方法。
        • 我的理解：接口就是全是抽象方法的抽象类。要使用接口的话，就得把所有的抽象方法覆盖了才能使用。
        • 语法：
          • class 类名 implements 接口名1、接口名2....{< 接口里所有的方法 }
    • 在接口里定义属性
      • 在接口里定义的量都是常量。
      • 在接口中可以定义属性，接口里的属性不能修改，接口中的属性默认是final ,static的。
      • 访问方式：
        • i>通过接口名来访问（推荐）</i><
        • 通过接口的实现类的实例来访问
      • 常量的命名规则
        • 单词大写，多个单词之间用下划线来分开。例如FINAL_PATH
    • 接口可以继承接口（多继承）
      • jdk1.7可以实现接口的多继承、多实现和多级继承
      • jdk1.6及其以下版本不能实现多继承
    • 使用接口的好处
      • 接口定义的是一种标准，可以使我们的代码分层开发，分模块开发
      • 接口降低了代码的耦合度，提高了代码的可扩展性和可维护性。
      • 接口改进了单继承的局限。
    • 接口和抽象类的区别
      • 接口里面所有的方法都是抽象的，抽象类里面的方法可能是抽象的，也可能是非抽象的。
      • 接口和抽象类都不能实例化，接口需要类来实现后实例化实现类，抽象类需要类来继承后实例化继承类。
      • 抽象类只能单继承；接口继承接口可以多继承、也可以单继承。接口还可以多实现(白话就是继承类继承接口可以继承多个接口)
      • <b>接口中的属性是final、static类型的，抽象类中的属性和普通类属性没有区别<
      • i>接口中的方法默认就是抽象的，不需要加abstract; 抽象类中的抽象方法要加abstract关键字。</i><
    • 注：接口是不能被实例化的。
      • 可以通过实现接口的类实例化接口
      • 语法：接口名 对象名 = new 实现接口的类名
  • 多态
    • 定义：
      • 行为具有多种表现功能的能力称为多态
    • 继承多态
      • 通常使用抽象类来抽象要使用多态的方法。
      • 特点
        • 必须要有继承关系，在抽象类中可以定义多态的抽象方法，通过子类来继承这个抽象类然后复写抽象类中的抽象方法以达到多态的效果。
        • <h3> i><font color= ;#c41230 ;>多态子类的实例可以赋给父类的引用。</font></i>< </h3>
        • 子类中的特有方法不能通过父类来调用。
        • instanceof可以判断多态引用的变量到底是什么类型。
    • 接口多态
      • 接口多态基本上和类的继承多态一致：不同的类的继承使用的是继承关系实现多态，接口采用实现的方式实现多态。
    • 模板方法（23种的一个）
      • 抽象模板
        • 必须要实现的一个业务方法
        • 定义一个可以重写也可以不重写的方法
        • 必须不能被重写的方法
        • 模板方法：供其他类来使用的方法
      • 具体模板
        • 具体的模板：实现具体的业务逻辑
          • 具体逻辑
          • 方法重写
      • 主程序所在类
        • 创建具体模板对象
    • API的使用
      • 解释一： API是我们写代码的帮助文档
      • 解释二： ;API（Application Programming Interface, <a target= ;_blank ;>应用程序</a> ;编程接口）是一些预先定义的 <a target= ;_blank ;>函数</a> ;，目的是提供 <a target= ;_blank ;>应用程序</a> ;与开发人员基于某 <a target= ;_blank ;>软件</a> ;或硬件得以访问一组 <a target= ;_blank ;>例程</a> ;的能力，而又无需访问源码，或理解内部工作 <a target= ;_blank ;>机制</a> ;的细节。
      • math类的使用
        • java.lang.*下的类都不需要引入，都是自动引入的。
    • 包
      • 就是文件夹
      • 作用：对类做分类管理，可以区分同名不同包的类。
      • 语法：package 包名（不同级别以.来分隔，位置放在有效代码的第一行）
      • 如何编译：javac -d .类文件
      • 包的使用
        • 同一个包下的两个类可以直接的访问。
        • 不同包的使用
          • 类的权限修饰符为public时才能被外部的包引用。
          • 方式1：访问不同包的类在类的前面加上包的全路径。这种情况下必须先编译被引用的包。
          • 方式2：在使用某个包下的类时需要引入。
            • 语法：import 包名.类名。
            • 这行代码放在package的下面，class的上面。
    • scanner扫描器
      • nextInt( )方法：将输入的下一个信息扫描为一个int
      • scanner是一个类，先实例化一个对象，再调用int 变量名=nextInt( )的方法扫描自己输入的信息。
• 第八章：内部类和Object
  • 内部类
    • 概念：
      • 把一个类定义到另一个类中，那个内部的类就是内部类。
      • ;内部类就是类里面的类。
    • 访问内部类
      • 内部类不能够直接访问
      • 访问内部类的语法：
        • 外部类.内部类 变量名 = new 外部类对象.new 内部类对象
      • 内部类的方法如果想要访问内部类的方法，必须要创建内部类的对象，根据对象来访问
    • 私有内部类
      • 内部的类可以是private,即定义了为私有内部类
        • 外部的类的权限修饰符只能是public或者默认(什么都不加)
      • 私有内部类只能在外部类里面被访问。可以通过外部类的公共方法实例化内部类再被其他类调用访问内部类。（和封装有点像，只不过这里封装的是一个内部类）
    • 静态内部类
      • 静态类可以加static关键字，定义了为静态内部类
      • 静态内部类的创建语法：
        • 外部类名.内部类名 对象名 = 外部类名.内部对象
      • j静态内部类只能访问它的外部类的静态属性
    • 局部内部类
      • 方法中定义的类叫局部内部类。
    • 匿名内部类
      • 方法中定义的匿名类叫做匿名内部类
  • 匿名类
    • 匿名类就是没有名字的类
    • 借助接口来创建匿名类。
      • 创建了一个没有名字但是实现了接口的类的对象。
      • 语法1：new 接口名（）{< 接口里的方法的覆盖 }；
        • 引用语法：.方法名（参数类型 参数名）；
      • 语法2：接口名 对象 = new 接口构造方法
        • 引用语法：对象.方法名（参数类型 参数名）；
      • 注意：匿名类最后的分号一定要加。
    • 匿名类是一次行的，用完就会被垃圾回收器回收。
    • 匿名对象：
      • 通过类可以实例化一个没有名字的对象，这个对象就叫做匿名对象。
      • 匿名对象很快就会被垃圾回收器回收。也是一次性的。
      • 语法： new 构造方法；
      • 也可以这么引用方法：new 构造方法.普通方法名（）；
  • 权限修饰符详解
    • 四种权限修饰符的可用性
      • 子主题（ ）
        • private
          • 默认的
            • protected
              • public
      • 类（外部类）
        • Ｎ　　　
          • Ｙ　　　
            • Ｎ　　　
              • Ｙ　
      • 　方法　　　
        • Ｙ　　
          • 　Ｙ　　　
            • Ｙ　　　
              • Ｙ　
      • 属性　　　　
        • Ｙ　　　
          • Ｙ　　　
            • Ｙ　　　
              • Ｙ
    • 四种权限修饰符的一般作用范围
      • 类的权限修饰符一般都是public
      • 方法绝大多数都是public
      • 属性绝大多数都是private
  • object类
    • object类是类层次结构的根类，每个类都使用object类。object类作为超类，每个类都继承它的方法。
    • 直接打印对象时是默认的在调用父类继承下来的toString
    • 判断对象相等时不能用“==”号，因为“==”是在判断地址是否相等，而地址是永远不会相等的。
• 第九章 ;Eclipse的使用和异常
  • 快捷键的使用
    • 标出输出：输入syso然后按下alt+/
    • 主函数：输入main然后按下alt+/
    • 常用快捷键
      • 自动补全：alt+/
      • 单行注释：ctrl+/
      • 多行注释封装：Ctrl+shift+/
      • 取消多行注释：Ctrl+shift+\
      • 对代码进行格式化：Ctrl+shift+f
      • 向上移动选中行：alt+↑
      • 向上下移动选中行：alt+↓
      • 对使用了其他包中的类或接口进行自动导入，也可以消除没用的包：Ctrl+shift+o
      • 删除选中行：ctrl+d
      • 将选中部分的字母大写：ctrl+shift+x
      • 将选中部分的字母小写:ctrl+shift+y
      • 获得建议处理方式：ctrl+1
  • 错误和异常
    • 错误都是以error结尾的
    • 异常都是以Exception结尾的
      • 编译期异常
        • 编译期异常必须处理，不处理就无法编译通过。
      • 运行时异常
        • 编译期没有异常，但是运行的时候出现了异常。
          • 如果发生了运行时异常，异常点之后的代码就不会执行。
    • 运行时异常的处理
      • 第一种方法：自行解决
        • 语法： try{< 可能发生异常的代码 }catch(异常类型 变量名){< 处理异常的代码 }
        • 如果不发生异常就不会产生异常对象（就是变量名代表的对象）也不会进入catch
        • 如果发生了异常，这个异常会进入catch中，走catch中的代码。
        • 如果异常通过catch得到了处理，那么catch模块后面的代码可以正常执行。
      • 第二种方法：向上层抛出（调用者）
        • try{ }catch( ){ }的快捷键：ctrl+shift+z
        • try catch语句可以有多个catch,分别处理不同的异常情况。
        • 自动上抛的
      • try{ }catch( )finally{ }语句
        • 在此语句中可以有多个catch
        • finally{ }一定会被执行而不管有没有异常
        • 如果catch{ } try{ }里面有return返回值被执行，那么finally{ }里是无法更改返回值的，除非finally { }里面也有一个return返回值。。
          • catch里的return执行后会等待finally{ }语句执行
        • 执行顺序shift最后执行finally{ }
        • return后面的句子不被执行
    • 编译期异常的处理
      • 第一种方法：自行解决
      • 第二种方法：向上层抛出（调用者）
        • 向上抛关键字：throws
    • 编译期异常自行处理 运行时异常上抛
    • 自定义异常
      • 自定义的异常都是运行时异常
      • 步骤
        • 创建一个异常类继承RuntimeException
        • 继承RuntimeException的构造器
• 第十章
  • 字符串概述
    • 数据类型
      • 基本数据类型
        • 数值型
          • 整形
            • byte、short、int、long
          • 浮点型
            • float、double
        • 字符型
          • char
        • 布尔型
          • boolean
      • 引用数据类型
        • 类（class）
        • 接口(interface)
        • 数组( [ ] )
• 第十一章
• 第十二章集合上
  • 集合的体系结构：
    • Collection
      • List
        • ArrayList
        • Vector
      • Set
        • HashSet
        • TreeSet
  • 集合也叫容器，用于存储对象
  • 集合中可以存储任何数据类型，但是在实际开发中一般只存储一种数据类型
    • <font color= ;#c41230 ;> i><u>通过泛型来指定这种数据类型</u></i>< </font>
• 第十三章
• 第十四章：Map集合和文件
  • Map的介绍和添加
    • Map概述
      • Map集合和Collection集合的区别
        • Map集合shift键值对的集合，Collection集合是单一出现的数据的集合
        • Map的键是唯一的，而Collection的子接口List集合中的元素是可以重复的，set是唯一的。
        • Map是夫妻对、Collection是光棍。
      • Map的特点
        • 数据成对出现
        • 数据的键是唯一的
        • 一个键只能对应一个值
        • 键可以重复
        • 键可以有一个为空、值可以有多个为空
  • Map的常用功能
• 第十五章：IO流和字符流
  • IO流介绍
    • 概述：
      • IO(Input、Output),输入和输出
    • 分类
      • 从输入和输出角度分类
        • 输入流
        • 输出流
      • 从数据角度分类
        • 字符流：凡是能够读懂的都是字符流
        • 字节流：二进制文件
    • 使用字符流向一个文件输入hello world
      • 创建文件
      • 创建输出流对象
      • 把流指定指向的文件
      • 释放资源
• 第十七章：线程
  • 线程概述
    • ;进程是一个具有独立功能的程序关于某个数据集合的一次运行活动。
    • 线程：是进程的一个单元
    • 多线程：一个进程中有多个线程在同时运行。
  • 线程的生命周期
    • 新建
      • 线程被new出来
    • 准备就绪
      • 线程具有了执行资格，即线程调用了start( ),不具有执行权利。
    • 运行
      • 具有执行资格和具备执行的权利
    • 阻塞
      • 没有执行资格和执行权利
    • 销毁
      • 线程的对象变成垃圾，释放资源。
  • 线程是并发执行的
    • 忽略线程间的相互转换。
  • 实现线程的两种方式
    • ;一种是继承Thread类，一种是实现Runnable接口
  • synchronized
    • 针对线程的安全性问题，需要使用同步（就是加锁，共享资源只能有一个人进入访问）
    • 语法：synchronized（锁对象）{< 操作共享资源的代码 }
    • 同步代码加在什么地方
      • 代码被多个线程访问
      • 代码中有共享的数据
      • 共享数据被多条语句操作
    • synchronized也可以加在方法上
      • 如果是静态方法，那么锁对象就是类的类对象。
      • 如果是对象方法，那么锁是this
    • synchronized同步代码快的锁对象可以使任意类对象，
      • 当线程的实现方式时继承Thread类时，这个对象必须是静态的。
    • 在synchronized内部如果休眠会带着锁休眠
    • 只有使用锁对象才能调用wait(）方法和notify(）方法。
  • 线程的休眠
    • 在做服务端的时候为了减少服务端的压力需要休眠。
    • 如果休眠时在同步代码块中执行，休眠不会让出锁对象。
• 基本数据类型
  • 引用数据类型