java知识总复习 笔记

1.面向对象

1.1 形式参数

​ 基本数据类型（4类8种） ：直接传具体的值i使用 引用数据类型 ；在调用时，应给它相应光电对象

1.2匿名对象

​ NoNameDemo nnd = new NoNameDemo();普通对象 nnd.Test(new Teacher());//匿名对象

1.3封装 ,继承，多态

1 封装

​ 概述 ：隐藏对象的属性和实现的细节，仅对外提供公共的访问方式。 原则：将不需要用户的操作的内容隐藏起来。根据需求，提供公共的访问需求。 优点 ：

2.private 关键字

1.它是一个权限修饰符 2.可以修饰成员的变量和方法 3.被修饰的成员只能在本类中被访问，如果其他类想访问，需要经过公共的访问方法。

3.private应用和封装

1.私有化成员变量 2.提供getxxx/setxxx方法

4.this关键字

1.表示当前类的对象

1. 谁调用该方法 ，该方法内部的this就代表谁（继承部分，结合surprice）

5.构造方法

​ 概述：创建对象，并对对象的数据进行初始化 格式： public 与类名相同的方法

注意事项：如果我们给出构造方法，则系统将不会在提供一个默认的无参构造方法 不给 ，系统提供

私有成员变量赋值 1.setxxx 2.有参构造函数

6.标准类的构造

1.成员变量 2.成员方法 3.构造方法

8.main学习方法

9.学习使用java API

1.打开API 2.左上角“显示”----“索引”--------搜索要学习 的类 3.除了java.lang包不需要导包，其他所有的包在使用前都需要导包import 4.类的组成 成员变量----字段 的摘要 成员方法-----方法 构造方法------构造方法 5.学习构造方法： a.邮构造方法：按照API的格式创建对象 b没有构造方法：可能它的成员变量和成员方法是静态的，直接可以通过类名进行调用

6.学习成员变量 了解每个成员变量的含义 7.学习成员方法

左边：
      a.是否为静态
       b。是否又返回值
 
  右边：
       a.方法名
       b。参数列表

10.代码块

/**

• 代码块
• 局部代码块:局部位置,用于限定变量的生命周期。
• 构造代码块：
• 位置：在类的成员位置
• 执行条件：无论调用有参还是无参构造方法，都执行
• 执行顺序：先于构造方法执行
• 作用：和构造方法一起对对象进行初始化，提高代码的复用性
• 静态代码块：在类的成员位置，有static关键字修饰
• 位置：类的成员位置
• 执行条件：类加载的时候执行
• 执行顺序：类加载的时候执行
• 作用：对类的初始化 */

11.继承

概述：是把多个类相同的成员提取出来，定义到一个独立的类中，然后让这多个类与这个独立的类 产生一个关系，多个类就具备了这个独立类的属性和功能，这个关系就叫做继承 格式：extends 关键字 class 子类extends 父类（） 优点：1.提高了代码的复用性 2.提高了代码的维护性 3.多态的前程 缺点：1.蹭强了类与类之间的耦合性，不符合“高内聚。低耦合”的设计 2.打破了封装性 注意事项：1.子类不能继承父类的私有成员方法和变量 2.子类不能继承父类的构造方法，但是可以通过super关键字去访问 3.不因为一个类的某几种功能而去选择继承 继承成员的关系： 1.成员变量 a 变量名相同 1.在子类局部位置寻找 2.在子类的成员变量位置寻找 3.在父类的成员位置寻找】 b. 变量名不同 2.构造方法 a。子类所有的构造方法都会默认访问父类的无参构造方法 原因：子类对象如果能够访问的属性活方法，则必须对父类进行初始化 b。如果父类没有无参构造 1.通过super关键字指定访问父类的有参构造方法，完成完成初始化 2.通过this关键字访问本类的其他构造方法，但是被访问的这个构造方法必须已经完成父类构造方法的访问 3.手动给出父类的无参构造 3.成员方法 a。方法名相同 1.在子类中找 2.在父类中找 3.报错 b。方法名不同

12.多态

概述:同一操作，作用于不同对象，可以产生不同的结果。 前提: 1.有继承关系

               2.有方法的重写

               3.父类引用指向子类的对象

    成员访问特点: .

       1.成员变量

            编译看父类(左边)，执行看父类(左边)

      2.构造方法

              子类的构造默认访问父类的无参构造

       3.成员方法

          编译看父类(左边)，执行看子类(右边)

       4.静态方法

编译看父类(左边)，执行石父类(左边)

    多态的优点:

        1.提高了代码的维护性

2.提高了代码的扩展性

   多态的缺点:

不能访问子类特有的方法。

    对象间的转型:

    向上转型（由子到父）
                                  Fu   f  =  new  zi();
                            向下转型 （由父到子）
                                 Zi   z  = (Zi)f;

13.抽象类

          ●被关键字abstract修饰，可以修饰类和方法

                     格式:
                          abstract class 类名{}抽象类
                         public abstract void方法名(参数列表) C抽象方法
          ●抽象类不一定有抽象方法，但是有抽象方法的类- -定是抽象类
          ●抽象类只能被子类实例化(多态的一 -种)
          ●抽象类的子类:①抽象类②标准类:必须重写抽象类中的所有抽象方法

• 抽象类
• 概述：用来描述抽象概念的类，叫做抽象类，抽象类中的方法不一定要实现具体的功能。
• 特点： 1.被abstract关键字修饰
• 2.抽象类中不一定有抽象方法，但是，有抽象方法的类，必须被定义为抽象类。
• 3.抽象类有构造方法。但是不能被创建对象。它的构造方法是供子类初始化父类数据用的。
• 4.抽象类可以被继承
• a.子类必须重写抽象类中所有的抽象方法
• b.抽象类可以继承抽象类，并且不需要实现父类中的抽象方法。
• 多态的应用：主要应用于抽象类与标准类之间的继承关系。
• 成员组成: 1.成员变量: 可以是变量，也可以是final修饰的变量(常量) 2.构造方法: 有构造方法，作用是供子类调用初始化父类数据。 3.成员方法: 可以是抽象方法，也可以是非抽象方法。 注意事项 1.没有抽象万法的抽象类，日的起为广不让你该类创建对象。 2.abstract与其他几个关键字的关系 a. private 冲突关系。因为抽象方法必须由了类实现，liprivate修饰的方法不能被继承，导致不能被了类重写。 b.final ：冲突关系 因为final修饰的方法不能被重写 c.static 冲突关系 因为static修饰的方法事随类的加载而加载，我们可以直接通过类名去调用。这样的组合没有任何意义。

14.接口

​ 概述: Java接口时一系列方法的声明， 是一-些方法特征的集合,接口中只有方法的特征,没有方法的 实现，因此这些方法可以在不同地方被不同类实现，而这些实现可以具有不同的行为 特点: 1.关键字interface interface接口名{ }

2.类实现接口使用关键字implements
    class类名implements 接口名1,接口..... }
3.接口不能被创建对象，但是可以通过多态去实例化
4.接口的实现类
    a.可以是标准类，但是标准类必须重写接口中所有的抽象方法。
    b.可以是抽象类，不需要重写抽象方法的。
                成员特点：1.成员变量
                       只能有常量，因为变量默认的被public static final修饰
2.构造方法
    没有构造方法
3.成员方法
    只能是抽象方法，默认被public abstract修饰
类，接口之间的关系
    1.类与类
        继承关系，只能单继承,不能多继承,但可以多层继承。
    2.类与接口
        实现关系，单实现或多实现
    3.接口与接口
        继承关系，并且是多继承。
            面试题:      Java中的继承是单继承?  错
        Java中的类是单继承?     对
接口与抽象类的区别
    1.组成区别
    抽象类: .
        成员变量:可以是变量，可以是常量
        构造方法:有构造方法
        成员方法:可以是抽象方法，也可以是非抽象方法
    接口:
        成员变量:没有成员变量，只能是常量
        构造方法:没有构造方法
        成员方法:只能是抽象方法
    2.关系的区别
        类与类
        类与接口
        接口与接口
    3.应用的区别
        抽象类中定义的是继承体系中相同的属性和方法
        接口中定义的是类的扩展功能。

15.包 概述:其实就是文件夹 作用:对类的分类管理(图书馆对于书籍的分类，这个分类就相当于包) 关键字: package 格式: package包名; (多级包用 ”. "隔开) 注意事项: 1.package语句必须是java文件的第一 条语句(注释除外) 2.-个java文件中， 只能有一条package语句 3.没有package语句,默认就是没有包 导包:关键字import 1.import包名类名(推荐格式) 2.import包名.*

16.权限修饰符 权限修饰符 本类 同一包 不同包子类 不同包其他类 private Y 默认 Y Y protected Y Y Y public Y Y γ Y

**常见修饰符：**

  	 1.权限修饰符： private ， 默认 ，protected  ,public

​ 2.状态修饰符：final , static

​ 3.抽象修饰符：abstract

修饰符
            1.权限修饰符： private ， 默认 ，protected  ,public

​ 2.状态修饰符：final , static 3.抽象修饰符：abstract

           类：
            权限修饰符: 默认 ，protected  ,public

            状态修饰符：final

            抽象修饰符：abstract
 
            常用修饰符：public 默认的

 成员变量：          

     权限修饰符：private ， 默认 ，protected  ,public
            
    状态修饰符：final ,  static
 
            常用修饰符： private
 
    构造方法：

            权限修饰符：private ， 默认 ，protected  ,public
 
            常用修饰符：public
 
    成员方法：

            权限修饰符：private ， 默认 ，protected  ,public

            状态修饰符：final ,  static

            抽象修饰符：abstract
 
     常用修饰符：public
 
   常见修饰符组合：

                成员变量

                          public static final

                 成员方法

                     public static

                     public abstract

                     public final

2.常用类

3.类的高级特性

4.集合

5.IO流

1.IO概述

​ **概述：**用于设备间数据传输的操作

分类：

​ 1.流向

​ 输入流：读取操作

​ 输出流：写出操作

​ 2.数据类型

​ 字节流

​ 字节输入流

​ 字节输出流

​ 字符流

​ 字符输入流

​ 字符输出流

注意：

​ 1.如果文件用记事本打开，内容能够读懂，就用字符流，读不懂就用字节流。实在不知道用什么流的话就用字节流。

2.FileOutputStream 字节输出流

​ 操作步骤：

                1.  创建字节流对象

FileOutputStream fos = new FileOutputStream(“fos.txt”);

​ 2.调用write()

fos.write(“Hello”.getBytes());

​ 3.释放资源

fos.close

注意：

​ 1.如何换行，如何在文件中追加内容

3.FileInputStream 字节输入流

操作步骤：

1.创建字节流对象

​ FileInputStream fis = new FileInputStream(“fos.txt”);

2.调用read()方法

//方式1：一次读取一个字节
int content = 0 ;
while((content = fis.read())!=-1){
    System.out.println((char)content)
}

//方式2：一次读取一个字节数组
byte[] bytes = new byte[1024];
int len = 0 ;
while((len=fis.read(bytes))!=-1){
    System.out.println(new String(bytes,0,len))
}
    

3.释放资源

fis.close

4.字节缓冲流

BufferedOutputStream

BufferedInputStream

5.字符流

5.1 字符转换流

1. 字符流 = 字节流 + 编码表
2. 编码表：ASCII ,GBK,GB2312,UTF-8

5.2 OutputStreamWriter

OutputStreamWriter(OutputStream os):没有指定编码集，就采用默认编码集：UTF-8

OutputStreamWriter(OutputStream os , String charsetName )指定编码集

5.3 InputStreamReader

InputStreamWriter(OutputStream os):没有指定编码集，就采用默认编码集：UTF-8

InputStreamWriter(OutputStream os , String charsetName )指定编码集

5.4 字符流

Writer

​ FileWriter

Reader

​ FileReader

6.标准输入输出流

​ in：标准输入流—inputStream

​ out：标准输出流—PrintStream

7.打印流

字节打印流–PrintStream

字符打印流–PrintWriter

特点：

​ 1.只负责输出数据，不负责读取数据 2.它有自己特有的方法

8.序列化流d

**序列化流：**把对象按照流的方式存入到文件中或在网络中传输。 对象----》流数据-ObjectOutputStream

**反序列化流：**把文件中的流数据或网络传输中的流数据还原成对象。 流数据----》对象-ObjectInputStream

如何实现序列化：

​ 让被序列化的对象所属的类实现序列化接口。这个接口是一个标记接口。

注意

​ UID:如果你不固定UID,你每次修改类文件时，都会相应的生成新的UID，这样你就需要重新执行对象的序列化和反序列化操作。

​ **transient：**不想被序列化的属性可以用它来修饰

6.Properties类

1.它是一个集合类，HashTable的一个子类。它的数据存储类似于Map集合，并且它的key和value都是String.

2.特有方法

public Object setProperty(String key,String value):添加元素
public String getProperty(String key)：根据键获取值
public Set stringPropertyNames()：获取键集合

3.与IO流结合使用 的方法

public void load(Reader reader):将文件中的数据写入到集合中----指定数据源
public void store(Writer writer,String comments)：将集合中的数据写入到文件中---指定目的地

6.多线程

7.网络编程

1.本章目标：

​ 1.了解IP地址与InetAddress类的关系。

​ 2.了解如何使用URL定位网络资源。

					  3.了解编码和解码的操作。

					  4.了解ServerSocket类与Socket类的关系以及客户端与服务器端的通信模式。

​ 5.了解如何将多线程机制应用在服务器开发上。

​ 6.了解UDP程序与TCP程序的实现区别。

扩展：TCP和UDP协议

​ TCP：可靠的传输协议，传输前会采用“三方握手”的方式建立连接，以保证传输的可靠性；

​ UDP：不可靠的传输协议，即发送的数据不一定接受得到，网上的聊天工具一般采用此协议。

2.IP（Internet Protocol)简介

​ IP地址使用32为长度二进制表示，一般实际中看到的大部分IP地址都是以十进制的数据形式表示，如同192.168.1.1。

IP地址=网络地址+主机地址

​ 127.x.x.x的为保留地址，用作循环测试使用。

3.InetAddress类

1.获取方法

public static InetAddress getByAddress(byte[] addr)throws UnknownHostException
    在给定原始 IP 地址的情况下，返回 InetAddress 对象。
    参数按网络字节顺序：地址的高位字节位于 getAddress()[0] 中。 
    此方法不会阻塞，即不执行任何反向名称服务查找操作。 
IPv4 地址 byte 数组的长度必须为 4 个字节，IPv6 byte 数组的长度必须为 16 个字节 

2.获取此 IP 地址的主机名

public String getHostName()
 //常用来输出IP地址

3.返回 IP 地址字符串

public String getHostAddress()

4.本地主机的 IP 地址

public static InetAddress getLocalHost()
                                throws UnknownHostException

4.URLEncoder与URLDecoder 编码和解码

5.TCP程序设计

1.套接字Scoket

6.UDP程序设计

​ 1.UDP开发中使用DatagramPacket类包装一条要发送的信息，之后使用DatagramPacket类用于完成信息的发送操作，这两个类的常用方法如下：

​ 包装发送的信息

public DatagramPacket(byte[] buf,int offset,int length,InetAddress address,int port)
    //实例化DatagramPacket对象时指定发送的数据、数据的长度、目标地址及端口
public DatagramPacket(byte[] buf,int length)
    //实例化DatagramPacket对象时指定发送数据的长度。
public byte[] getData()
    //返回数据缓冲区。接收到的或将要发送的数据从缓冲区中的偏移量 offset 处开始，持续 length 长度。 
public int getLength()    
    //返回将要发送或接收到的数据的长度。 

完成信息的发送操作

//构造方法
public DatagramSocket(int port) throws SocketException
//普通方法
 public void receive(DatagramPacket p) throws IOException  
//从此套接字接收数据报包。当此方法返回时，DatagramPacket 的缓冲区填充了接收的数据。数据报包也包含发送方的 IP 地址和发送方机器上的端口号。 
此方法在接收到数据报前一直阻塞。数据报包对象的 length 字段包含所接收信息的长度。如果信息比包的长度长，该信息将被截短。 
如果存在安全管理器，而安全管理器的 checkAccept 方法不允许接收操作，则包不能被接收。
  public void send(DatagramPacket p) throws IOException 
//从此套接字发送数据报包。DatagramPacket 包含的信息指示：将要发送的数据、其长度、远程主机的 IP 地址和远程主机的端口号

任务：

1. 自动获取电脑IP地址并输出

​ 2.接受用户端想要监听的端口

​ 3.用户发送数据 ，服务器接受消息 ，反馈。

​ 4.完成用户登录注册方式 ，服务器自动回复登录成功等。

练习 ：上传文件 今日练习

//1.int[] numbers = {23,5,28,29,4.65} 冒泡排序

//2.上传文件

8.JDK新特性-JDK9

2017年9月发布

1.模块化系统-Modularity

2.REPL工具-jshell命令

R：read

E:evaluate

P：print

L：loop

​ 产生背景：

Python ,Scala语言在很早就提出了交互式编程环境

常用命令/help

1./list :显示已经成功的代码

2./vars(method)：显示已定义的变量（方法）

3./edit：调用编辑框，修改代码

4./open:运行JAVA文件中的代码

特点：

​ 1.可以声明同名变量，但是原来的值会被覆盖。

​ 2.可以声明同名方法，原方法体被覆盖

​ 3.tab可以提示和补全代码

​ 4.没有编译时异常

3.接口可以有方法和私有方法

特点：

1.接口中可以有默认方法，静态方法，私有方法

2.实现接口的类必须实现抽象方法，但是不强制实现默认方法

3.接口中的静态方法，通过接口名调用

4.接口中的私有方法，只能被默认方法使用，不能被静态方法以及实现类中被使用。

4.钻石操作符（泛型）功能升级

在JDK8中，匿名内部类如果使用泛型会发生错误；

错误格式：

//JDK9
Comparator