Java基础简要总结

Java基础简要总结

基础语法

1. 基本数据类型

Java的基本类型分为两大类，Boolean类型和数值类型，而数值类型又可以分为整数类型和浮点类型，整数类型里的字符类型也可以被单独对待。因此常把Java的基本数据类型分为4类

1. 整数类型
   1. byte:1字节
   2. short:2字节
   3. int:4字节
   4. long:8字节
2. 字符类型
   1. char:2字节
3. 浮点类型
   1. float:4字节
   2. double:8字节
4. 布尔类型
   1. boolean

字符串不是基本数据类型，属于引用类型。

特殊的：Integer Character

2. 自增自减运算
   1. ++
      1. ++在前：先运算再使用
      2. ++在后：先使用再运算
   2. –
      1. –在前：先运算再使用
      2. –在后：先使用再运算

面向对象

1. 对象的创建，独享的属性和方法，构造方法的作用

   访问修饰符	范围	解释	使用
   private	当前类	通过private访问控制符修饰的属性或方法，只能在当前类的内部被访问。	本类中：直接直接通过成员变量名访问； 子类中：不能直接通过两种方式的任意一种访问。 不同包的类中：不能直接通过两种方式的任意一种访问；
   default	包访问	如果类里的成员一个成员（包括成员变量、方法、构造器等）或者一个外部类不适用的任何访问控制符修饰，就称他是包访问权限。default访问控制的成员或外部类可以被相同包下的其他类访问	本类中：直接通过成员变量名访问； 同包的子类中：直接通过成员变量名访问 同包的其它类：可以通过第二种方式访问； 不同包的类（包括子类）中：不能直接通过两种方式的任意一种访问。
   protect	子类访问权限	使用protected访问控制符修饰的成员变量或方法，可以被同一个包中的其他类访问，也可以被同包中的子类访问。	本类中：直接通过变量名访问； 同包的子类中L直接通过成员变量名访问； 同包的其他类中：可以通过第二种方式访问； 不同包的子类：直接通过成员变量名访问； 不同包的类中：不能直接通过两种方式的任意一种访问。
   public	公共访问权限	被public修饰的成员变量或方法，可以被所有的类访问，不管访问类和被访问类是否在同一个包中。

   1. Java中创建对象的根本途径是构造器，通过new关键字来调用某个类的构造器即可创建这个类的实例。

   2. 被private修饰的成员变量或方法只能在本类中访问。

   3. 构造方法：

      构造方法是指于类名相同，无返回类型，参数可为空，也可以带参数，基本上构造方法都是public修饰的。

      1. 作用：

         用来初始化Java类，提供类的初始化和实例化，以便调用。

         通过new创建一个对象的时候一定要用到构造方法。Java中会默认生成一个无参的构造方法，但只要在类中定义了一个有参的构造方法，无参构造方法就会失效。因此如果在类中定义了一个有参的构造方法，那么最好重新定义一个无参的构造方法。否则在创建无参对象的时候会报错

         扫描二维码关注公众号，回复： 14934709 查看本文章

      2. 有参构造方法和无参构造方法的区别

         之所以分有参合无参构造方法，是因为方法可以重载。有参构造方法的主要目的是为类中的属性根据不同的情况初始化，而无参的构造方法，可以控制new对象。

2. 方法重载的条件，重载和重写的区别

   Java中允许同一个类定义多个同名的方法，只要形参列表不同就行。如果同一个类中包含了两个或两个以上的方法名相同，但形参列表不同的方法，则称为方法重载。

   1. 定义方法的三要素

      1. 调用者：方法的所属者，既可以是类，也可以是对象
      2. 方法名：方法的表示
      3. 形参列表：当地阿勇方法时，系统会根据传入的实参列表匹配。

   2. 方法重载的条件

      1. 同一个类
      2. 方法名相同
      3. 参数列表不同

   3. 重载和重写的区别

      1. 重载（Overload）：是一个类中多态性的表现。如果一个类中定义了多个同名的方法，他们参数列表不同，则称为方法的重载。

      2. 重写（Override）：是父类与子类多态性的一种表现。如果在子类中定义某方法于其父类有相同的名称和参数，就可以说该方法被重写了。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中定义的如同被“屏蔽了”

      3. 区别：重载实现于一个类中，重写实现于子类中。

         重载：指同一个类中不同的函数使用相同的函数名，但是函数的形参列表或类型不同。可以有不同的返回值，可以有不同的访问修饰符，可以抛出不同的异常。调用的时候根据函数的参数来区别不同的函数。

         重写：是子类对父类函数的重新实现。函数名和参数与父类一样，子类与父类函数体内容不同。子类的返回值类型必须与父类保持一致，子类方法访问修饰符的限制一定要大于父类方法的访问修饰（public>protected>default>private），子类重写方法一定不能抛出新的检查异常或者比被父类方法申明更加广泛的检查星异常。

3. 继承的特点

   1. 子类可以继承费雷的属性和行为，但是子类不能继承父类的构造器
   2. Java是单继承模式：一个类只能继承一个直接父类
   3. Java不支持多继承，但是支持多层继承
   4. Java中所有的类都是object类的子类

   继承是实现软件复用的重要手段，指子类继承父类所有非私有的属性和方法，Java的继承是单继承，一个子类只能继承一个父类，但是Java可以有无限多个间接父类。

   Java的子类不能获得父类的构造器，子类只能从被扩展的父类获得成员变量、方法、内部类（包括内部接口、枚举），不能获得构造器和初始化块（静态块）。

   从子类的角度看，子类扩展（extends）了父类，但从父类的角度看，父类派生（derive）出了子类。也就是说，扩展和派生所描述的是同一个动作，只是观察角度不同。

4. 接口的特点

   接口时从多个相似类中抽象出来的规范，接口不提供任何实现。接口体现的是规范和实现分离的设计哲学。接口定义的是多个类共同的公共行为规范，这些行为是与外部交流的通道，这就意味着接口里通常是定义一组公用方法。

   在Java中，类可以实现多个接口

   接口于接口之间多继承。

   只能定义抽象方法

5. Static关键字，abstract关键字，final关键字

   • static：
     • 用途
       • 可修饰成员变量，表示该成员变量在内存中只存储一份，可以被共享访问、修改。可用类名引用（推荐），也可用对象访问。
       • 静态代码块
         • 代码块是类的五大成分之一（成员变量、构造器、方法、代码块、内部类），定义在类中方法外。在Java中，使用{}括起来的代码被称为代码块。
         • 用途特点：
           • 特点：需要通过static关键字修饰，随着类的加载而加载，并且自动触发，仅执行一次。
           • 通途：在类加载过程中做一些静态数据初始化的操作，以便后续使用。
       • 修饰工具类
         • 对于一些程序内部多次需要用到的功能，可以将这些功能封装成静态方法，放在一个类中，这个类就是工具类。
           • 内部都是静态方法，每个方法完成一个功能。
         • 优点：方便调用，提高代码复用
         • 注意
           • 一次编写，处处可用
           • 建议将工具类的构造器私有化处理。
           • 工具类不需要创建对象
     • 注意：
       • 静态方法只能访问静态成员，不能直接访问实例成员
       • 实例方法可以访问静态成员，也可以访问实例成员
       • 静态方法不能出现this（主要用来代表实例对象）关键字
   • abstract:
     • 用于修饰抽象方法和抽象类，有抽象方法的类只能被定义为抽象类，抽象类中可以没有抽象方法。
     • 声明规则
       • 抽象类必须使用abstract修饰符来修饰，抽象方法也必须使用abstract来修饰，抽象方法不能有方法体。
       • 抽象类不能被实例化，无法使用new 关键字来调用抽象类的构造器创建抽象类的实例。即使抽象类里不包含抽象方法，这个抽象类也不能被实例。
       • 抽象方法可以包含成员变量、方法（普通方法和抽象方法都可以），构造器、代码块、内部类五个成分。抽象类的构造器不能用于创建实例，主要用于其被子类调用。
       • 含有抽象方法的类（包含直接定义了一个抽象方法；或继承了一个抽象父类，但没有完全实现父类包含的抽象方法；或实现了一个接口，但没有完全实现接口包含的抽象方法三种情况）只能被定义为抽象类。
   • final:
     • 被final修饰的变量或方法，一旦获得了初始值，该final变量的值就不能被重新赋值。
     • final成员便令在显式初始化之前不能直接访问，但可以通过方法来访问，这基本上可以断定是Java设计的一个缺陷。按照正常的逻辑，final成员变量在显式初始化之前是不应该允许访问的。
     • 被final修饰的类不可以被继承。
     • final修饰的方法不能被重写。

6. 实体类的书写规范

   • 实现序列化接口
   • 定义成员变量
   • 定义有参无参构造方法
   • 定义set get 方法
   • 重写toString方法

异常

1. 异常的分类，多重catch块的执行特点

   异常时程序在“编译”或“执行”的过程中可能出现的问题，语法问题不算异常

   

   异常分为编译时异常和运行时异常

   • 编译时异常：编译的时候出现的异常，没有继承RuntimeExcepetion的异常，编辑阶段就会出错

     • 编译阶段报错，必须处理，否则代码不能执行。

   • 运行时异常：运行时出现的异常，继承自Runtime Exception的异常或其子类，编译阶段不报错，运行时可能报错

   • 解决

     • 出现异常直接抛出去给调用者，调用者也继续抛出
     • 出现异常自动捕获
     • 结合前两者，出现异常直接抛出给调用者，调用者捕获异常

   多重try catch执行特点

   • try catch :监视捕获异常，用在方法内部，可以将方法内部出现的异常直接捕获处理
   • 多重try catch，在try中出现异常后，将异常类型跟catch后面的类型一次比较，按照代码顺序进行比较，执行第一个于异常类型匹配的catch语句。
   • 一旦执行其中一条catch语句后，后面的都被忽略
   • 一般将特殊的异常放在前面，一般异常放在后面，先写子类异常，再写父类异常

2. Throw和throws的区别

   throws是用来声明一个方法可能抛出的所有异常，throws是将异常声明但不处理，而是将异常往上传，谁调用交给谁处理。而throw则是抛出一个具体的异常类型。

   1. throws：用在方法上，可以将方法内部出现的异常抛出给本方法的调用者处理
      • 这种方法并不好，发生异常的方法自己不处理异常，如果异常抛出去给虚拟机将引起程序死亡。
   2. throw：自己处理异常，处理的时候有两种方式，要么自己捕获异常（也就是try catch进行捕捉），要么就是声明抛出一个异常
      • throw一旦进入被执行，程序就会立即转入异常处理阶段，后面的语句就不再执行，而且所在的方法不在返回有意义的值。
   3. 区别
      • throw用于在方法体内，throws用在方法声明后面，表示在抛出异常，由该方法的调用者处理。
      • throw是具体向外抛异常，抛出的是一个异常实例，throws声明了是那种类型的异常，使它的调用者可以捕获这个异常
      • throw如果执行了，那么一定抛出了某种异常，而throws表示可能出现，但不一定
      • 同时出现时，throws出现在函数头，throw出现在函数体，两种不会由函数去处理，真正的处理由函数的长层调用处理。

常用类

1. 包装类，包装类的池优化操作

   1. 包装类
      • Integer
      • Character
      • Double
      • …………
   2. 池化操作
      • 每个包装类都会有一个常量池
      • 当内容超过常量池的范围后会重新创建一个对象

2. 反射的作用

   • 什么是反射
     • Java反射就是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用他的任意方法和属性；并能改变他的属性。
   • 反射机制允许程序在运行时取得任何一个已知名称的class的内部信息，包括其修饰符、属性、方法等，并且可以在运行时改变属性内容或调用方法
   • 注意：
     • 反射会消耗系统性能，增加复杂性

3. 字符串的特点

   • 字符串是引用类型：字符串的数据都是存储在堆空间的，栈空间中的变量存储了该数据的引用地址
   • 字符串是不可变的：当一个字符串变量重新赋值时，旧值并没有销毁，而是重新开辟了一个新的空间存储新值
   • 字符串可以看成一个只读的字符数组：可以通过for循环遍历字符串，得到所有的单个字符，也可以用变量名[索引下标]的形式得到相应的字符。

4. 求字符串的子串

   • substring()
   • charAt()
   • split()

5. String，StringBuffer和StringBuilder的区别

   • String:
     • 对于String来说，是把数据存放在了常量池中，因为所有的String，默认都是以常量形式保存，且由final修饰，因此在线程池中它是线程安全的。因为每一个String当被创建好了以后，他就不再发生任何变化，但是它的执行速度是最差的。
       我们要创建String的时候，他在常量池中对这些信息进行处理，如果在程序中出现了大量字符串拼接的工作，效率是非常底下的。
       因此使用场景是在少量字符串操作的时候才建议直接使用String来操作。
   • StringBuffer
     • StringBuffer相对于StringBuilder效率要相对低一点，但也远比String要高的多。效率低的原因：对于StringBuffer来说更多的考虑到了多线程的情况，在进行字符串操作的时候，它使用了synchronize关键字，对方法进行了同步处理。
       因此StringBuffer适用于多线程环境下的大量操作。
   • StringBuilder
     • 线程安全与线程不安全：
       在进行多线程处理的时候，如果多个线程对于这一个对象同时产生操作，会产生预期之外的结果。对于StringBuilder来说，执行效率虽然高，但是因为线程不安全，所以不建议在多线程的环境下对同一个StringBuilder对象进行操作。
       因此StringBuilder适用于单线程环境下的大量字符串操作。

6. 生成随机数

   // 使用Random类
   Random r = new Random();
   r.nextInt();
   r.nextLong();
   r.nextBoolean();
   r.nextFlot();
   // 使用Math中的random()方法
   Math.random()
   

7. == 和equals的区别

   • == ：比较地址
   • equals：只比较值

集合

1. 集合的体系，接口，实现类

   

2. 集合中泛型的使用

   Java集合有个缺点，把一个元素放到集合中，集合就会忘记这个元素对应的数据类型，当再次取出该元素时，该元素的类型就自动编程Object类型。因此在定义集合的时候，通常为了保证数据类型的准确，避免在从集合中取出元素时重新进行强制类型转换，都会使用泛型来固定元素的类型。

   所谓泛型，就是允许在定义类、接口、方法时使用类型形参，这个类型形参（或者加泛型）将在声明变量、创建对象、调用对象时动态指定（即传入实际的类型参数，也称为类型实参）。

3. Array List和LinkedList的特点

   • Array List
     • ArrayList类实现了可变数组的大小，存储在内的数据称为元素。他还提供了快速索引访问元素的方式，对尾部成员的增加删除支持比较友好。使用Array List创建的集合，允许集合中的元素进行快速的随机访问，不过Array List中删除和插入元素相对较慢（顺序存储结构）。
     • 重载
       • ArrayList()：构造一个初始容量为 10 的空列表。
       • ArrayList(Collection<?extends E>c)：构造一个包含指定 Collection 元素的列表，这些元素是按照该 Collection 的迭代器返回它们的顺序排列的。
     • 注意
       • 当调用List的set(indext , elem)方法来改变List集合指定处索引的元素时，指定的索引必须时List集合的有效索引
   • Linked List
     • LinkedList类采用链表结构保存对象，这种结构的优点是便于向集合中插入或删除元素。需要频繁向集合中插入或删除元素时，使用LinkedList类比Array List类的效率高，到那时LinkedList类随机访问元素（检索集合中特定索引位置的元素）的速度则相对较慢。
   • 区别
     • Array List和Linked List都是List接口的实现类，因此都实现了List的所有未实现的方法，只是实现的方式不同
     • Array List是基于动态数组的线性存储结构的实现，访问元素速度优于Linked List。Linked List 是基于链表结构的实现，占用的内存空间比较大（每个元素都有一个指针），但在插入和删除的是偶优于Array List

4. List， Map，Set的特点

   • List

     List是一个有序、可重复的集合，集合中的每个元素都有其对应的顺序索引。List集合允许使用重复元素，可以通过索引来访问指定位置的集合元素。List集合默认按元素的添加顺序设置元素的索引，第一个添加到List集合中的元素的索引为0，

     • 特点：
       • 有序、可重复
       • 每个元素都有对应的索引
     • 实现类
       • Array List
       • Linked List

   • Map

     

     • 概述

       • Map集合是一种双列集合，每个元素包含两个数据
       • 每个元素的格式：key = value（键值对元素）
       • Map集合也称为“键值对集合”

     • 特点

       • Map集合的特点都是由键决定的
       • Map集合的键是无序，不重复，无索引的，值没有要求
       • Map集合后面重复的键值对都可以为null
       • Map集合后面重复的键对应的值都会覆盖前面重复的值。

     • 实现类

       • Hash Map：元素按照键是无序、不重复、无索引，值不做要求
       • LinkedHashMap:元素按照键是有序、不重复、无索引，值不做要求
       • TreeMap：元素按照键是排序、不重复、无索引，值不做要求

   • Set

     • 底层原理

       • JDK8之前，哈希表：底层使用数组+链表组成
       • JDK8之后，哈希表：底层采用数组+链表+红黑树组成。

     • 特点：

       • 无序：存放顺序不一致
       • 不重复：可以去除重复
       • 无索引：没有带索引的方法，所以不能使用普通的For循环遍历，也不能通过索引获取元素

     • 实现类

       • HashSet：无序、不重复、无索引

         • 底层采用哈希表存储数据
         • 哈希表是一种对于增删改查数据性能都较好的结构

       • LinkedHashSet：有序、不重复、无索引

         • 有序指的是保证存储和取出的元素顺序一致
         • 原理：底层数据结构依然是哈希表，只是每个元素又额外多了一个双链表的机制记录存储的顺序

       • TreeSet：排序、不重复、无索引

         • 可排序：按照元素的大小默认升序排序
         • 底层基于红黑树的数据结构实现排序，增删改查性能都较好
         • 注意：TreeSet集合是一定要排序的，可以将元素按照指定的规则进行排序
         • 想要使用TreeSet存储自定义类型，需要指定排序规则
         • 自定义排序规则
           • 类实现Comparable接口，重写比较规则
           • 结合自定义Comparator比较器对象，重写比较规则

5. Map集合中存值，entryset遍历和迭代器遍历

   • Map的遍历方式：三种
     • 键找值的方式遍历：先获取Map集合全部的键，再根据遍历键找值
       • map.keySet()
     • 键值对方式遍历：把键值对看成一个整体。
       • map.entrySet()
     • 遍历值
       • map.values()

    Map<String,String> map = new HashMap<>();
           map.put("1","a");
           map.put("2","d");
           map.put("3","c");
           map.put("4","d");
           map.put("5","e");
           //entryset key-value ==>entry
           Set<Map.Entry<String, String>> entries = map.entrySet();
           //for
           for (Map.Entry<String, String> entry : entries) {
         
         
               System.out.println("entry.getKey() = " + entry.getKey());
               System.out.println("entry.getValue() = " + entry.getValue());
           }
           //迭代器
           Iterator<Map.Entry<String, String>> iterator = entries.iterator();
           while (iterator.hasNext()){
         
         
               Map.Entry<String, String> entry = iterator.next();
               System.out.println("entry.getKey() = " + entry.getKey());
               System.out.println("entry.getValue() = " + entry.getValue());
           }
           //values
           Collection<String> values = map.values();
           //缺点：无法根据value获得key。
           //for
           for (String value : values) {
         
         
               System.out.println("value = " + value);
           }
         //迭代器
           Iterator<String> iterator = values.iterator();
           while (iterator.hasNext()){
         
         
               String value = iterator.next();
               System.out.println("value = " + value);
           }
           // keyset
           Set<String> strings = map.keySet();
           // for
           for (String key : strings) {
         
         
               System.out.println("key = " + key);
               String value = map.get(key);
               System.out.println("value = " + value);
           }
           // 迭代器
           Iterator<String> iterator  =strings.iterator();
           while (iterator.hasNext()){
         
         
               String key = iterator.next();
               System.out.println("key = " + key);
               String value = map.get(key);
               System.out.println("value = " + value);
           }
   

6. 比较功能的接口

   • Comparable 接口
     • 该接口强行对实现它的每个类的对象进行整体排序。此排序称为该类的自然排序，类的comparaTo方法被称为自然比较方法。实现此接口的对象列表可以通过Collections.sort（Arrays.sort）进行自动的排序。实现此接口的对象可以用作有序映射表中的键或有序集合中的元素，无序指定比较器
     • 实现方法：compare To
   • Comparator 接口
     • Comparator位于包Java.util下，而Comparable位于包Java.lang下
     • Comparable接口将比较代码嵌入需要进行比较的类自身代码中，而Comparator接口在一个独立的类中实现比较
     • 如果前期类的设计没有考虑Compare问题i二十实现Comparable接口，后期可以通过Comparator接口来实现比较算法进行排序，并且为了使用不同的排序标准做准备。

IO流

​ IO流也称为输入、输出流，就是用用来读写数据的。I表示input，数据从硬盘文件读入到内存，O表示output，数据从内存中写入到硬盘。

IO流分为四大类：

• 字节输入流：以内存为基准，来自磁盘文件/网络中的数据以字节的形式读入到内存中
• 字节输出流：以内存为基准，把内存中的数据以字节写到磁盘文件或网络中
• 字符输入流：以内存为基准，把磁盘文件/网络中的数据以字符的形式读入到内存
• 字符出书流：以内存为基准，把内存中的数据以字符的形式写出到磁盘文件/网络介质中

1. BufferedReader的特殊方法
   • readLine():读取一行数据返回，如果读取没有完毕，无行可读返回null
2. IO流中的设计模式
   • 装饰器模式
     • 装饰器模式是在不必改变原类文件和不使用继承的情况下，动态的扩展一个对象的功能。通过创建一个包装对象，也就是装饰来包裹真实的对象。
     • 注意
       • 不改变原类文件
       • 不适用继承
       • 动态扩展
   • 适配器模式
   • 装饰器和适配器模式的异同点
     • 装饰器与适配器都有一个别名叫做 包装模式(Wrapper)，它们看似都是起到包装一个类或对象的作用，但是使用它们的目的很不一一样。
       适配器模式：义是要将一个接口转变成另一个接口，它的目的是通过改变接口来达到重复使用的目的。
       装饰器模式：不是要改变被装饰对象的接口，而是恰恰要保持原有的接口，但是增强原有对象的功能，或者改变原有对象的处理方式而提升性能。所以这两个模式设计的目的是不同的。
3. 字符流的顶级父类，转换流的创建

1. 序列化接口

   Serializable

   • 用途
     • 把内存中的对象保存到一个文件或数据库中
     • 把对象通过网络进行传输的时候
   • 实现
     • 实体类实现Serializable接口

线程

1. 线程的状态

   1. 新建
   2. 可运行
   3. 运行
   4. 阻塞
   5. 死亡

2. 线程的启动

   调用start方法，只有调用start方法才会启动一个新的线程

   如果调用run方法会当成普通的方法执行，还是相当于单线程。

3. 实现线程的两种方式

   • 方式一
     • 定义一个线程任务类MyRunnable实现Runnable接口，重写run方法
     • 创建MyRunnable对象
     • 把MyRunnable任务对象交给Thread线程对象处理
     • 调用线程对象的start方法启动线程
     • 优缺点：
       • 优点：线程任务类只是实现了Runnable接口，可以继续继承和实现
       • 缺点：如果线程有执行结果是不能直接返回的。
   • 方式二
     • 继承Thread类
     • 重写run方法
     • 创建线程对象
     • 调用start方法
     • 优缺点：
       • 优点：编码简单
       • 缺点：存在单继承的局限性，继承Thread类后，不能继承其他类，不便于扩展。

4. 保证线程安全的关键字

   • synchronized：加锁
     • 对于实例方法建议使用this作为锁对象
     • 对于静态方法建议使用字节码（类名.class）对象作为锁对象

5. Wait,notify方法的使用要求

   • wait：让当前线程等待并释放所占锁，知道另一个线程调用notify（）方法或notifyAll（）方法
   • notify：唤醒正在等待的单个线程
   • 注意：
     • 应当使用当前同步锁对象进行调用

网络

1. 创建Socket对象

   // 服务器端
   package server;
   
   import java.io.IOException;
   import java.net.ServerSocket;
   import java.net.Socket;
   
   public class Mysever {
         
         
   
   	public static void main(String[] args) throws IOException {
         
         
   		
   		//建立服务端对象，绑定4574端口。
   		 ServerSocket serv =new ServerSocket(4574);
   		 
   		 System.out.println("服务器启动成功，等待用户接入");
   		  
   		 //accept()等待用户接入,如果没有用户连接，会一直等待。
   		 //有客户连接后，accept()方法会返回一个Socket对象，代表客户端
   		 Socket sc=serv.accept();
   		 
   		 System.out.println("有客户端接入，客户端ip:"+sc.getInetAddress());
   	}
   }
   
   // 客户端
   
   package server;
   
   import java.io.IOException;
   import java.net.ServerSocket;
   import java.net.Socket;
   
   public class Mysever {
         
         
   
   	public static void main(String[] args) throws IOException {
         
         
   		
   		//建立服务端对象，绑定4574端口。
   		 ServerSocket serv =new ServerSocket(4574);
   		 
   		 System.out.println("服务器启动成功，等待用户接入");
   		  
   		 //accept()等待用户接入,如果没有用户连接，会一直等待。
   		 //有客户连接后，accept()方法会返回一个Socket对象，代表客户端
   		 Socket sc=serv.accept();
   		 
   		 System.out.println("有客户端接入，客户端ip:"+sc.getInetAddress());
   	}
   }
   
   
   

JDBC

1. JDBC相关对象，JDBC的步骤
   1. 相关对象
      • Driver Manager：用于管理JDBC驱动的服务类，程序中使用该类主要功能是获取Connection对象。
      • Connection：代表数据库连接对象，每个Connection代表一个物理连接会话。要想访问数据库，必须先获取数据库连接。常用的方法如下：
        • Statement createStatemente() thror SQLExcetpion:该方法返回一个Statement对象
        • PreparedStatement prepareStatement(String sql) throw SQLException:该方法返回预编译的Statement对象，即将Sql语句提交到数据库进行预编译
        • Callable Statement prepareCall(String sql) throw SQLExcetpion:该方法返回Callable Statement对象，该对象用于调用存储过程。
      • Statement：用于执行SQL语句的工具接口。该对象即可用于执行DDL、DCL语句，也可用于执行DML语句，还可用于执行SQL查询。当执行SQL查询时，返回查询到的结果集。
      • PreparedStatement：预编译的Statement对象。Prepared Statement是Statement的子接口，它允许数据库预编译SQL语句（这些SQL语句通常带有参数），以后每次只改变SQL命令的参数，避免数据库每次都需要编译SQL语句，因此性能更好，相对于Statement而言，使用Prepared Statement执行SQL语句时，无需再传入SQL语句，只需要把预编译的SQL语句传入参数值即可。
   2. JDBC编程步骤
      1. 加载数据库驱动。通常使用Class.forName()静态方法来加载驱动
      2. 通过Driver Manager获取数据库连接。
      3. 通过Connection对象创建Statement对象或PreparedStatement对象
      4. 使用Statement对象或PreparedStatement对象执行SQL语句。
      5. 操作结果集。如果执行的SQL语句是查询语句，则执行结果将返回一个ResultSet对象，该对象里保存了SQL语句查询的结果。程序可以通过操作改ResultSet对象来取出查询结果。
      6. 回收资源，关闭ResultSet，Statement、Prepared Statement、Connection

ement对象。Prepared Statement是Statement的子接口，它允许数据库预编译SQL语句（这些SQL语句通常带有参数），以后每次只改变SQL命令的参数，避免数据库每次都需要编译SQL语句，因此性能更好，相对于Statement而言，使用Prepared Statement执行SQL语句时，无需再传入SQL语句，只需要把预编译的SQL语句传入参数值即可。
2. JDBC编程步骤
1. 加载数据库驱动。通常使用Class.forName()静态方法来加载驱动
2. 通过Driver Manager获取数据库连接。
3. 通过Connection对象创建Statement对象或PreparedStatement对象
4. 使用Statement对象或PreparedStatement对象执行SQL语句。
5. 操作结果集。如果执行的SQL语句是查询语句，则执行结果将返回一个ResultSet对象，该对象里保存了SQL语句查询的结果。程序可以通过操作改ResultSet对象来取出查询结果。
6. 回收资源，关闭ResultSet，Statement、Prepared Statement、Connection