当前位置： 代码迷 >> 综合 >> 第二阶段：JAVA基础深化与提高
  详细解决方案

第二阶段：JAVA基础深化与提高

热度：41   发布时间：2024-01-10 16:44:40.0

文章目录

  • 2 第二阶段 JAVA深化和提高
    • 2.1 面向对象深化
      • 2.1.1 抽象类和抽象方法
        • 2.1.1.1 抽象方法概念
        • 2.1.1.2 什么情况下使用抽象方法和抽象类？
      • 2.1.2 接口详解
        • 2.1.2.1 接口的概念
        • 2.1.2.2 接口中可以包含什么？
        • 2.1.2.3 接口与类的关系
      • 2.1.3 接口的特征_使用接口的意义
        • 2.1.3.1 接口的传递性
        • 2.1.3.2 接口的继承性（多继承）
        • 2.1.3.3 使用接口的意义_接口实现多态的步骤
      • 2.1.4 内部类
        • 2.1.4.1 内部类的概念
        • 2.1.4.2 内部类的特点
        • 2.1.4.3 内部类的优缺点
        • 2.1.4.4 内部类的访问
        • 2.1.4.5 内部类访问外部类
        • 2.1.4.6 定义在方法中的内部类
        • 2.1.4.7 匿名内部类（没有名字的内部类）
      • 2.1.5 String类常用方法_API文档阅读
        • 2.1.5.1 String 类的定义
        • 2.1.5.2 String类的常用方法
        • 2.1.5.3 API文档
      • 2.1.6 String类与常量池
        • 2.1.6.1 String类的构造方法
        • 2.1.6.2 通过String类学习内存空间的运作
      • 2.1.7 字符串相等的判断
        • 2.1.7.1
    • 2.2 数组深化
      • 2.2.1 多维数组
        • 2.2.1.1 二维数组的格式
        • 2.2.1.2 二维数组的初始化
        • 2.2.1.3 **二维数组中的元素，实际上是存储一维数组的地址**
        • 2.2.1.4 二维数组的遍历
      • 2.2.2 Object数组存储表格数据
      • 2.2.3 数组的拷贝
        • 2.2.3.1 地址的拷贝（即引用的拷贝）
        • 2.2.3.2 值的拷贝：这里使用System.arrcopy()方法
      • 2.2.4 java.util.Arrays 工具类的使用
        • 2.2.4.1 java.util.Arrays常用工具介绍
      • 2.2.5 冒泡排序的基础算法
      • 2.2.6 冒泡排序法的优化算法
      • 2.2.7 二分法（折半查找法）
    • 2.3 异常机制 Exception
      • 2.3.1 异常概念_分类
        • 2.3.1.1 异常的概念及出现的情况
        • 2.3.1.2 Error 错误
        • 2.3.1.3 Exception 异常的分类
      • 2.3.2 捕获异常
        • 2.3.2.1 try-catch 组合
        • 2.3.2.2 try-finally 组合
        • 2.3.2.3 try-catch-final 组合
      • 2.3.3 声明异常
        • 2.3.3.1 声明异常的关键字throws
        • 2.3.3.2 继承关系中的异常声明
        • 2.3.3.3 throw 抛出异常对象
      • 2.3.4 常见的简单异常的解决方法
        • 2.3.5 常见的异常类型
          • 2.3.5.1 RuntimeException类下的常见异常
          • 2.3.5.2 Checked类下的常见异常
      • 2.3.6 自定义异常
        • 2.3.6.1 自定义异常类的步骤
    • 2.4 常用类的基本用法
      • 2.4.1 包装类的基本用法
        • 2.4.1.1 为什么需要包装类（Wrapper Class）
        • 2.4.1.2 包装类和基本数据类型的对应关系
        • 2.4.1.3 包装类的继承关系
        • 2.4.1.4 包装类的基本操作
      • 2.4.2 自动装箱和拆箱
        • 2.4.2.1 自动装箱auto-boxing
        • 2.4.2.2 自动拆箱 unboxing
      • 2.4.3 Stringg 类底层分析_JDK源码分析
        • 2.4.3.1 String 的底层数据结构
      • 2.4.4 StringBuilder_StringBuffer用法_JDk底层源码分析
        • 2.4.4.1 可变的字符串
        • 2.4.4.2 StringBuilder与StringBuffer的常用方法的使用
      • 2.4.5 不可变字符序列和可变字符序列使用陷阱
      • 2.4.6 java.util.Date类
      • 2.4.7 DateFormat与SimpleDateFormat
      • 2.4.8 Calendar 日历类
        • 2.4.8.1 Calendar的类
        • 2.4.8.2 GregorianCalendar类的常用方法的使用
      • 2.4.9 Math类的常用方法_静态导入
        • 2.4.9.1 Math类的常用方法
        • 2.4.9.2 静态导入
      • 2.4.10 FIle类
        • 2.4.10.1 File类操作文件
        • 2.4.10.2 File类操作文件夹
        • 2.4.10.3 特别注意
      • 2.4.11 使用递归算法遍历目录结果_树结构
      • 2.4.12 枚举
        • 2.4.12.1 枚举的构建
        • 2.4.12.2 枚举的成员
        • 2.4.12.3 枚举的调用
        • 2.4.12.4 枚举的方法和其它成员变量的调用
        • 2.4.12.5 枚举成员与String类型的互转
        • 2.4.12.6 枚举类型在switch方法的使用
    • 2.5 容器（集合）
      • 2.5.1 基本概念_Collection_Set_List接口介绍
        • 2.5.1.1 容器的概念
        • 2.5.1.2 容器的分类
        • 2.5.1.3 容器框架(Collection)及其提供的主要方法
        • 2.5.1.4 集合的遍历
        • 2.5.1.5 各接口的特点
      • 2.5.2 迭代器及其使用
        • 2.5.2.1 **迭代器Iterator接口的概念及其方法**
        • 2.5.2.2 ListIterator迭代器：List接口下的容器所使用的的迭代器接口
      • 2.5.3 List集合_ArryaList
        • 2.5.3.1 ArrayList容器
        • 2.5.3.2 ArrayList的特有的方法详解
        • 2.5.3.3 ArrayList_JDK源码分析
      • 2.5.4 List集合_LinkedList容器
        • 2.5.4.1 链表的概念
        • 2.5.4.2 LinkedList的特有方法
        • 2.5.4.3 源码分析
      • 2.5.6 List集合_Vector容器
        • 2.5.6.1 相对ArrayList，Vctor中较特殊的方法：elements() 与 迭代器的比较
        • 2.5.6.2 为什么还要继续使用Enumeration接口
      • 2.5.7 Set接口_HashSet
        • 2.5.7.1 为啥要用HahSet?
        • 2.5.7.2 HashSet容器的底层数据结构
        • 2.5.7.3 HashSet容器的操作原理（引用地址[：资料引用地址](https://www.cnblogs.com/runwulingsheng/p/5208762.html)）
      • 2.5.8 HashMap的底层原理
      • 2.5.9 二叉树和红黑树
      • 2.5.10 TreeSet的使用_JDK源码分析
      • 2.5.11 泛型
        • 2.5.11.1 什么是泛型
        • 2.5.11.2 泛型的分类
      • 2.5.12 泛型的高级使用_容器中使用泛型
        • 2.5.12.1 泛型的高级使用
      • 2.5.15 容器体系框架总结
    • 2.6 IO流技术
      • 2.6.1 IO流的基本概念
      • 2.6.2 流概念细分和体系_四大抽象类
        • 2.6.2.1 流的分类
        • 2.6.2.2 IO流的四大抽象类
      • 2.6.3 文件字节流FileInputStream与FileOutputStream
        • 2.6.3.1 FileInputStream类的的使用
        • 2.6.3.2 FileOutputStream类的使用方法
      • 2.6.4 使用字节流实现文件复制
      • 2.6.5 文件字符流_FileWriter类与FileReader类
        • 2.6.5.1 FileReader类
        • 2.6.5.2 FileWriter类
      • 2.6.6 缓冲字节流_缓冲字符流
        • 2.6.6.1 缓冲字节流——BufferedInputStream
        • 2.6.6.2 缓冲字节流——BufferedOutputStream
        • 2.6.6.3 缓冲字符流——BufferedReader
        • 2.6.6.4 缓冲字符流——BufferedWriter
      • 2.6.7 转换流
        • 2.6.7.1 InputStreamReader
        • 2.6.7.3 OutputStreamWriter
      • 2.6.8 打印流
        • 2.6.8.1 打印流的概念
        • 2.6.8.2 字节打印流_PrintStream
        • 2.6.8.3 字符打印流_PrintWriter
      • 2.6.9 数据流
        • 2.6.9.1 DataInputStream和DataOutputStream
      • 2.6.10 对象流
        • 2.6.10.1 对象序列化（Serializable）
        • 2.6.10.2 为什么要对象序列化？
        • 2.6.10.3 对象序列化的条件
      • 2.6.11 序列化和反序列化
      • 2.6.12 文件夹的复制
        • 2.6.12.1 字节流和字符流的选择
        • 2.6.12.2 问题分解
      • 2.6.13 字节数组流
        • 2.6.13.1 字节数组流的特点
        • 2.6.13.2 ByteArrayInputStream
        • 2.6.13.3 ByteArrayOutputStream
      • 2.6.14 设计模式_装饰器模式
      • 2.6.15 IO体系总结
      • 2.6.16 Apache IOUtils的使用_Apache FileUtils的使用
    • 2.7 多线程技术
      • 2.7.1 多线程的基本概念
      • 2.7.2 通过继承Thread实现多线程
      • 2.7.3 通过接口实现Runnable接口实现多线程
      • 2.7.4 线程的生命周期
      • 2.7.5 获取线程基本信息的方法
      • 2.7.6 多线程的安全问题
      • 2.7.7 暂停线程执行sleep/yeild/stop
      • 2.7.8 线程的优先级问题
      • 2.7.9 线程同步——具体实现
      • 2.7.11 生产者消费者模式的实现1-基本功能实现
      • 2.7.12 生产者消费者模式的实现2-线程通信引入
    • 2.8 网络编程技术
      • 2.8.1 网络编程的基本概念
      • 2.8.2 端口和Socket含义
      • 2.8.3 TCP和UDP协议区别
      • 2.8.4 TCP协议数据传递细节
      • 2.8.5 UDP协议数据传递细节
      • 2.8.6 InetAddress类与InetSocketAddress类
      • 2.8.7 URL类
      • 2.8.8 基于TCP协议的Socket编程 模拟登陆服务器

2 第二阶段 JAVA深化和提高

2.1 面向对象深化

2.1.1 抽象类和抽象方法

2.1.1.1 抽象方法概念
  • 抽象类用abstract描述
  • 抽象类有构造方法、可以包含成员变量、成员方法、静态方法、final修饰的方法、抽象方法
  • final修饰的方法只能被子类调用，不允许被子类重写
  • 使用abstract修饰的方法是抽象方法，含有抽象方法的类必须是抽象类
  • 抽象方法只定义方法名，不能有方法体，如：
public abstract void hello();
  • 抽象类的子类必须实现父类中的抽象方法(也可以只是把方法写出来，但是方法体中可以不写东西)或该子类本身也是一个抽象方法
2.1.1.2 什么情况下使用抽象方法和抽象类？

通过抽象类，可以避免子类设计的随意性。通过抽象类，我们就可以做到严格限制子类的的设计，使子类之间更加通用。（程序的可拓展和可维护性）

  • 父类的名称比较抽象，创建的对象无意义，如：
Animal 动物类->设计为抽象类，定义一些抽象方法如sbstract void shout（）;方法

2.1.2 接口详解

2.1.2.1 接口的概念
  • 如果一个类中所有的方法均为abstract方法，那么这个类就可以声明为接口(接口不是类)
  • 新建一个接口类型，右键new->Interface
  • 接口使用interface而不是class修饰，是一种数据类型，引用数据类型
  • 接口中不允许定义构造方法
  • 接口可以被另一个接口继承，使用extends关键字
  • 同样一个接口中只允许有一个public修饰的接口，其它的为内部接口
2.1.2.2 接口中可以包含什么？
  • 抽象方法:
    Interface默认的方法就是抽象方法,默认被修饰为public abstract
  • 非抽象方法（jdk1.8新特性）
//必须使用default修饰
public default void method(){}
  • 属性常量：
    接口中的属性默认且只能是public final static 修饰的，且必须赋值
2.1.2.3 接口与类的关系
  • 类去实现接口中的实现方法：实现关系，需要使用关键字 implements
public class A implements MyInterface{}
  • 一个类既有继承关系又有实现关系:继承在前，实现在后，写法如：
public class A extends B implements C{}
  • 一个类，它的父类中有和所实现的接口完全相同的方法，他实现的方法是父类来的
  • 一个类，他的父类和实现接口中有同名的方法，传递的参数不相同，那么对这个类要求他对父类和所实现的接口实现方法的重载/重写（在这个子类里写）

2.1.3 接口的特征_使用接口的意义

2.1.3.1 接口的传递性

如果接口B继承了接口A，而接口中有一个抽象方法method();那么B的一个实现将拥有且必须实现这个抽闲方法method()

public interface InterfaceA{public abstract void method();
}interface InterfaceB extends InterfaceA{}class Iml implements InterfaceB{@Overridepublic abstract void method{//TODO balabalabala}
}
2.1.3.2 接口的继承性（多继承）

一个类可以继承多个接口，格式如下

class ClassExample implements InterfaceA,InterfaceB{ //多个接口之间使用逗号分开}
2.1.3.3 使用接口的意义_接口实现多态的步骤
  • 意义：可以实现设计与实现的分离，抽象出N多不同类的共同点
举例：飞机，鸟，炮弹，宇宙飞船这几种物体
继承：is-a 关系，三角形is a 几何图形（实例）
接口：has-a 关系 鸟has a飞行功能，飞机has a 飞行功能，我们就可以用接口的方式来定义“飞”这种能力，让其他类去实现
//接口体现的是一种能力
  • 接口实现多态的步骤
1.编写接口
2.实现类实现接口中的方法(实现方法不加abstract)
3.接口（类型）new 实现类对象
这就是面向接口的编程
public interface Fly{void flying();
}
class Bird implements  Fly{@overridepublic  void flying{System.out.println("小鸟在飞");}
}
class Plane implements Fly{@overridepublic void flying{System.out.println("飞机在飞");}
}class Dog implements Fly{@overridepublic void flying{System.out.println("小狗被踢飞");}
}
//以下代码在一个测试类中
public static void main(String args[]){Fly bird = new Bird;bird.flying();Fly puppy =new Dog;puppy.flying();Fly airPlane =new Plane();airPlane.flying();
}

2.1.4 内部类

2.1.4.1 内部类的概念
  • 内部类是写在一个外部类中的类，他们的关系是嵌套关系
2.1.4.2 内部类的特点
  • 内部类可以直接访问外部类的成员，反之则不行
  • 内部类作为外部类的成员，可声明为private、default、protect和public
  • 内部类定义在外部类中不可访问的属性，这样就在外部类中实现了此外部类的private还要下的访问权限
  • 脱离了外部类，无法访问内部类
2.1.4.3 内部类的优缺点
  • 优点：内部类可以直接访问外部类的私有属性
  • 缺点：破坏了类的结构
2.1.4.4 内部类的访问
  • 通过实例化一个外部类的对象，再实例化一个内部类的对象，来访问内部类的属性。
public class Face{private String shape="瓜子脸";public class Nose{private String shape="高鼻梁";public void breath(){System.out.println("鼻子在呼吸");}}
//测试类
public void static main(String args[]){Face f = new Face();Nose n = f.new Nose();n.breath();
}
}
  • 静态内部类的访问使用如下格式访问
外部类名.内部类名  //对!就是这样的
当要实例一个静态内部类的对象时：
外部类名.内部类名 实例名 = new 外部内名.内部类名(); //就是这样子
2.1.4.5 内部类访问外部类
  • 当内部类拥有和外部类一样的成员变量时，在内部类中访问外部类的变量需要按这样的格式访问
外部类名.this.成员变量
  • 当内部类被static修饰时，内部类不能访问没有带static修饰的外部类的属性
  • 如果在内部类中写了一个静态方法，那么这个内部类必须被修饰为static的
2.1.4.6 定义在方法中的内部类

定义在方法中的内部能，只能在方法中去使用，如下

public void Hello(){int a=10;class Inner{public void kk(){System.out.println("a="+a);}}new Inner().kk();//只能在方法体中调用方法中的内部类，对于方法外，这个内部类毫无意义
}
2.1.4.7 匿名内部类（没有名字的内部类）
  • 存在的前提是要继承或实现一个接口（最多一个接口。比较常见的是在图形界面编程中使用）
//以匿名继承内部类举例public abstract class Father{
public abstract void dream() ;
}
class Test{public static void main(String[] args){Father f = new Father(){         //这个部分就是匿名内部类@Overridepublic void dream() {System.out.println("欧耶实现了父亲的梦想！");}};f.dream();//调用内部内的方法}
}

2.1.5 String类常用方法_API文档阅读

2.1.5.1 String 类的定义
  • String类相当于char类的数组，数组长度一旦创建不可更改，value的数组还是用了final修饰
String str = "abc";
str = "def"; //在这里字符串并没有被改变，改变的只是指向它的地址
//在常量池中，有两个字符串常量"abc" 与"def"，刚开始时前者的地址指向str，执行第二句后，变成了后者的地址指向str
  相关解决方案

代码迷 - 您身边的软件异常，代码异常，编程异常助手（发现，解决，分享）
Copyright © 2009-2013 DAIMAMI.COM. All rights reserved.