Java基础学习_2

=Start=

缘由:

作为一个Java编程新手,整理一下在学习《Java核心技术 卷I:基础知识》时的笔记,方便以后回顾和参考。

正文:

参考解答:
  • 封装:Java中所有的代码都放在了类中,从形式上来看只是将变量和方法放在了一起,但是推荐将所有的变量都用private修饰,只允许类内部的方法进行修改,这样一层封装确保了数据不会被随意修改,使大型项目的排错更容易。
  • 继承:可以通过继承这种方式在超类的基础上丰富子类的功能。同时也达到了代码复用的效果。
  • 重载:同一个方法名,根据参数的不同,由编译器来决定实际该调用哪个方法。
  • 多态:一个Employee类变量除了可以指代Employee对象之外,还可以指代基于Employee类派生出的Manager类的变量。
第1章 Java程序设计概述
  • ……
  • 1.3 Java applet与Internet
    • 在网页中运行的Java程序被称为applet
  • 1.4 Java发展简史
  • ……
第2章 Java程序设计环境
  • ……
  • 2.3 使用命令行工具
    • javac和java
  • ……
  • 2.6 建立并运行applet
第3章 Java的基本程序设计结构
  • 3.1 一个简单的Java应用程序
    • Java对大小写敏感
  • 3.2 注释
  • ……
  • 3.6 字符串
    • 3.6.1 子串
    • 3.6.2 拼接
    • 3.6.3 不可变字符串
    • 3.6.4 检测字符串是否相等
    • 3.6.5 空串与Null串
    • ……
    • 3.6.9 构建字符串
  • 3.7 输入输出
    • 3.7.1 读取输入
    • 3.7.2 格式化输出
    • 3.7.3 文件输入与输出
  • ……
  • 3.10 数组
    • 3.10.1 for each循环
    • 3.10.2 数组初始化以及匿名数组
    • 3.10.3 数组拷贝
    • 3.10.4 命令行参数
  • ……
第4章 对象与类
  • 4.1 面向对象程序设计概述
    • 面向对象的程序是由对象组成的,每个对象包含对用户公开的特定功能部分和隐藏的实现部分。
    • 在OOP中,不必关心对象的具体实现,只要能够满足用户的需求即可。
    • 4.1.1 类
      • 用Java编写的所有代码都位于某个类的内部
      • 在扩展一个已有的类时,这个扩展后的新类具有所扩展的类的全部属性和方法
    • 4.1.2 对象
    • 4.1.3 识别类
      • 首先从设计类开始,然后再往每个类中添加方法。
      • 识别类的简单规则是:在分析问题的过程中寻找名词,而方法对应着动词。
    • 4.1.4 类之间的关系
      • 依赖(”uses-a”):应该尽可能的将相互依赖的类减至最少!!!
      • 聚合(”has-a”)
      • 继承(”is-a”)
  • 4.2 使用预定义类
    • 4.2.1 对象与对象变量
      • 构造器是一种特殊的方法,用来构造并初始化对象。构造器的名字应该与类名相同。
      • 一个对象变量并没有实际包含一个对象,而仅仅引用一个对象。
      • 在Java中,任何对象变量的值都是对存储在另外一个地方的一个对象的引用。
    • 4.2.2 Java类库中的Gregorian-Calendar类
    • 4.2.3 更改器方法与访问器方法
  • 4.3 用户自定义类
    • 要想创建一个完整的程序,应该将若干类组合在一起,其中只有一个类有main方法。
    • 类文件(.java文件)名必须与public类的名字相匹配。
    • 在一个源文件中,只能有一个公有类,但可以有任意数目的非公有类。
    • 4.3.1 Employee类
      • 域(变量)
      • 构造函数
      • 方法
    • 4.3.2 多个源文件的使用
    • 4.3.3 剖析Employee类
    • 4.3.4 从构造器开始
      • 构造器与类同名;
      • 每个类可以有一个以上的构造器;
      • 构造器可以有0个、1个或多个参数;
      • 构造器没有返回值;
      • 构造器总是伴随着new操作符一起调用。
    • 4.3.5 隐式参数与显式参数
      • 第一个参数称为隐式(implicit)参数——关键字this,隐式参数没有出现在方法声明中。
    • 4.3.6 封装的优点
      • 第一:限定了可以修改内部变量的方法;
      • 第二:更改器方法可以执行错误检查。
    • 4.3.7 基于类的访问权限
    • 4.3.8 私有方法
    • 4.3.9 final实例域
  • 4.4 静态域与静态方法
    • 4.4.1 静态域(静态变量)
    • 4.4.2 静态常量
    • 4.4.3 静态方法
    • 4.4.4 工厂方法
    • 4.4.5 main方法
  • 4.5 方法参数
    • Java总是采用按值调用(call by value)。
    • Java对对象采用的不是引用调用,实际上,对象引用进行的是值传递。
  • 4.6 对象构造
    • 4.6.1 重载
      • 如果有多个方法有相同的名字、不同的参数,便产生了重载。
    • 4.6.2 默认域初始化
    • 4.6.3 无参数的构造器
    • 4.6.4 显式域初始化
    • 4.6.5 参数名
    • 4.6.6 调用另一个构造器
    • 4.6.7 初始化块
    • 4.6.8 对象析构与finalize方法
  • 4.7 包
    • Java使用包(package)将类组织起来。使用包的主要原因是确保类名的唯一性。
    • 4.7.1 类的导入
    • 4.7.2 静态导入
    • 4.7.3 将类放入包中
      • 如果没有在源文件中放置package语句,这个源文件中的类就被放置在一个默认包(default package)中。
    • 4.7.4 包作用域
  • 4.8 类路径
  • 4.9 文档注释
    • 4.9.1 注释的插入(javadoc)
    • 4.9.2 类注释
    • 4.9.3 方法注释
    • 4.9.4 域注释
    • 4.9.5 通用注释
    • 4.9.6 包与概述注释
    • 4.9.7 注释的抽取
  • 4.10 类设计技巧
    • 一定要保证数据私有(private)
    • 一定要对数据初始化
第5章 继承
  • 利用继承,人们可以基于已存在的类构造一个新类。继承已存在的类就是复用(继承)这些类的方法和域。
  • 5.1 类、超类和子类
    • 关键字extends表示继承。已存在的类称为 超类(super class)、基类(base class)或父类(parent class);新类称为 子类(sub class)、派生类(derived class)或孩子类(child class)。
    • 一个对象变量可以指示多种实际类型的现象被称为多态(polymorphism)。
    • 在运行时能够自动的选择调用哪个方法的现象被称为动态绑定(dynamic binding)。
    • 5.1.1 继承层次
    • 5.1.2 多态
      • 在Java中,对象变量是多态的。一个Employee变量既可以引用一个Employee类对象,也可以引用一个Employee类的任何一个子类的对象(例如:Manager、Executive等)
    • 5.1.3 动态绑定
    • 5.1.4 阻止继承:final类和方法
      • 不允许扩展的类被称为final类。
      • 类中的特定方法也可以被声明为final。如果这样做,子类就不能覆盖这个方法(final类中的所有方法自动地成为final方法)。
      • 将方法或类声明为final的主要目的是:确保它们不会在子类中改变语义。
    • 5.1.5 强制类型转换
    • 5.1.6 抽象类
      • 为了提高程序的清晰度,包含一个或多个抽象方法的类本身必须被声明为抽象的。
      • 抽象方法充当着占位的角色,它们的具体实现在子类中。
      • 类即使不含抽象方法,也可以将类声明为抽象类。抽象类不能被实例化。(实例化可以简单的认为是用new关键字进行的)
    • 5.1.7 受保护访问
  • 5.2 Object:所有类的超类
    • Object类是Java中所有类的始祖,在Java中每个类都是由它扩展而来的。
    • 5.2.1 equals方法
    • 5.2.2 相等测试与继承
    • 5.2.3 hashCode方法
      • equals与hashCode的定义必须一致:如果 x.equals(y) 返回 true ,那么 x.hashCode() 就必须与 y.hashCode() 具有相同的值。
    • 5.2.4 toString方法
  • 5.3 泛型数组列表
    • ArrayList是一个采用类型参数(type parameter)的泛型类(generic class)。
    • 5.3.1 访问数组列表元素
    • 5.3.2 类型化与原始数组列表的兼容性
  • 5.4 对象包装器与自动装箱
    • 有时,需要将 int 这样的基本类型转换为对象。所有的基本类型都有一个与之对应的类。例如,Integer类对应基本类型int。通常,这些类被称为包装器(wrapper)。
    • 比如 list.add(3) 这个调用将自动的变换成 list.add(Integer.valueOf(3)) ,这种变换被称为自动装箱(auto boxing)。
  • 5.5 参数数量可变的方法
    • System.out.printf()
  • 5.6 枚举类
  • 5.7 反射
    • 反射是指在程序运行期间发现更多的类及其属性的能力。
    • 5.7.1 Class类
      • Employee e; Class cl = e.getClass();
    • 5.7.2 捕获异常
    • 5.7.3 利用反射分析类的能力
    • 5.7.4 在运行时使用反射分析对象
    • 5.7.5 使用反射编写泛型数组代码
    • 5.7.6 调用任意方法
  • 5.8 继承设计的技巧
    • 将公共操作和域放在超类
    • 不要使用受保护的域
    • 使用继承实现 “is-a” 关系
    • 使用多态,而非类型信息
    • 不要过多的使用反射
第6章 接口与内部类
  • 首先,接口是一种技术;其次,这种技术主要用来描述类具有什么功能,而并不给出每个功能的具体实现。
  • 6.1 接口
    • 在Java中,接口不是类,而是对类的一组需求描述,这些类要遵从接口描述的统一格式进行定义。
    • 6.1.1 接口的特性
      • 接口不是类,尤其不能使用new运算符实例化一个接口!
      • 尽管每个类只能够拥有一个超类,但却可以实现多个接口。这就位定义类的行为提供了极大的灵活性。
    • 6.1.2 接口与抽象类
      • 为什么有了抽象类之后还要有接口?因为用抽象类表示通用属性存在这样一个问题:每个类只能扩展于一个类。尽管每个类只能够拥有一个超类,但却可以实现多个接口,这样类的定义就比较灵活。
  • 6.2 对象克隆
  • 6.3 接口与回调
    • 回调(callback)是一种常见的程序设计模式。在这种模式中,可以指出某个特定事件发生时该采取的动作。
  • 6.4 内部类
    • 6.4.1 使用内部类访问对象状态
    • 6.4.2 内部类的特殊语法规则
    • 6.4.3 内部类是否有用、必要和安全
    • 6.4.4 局部内部类
    • 6.4.5 由外部方法访问final变量
    • 6.4.6 匿名内部类
    • 6.4.7 静态内部类
  • 6.5 代理
    • 利用代理可以在运行时创建一个实现了一组给定接口的新类。这种功能只有在编译时无法确定需要实现哪个接口时才有必要使用。
    • 所有的代理类都扩展于Proxy类。
    • 代理类一定是public和final。
第10章 部署应用程序和applet
  • 10.1 JAR文件
    • 10.1.1 清单文件
      • 除了类文件、图像和其它资源外,每个jar文件还包含一个用于描述归档特征的清单文件
      • 清单文件被命名为MANIFEST.MF,它位于jar文件的一个特殊 META-INF 子目录中
    • 10.1.2 可运行JAR文件
    • 10.1.3 资源
    • 10.1.4 密封
  • 10.2 Java Web Start
    • 10.2.1 沙箱
    • 10.2.2 签名代码
    • 10.2.3 JNLP API
  • 10.3 applet
    • 10.3.1 一个简单的applet
      • applet是一种包含在HTML网页中的Java应用程序
    • 10.3.2 applet的HTML标记和属性
    • 10.3.3 object标记
    • 10.3.4 使用参数向applet传递信息
    • 10.3.5 访问图像和音频文件
    • 10.3.6 applet上下文
  • 10.4 应用程序首选项存储
    • 10.4.1 属性映射
    • 10.4.2 Preferences API
第11章 异常、断言、日志和调试
  • 11.1 处理错误
    • 11.1.1 异常分类
      • 在Java中,异常对象都是派生于Throwable类的一个实例
      • 所有的异常都是由Throwable继承而来,但在下一层立即分解为两个分支:Error和Exception
      • Error类层次结构描述了Java运行时系统的内部错误和资源耗尽错误,应用程序不应该抛出这种类型的对象,如果遇到了,除了通告给用户,并尽力使程序安全地终止之外,再也无能为力了;
      • Exception层次结构是在编码时需要重点关注的,它又分为两个分支:一个是RuntimeException(如果出现RuntimeException异常,那么就一定是你的问题),另一个是其它异常;
      • 由程序错误导致的异常属于RuntimeException,包含下面几种情况:
        • 错误的类型转换
        • 数组访问越界
        • 访问空指针
      • Java语言规范将派生于Error类或RuntimeException类的所有异常称为「未检查异常」,所有其它的异常称为已检查异常。
    • 11.1.2 声明已检查异常
      • 一个方法不仅需要告诉编译器将要返回什么值,还要告诉编译器有可能发生什么错误。
      • 方法应该在其首部声明所有可能抛出的异常。这样可以从首部反映出这个方法可能抛出哪类已检查异常。
        • public FileInputStream(String name) throws FileNotFoundException, EOFException
        • public FileInputStream(String name) throws Exception
      • 总之,一个方法必须声明所有可能抛出的「已检查异常」,而「未检查异常」要么不可控制(Error),要么就应该避免发生(RuntimeException)。
    • 11.1.3 如何抛出异常
      • throw new EOFException();
      • EOFException e = new EOFException(); throw e;
    • 11.1.4 创建异常类
      • 定义一个派生于Exception的类,或者派生于Exception子类的类。
  • 11.2 捕获异常
    • 如果某个异常发生的时候没有在任何地方进行捕获,那程序就会终止执行,并在控制台上打印出异常信息,其中包括异常的类型和堆栈的内容。
    • 如果调用了一个抛出已检查异常的方法,就必须对它进行处理,或者将它继续进行传递。
    • 11.2.1 捕获多个异常
    • 11.2.2 再次抛出异常与异常链
    • 11.2.3 finally子句
    • 11.2.4 带资源的try语句
    • 11.2.5 分析堆栈跟踪元素
  • 11.3 使用异常机制的技巧
    • 异常处理不能替代简单的测试
    • 不要过分的细化异常
    • 利用异常层次结构
    • 不要压制异常
    • 在检测错误时,「苛刻」要比放任更好
    • 不要羞于传递异常
  • 11.4 使用断言
    • 11.4.1 启用和禁用断言
    • 11.4.2 使用断言完成参数检查
    • 11.4.3 为文档假设使用断言
  • 11.5 记录日志(Logger
    • 11.5.1 基本日志
    • 11.5.2 高级日志
    • 11.5.3 修改日志管理器配置
    • 11.5.4 本地化
    • 11.5.5 处理器
    • 11.5.6 过滤器
    • 11.5.7 格式化器
    • 11.5.8 日志记录说明
  • 11.6 调试技巧
    • 打印变量的内容System.out.println()
    • 在每一个类中放置一个main方法,这样就可以对每一个类进行单元测试
    • JUnit
    • 日志代理(logging proxy)
    • 利用Throwable类提供的printStackTrace方法,可以从任何一个异常对象中获得堆栈情况
    • 利用printStackTrace(PrintWriter s)将堆栈跟踪发送到一个文件中
    • 将错误信息单独保存在一个文件在(java myprogram 2>errors.txt)
    • 观察类的加载过程(在启动时添加 -verbose 选项)
    • 使用-Xlint选项对代码问题进行检查
    • 使用jconsole
    • 使用jmap
    • 使用-Xprof选项
  • 11.7 GUI程序排错技巧
  • 11.8 使用调试器
    • 断点
    • 单步跟踪
参考链接:

=END=

声明: 除非注明,ixyzero.com文章均为原创,转载请以链接形式标明本文地址,谢谢!
https://ixyzero.com/blog/archives/3811.html

《Java基础学习_2》上有17条评论

  1. JAVA字符串格式化-String.format()的使用
    http://blog.csdn.net/lonely_fireworks/article/details/7962171/
    Java魔法堂:String.format详解
    http://www.cnblogs.com/fsjohnhuang/p/4094777.html

    Java String.format()的对于int,long
    http://bosshida.iteye.com/blog/898409
    http://blueram.iteye.com/blog/441683

    今天用String.format(format, args)方法,

    format: "this num %l is long",args是一个long数

    但运行有错,抛java.util.UnknownFormatConversionException,查了一下才知道,

    原来%d是包括了int,long,byte等等类型了,

    format:"this num %d is long"就行了。

  2. java中,如何计算一个方法所耗费的时间秒数?
    http://blog.csdn.net/wer724853863/article/details/52232808

    long startTime=System.currentTimeMillis();//记录开始时间

    method();//此处为你调用的方法

    long endTime=System.currentTimeMillis();//记录结束时间
    System.out.println(String.format("执行时间:%d ms", endTime-startTime));
    float excTime=(float)(endTime-startTime)/1000;
    System.out.println("执行时间:"+excTime+"s");

  3. 一名3年工作经验的java程序员应该具备的技能
    http://dataunion.org/32518.html

    1、基本语法
    2、集合
    3、框架
    4、数据库
    5、Web方面的一些问题
    6、数据结构和算法分析
    7、Java虚拟机
    8、设计模式
    9、多线程

  4. Java进阶(一)Annotation(注解)
    https://www.jasongj.com/2016/01/17/Java1_%E6%B3%A8%E8%A7%A3Annotation/
    Java进阶(二)当我们说线程安全时,到底在说什么
    https://www.jasongj.com/java/thread_safe
    Java进阶(三)多线程开发关键技术
    https://www.jasongj.com/java/multi_thread
    Java进阶(四)线程间通信方式对比
    https://www.jasongj.com/java/thread_communication
    Java进阶(五)Java I/O模型从BIO到NIO和Reactor模式
    https://www.jasongj.com/java/nio_reactor/
    Java进阶(六)从ConcurrentHashMap的演进看Java多线程核心技术
    https://www.jasongj.com/java/concurrenthashmap/
    Java进阶(七)正确理解Thread Local的原理与适用场景
    https://www.jasongj.com/java/threadlocal/

  5. java注解详解
    https://www.cnblogs.com/yiwangzhibujian/p/7353270.html

    一、前言
    1.1 示例
    1.2 再议注解
    二、注解的属性
    2.1 注解位置
    2.2 注解生命周期
    三、自定义注解
    3.1 注解定义
    3.2 注解使用
    四、jdk已有注解
    五、总结
      说到底,注解的使用方还是很简单的,难点在于提供给你注解的人是怎么通过注解去达到他的目的的。如果你设计一个框架并提供注解给人使用,那么你就要精通反射。不过一般情况下是很少遇到需要自定义反射的场景,除非你设计一个中间框架,别人通过你的框架来调用自己实现的类,就像Spring一样。

  6. Java 注解详解 (annotation)
    https://blog.csdn.net/suifeng3051/article/details/51801018

    什么是java注解
    Java注解的目的
    注解基本概念
      注解的构成
      注解的位置
    一些常用的内置注解
      Deprecated注解
      Override注解
      SuppressWarnings
    创建自定义注解
      定义一个自定义注解
      给注解元素设置默认值
      两个元注解Retention和Target
    通过反射获得Java注解信息
      获取类的注解信息
      获取方法的注解信息
      获取参数的注解信息
      获取字段的注解信息

  7. Java 异常设计最佳实践
    https://blog.csdn.net/suifeng3051/article/details/52126895

    关于异常
    Java 异常基本概念
      Java 异常体系结构
      检查异常与非检查异常
    检查异常 or 非检查异常
      尽量少使用检查异常
      异常转译
    异常的架构设计
      从系统不同角度看异常
      设计一个统一的异常处理类
      异常层次定义

  8. Java反射机制
    https://juejin.im/post/5b7e708b51882542b83d70c9

    目录
    一、Java反射机制概述
    二、反射的作用
    三、理解Class类和类类型
      3.1 类是对象吗
      3.2 Class的对象的获取
        第一种方法
        第二种方法
        第三种方法
    四、动态加载类
    五、获取类的信息
      5.1 获取类的构造函数
        1、单独获取某个构造函数
        2、获取所有的构造函数
      5.2 获取类的成员方法
        1、单独获取某一个方法
        如何调用获取到的方法
        2、获取类中所有成员方法的信息
        注意:
      5.3 获取类的成员变量
        1、单独获取某个成员变量
        2、获取所有的成员变量
      5.4 获取类、方法、属性的修饰域
      5.5 通过反射获取私有成员变量和私有方法
    六、关于反射的一些高级话题
      Android编译期问题
      软件的解耦合
      反射安全
    七、通过反射了解集合泛型的本质

发表评论

电子邮件地址不会被公开。 必填项已用*标注