一、  Java SE 开篇

1.  Java 基本数据类型及其对应的包装类

  1. 基本数据类型 对应的包装类
  2. * byte Byte
  3. * boolean Boolean
  4. * char Character
  5. * int Integer
  6. * long Long
  7. * short Short
  8. * float Float
  9. * double Double

1.2  自动装箱和自动拆箱

  1. // 1.自动装箱:
  2. // 基本类型自动封装到对应的包装类对象中,如:
  3. Integer i = 100;
  4. // 本质上编译器编译时添加了:
  5. Integer i = new Integer(100);
  6.  
  7. // 2.自动拆箱:
  8. // 包装类对象自动转换成对应的基本类型数据,如:
  9. int a = new Integer(100);
  10. // 本质上编译器编译时添加了:
  11. int a = new Integer(100).intValue();

2.  Java 封装

  1. 同一个类 同一个包 子类 所有类
  2. private
  3. default
  4. protected
  5. public
  6.  
  7. 封装要点:
  8. * 1.属性成员一般使用 private
  9. * 2.提供相应的 getter/setter 方法来访问相关属性,这些方法通常是 public(注意:boolean 变量的 getter 方法是用: is 开头!)
  10. * 3.只用于本类的辅助性方法用 private,希望其他类能够调用的方法使用 public

3.  关键字

  1. 1. static 用于声明静态方法和静态成员
  2. 注意:在 static 方法中可直接访问 static 声明的成员;不可以直接访问非 static 的成员,只能先实例化对象才能进行访问!
  3.  
  4. 2. final 通常用于声明常量
  5. 注意:不能继承用 final 修饰的类,不能对用 final 定义的方法进行重写!
  6.  
  7. 3. this 调用本类中的属性和方法
  8. 注意:this 不建议用于调用本类中用 static 声明的属性和方法上; this();必须位于重载的构造方法中的第一句,来调用无参构造器!
  9.  
  10. 4. super 是对直接父类对象的引用。可以通过 super 来访问父类中被子类覆盖的方法和属性。任何类的构造函数中,Java 默认都会调用 super();
  11. 注意:super(); 必须位于子类构造方法的第一句!
  12.  
  13. 5. instanceof 用于判断一个对象是否是指定类的一个实例,用法:boolean ins = object instanceof class;
  14. 注意:object 必须是对象的引用,不能是基本数据类型

4.  构造器

  1. 构造器,又称构造方法,是一种特殊的方法
  2. * 格式:public + 类名(){}
  3. * 1.通过 new 关键字调用
  4. * 2.构造方法名必须和类名一致!
  5. * 3.作用:构造该类的对象,经常用来初始化对象的属性
  6. * 4.不能定义返回值类型,也不能在里面使用 return * 5.构造方法也可以重载

5.  抽象类

  1. 抽象类 abstract,为所有子类提供一个通用的模板
  2. * 要点:
  3. * 1.含有抽象方法的类一定是抽象类,所以在定义时必须定义成抽象类!
  4. * 2.抽象类不能实例化,即不能用 new 来实例化抽象类
  5. * 3.抽象类只能用来被继承 extends
  6. * 4.抽象方法必须通过子类重写
  7. * 5.抽象类中可以包含属性,非抽象方法,构造方法等
  8.  
  9. public abstract class Animal {
  10. public static final int MIN_VALUE = 100;
  11. private String name;
  12. public abstract void fun();
  13. public Animal(){
  14. System.out.println("创建一个动物对象");
  15. }
  16. public void hello(){
  17. System.out.println("hello,abstract!");
  18. }
  19. }

6.  接口

  1. 接口 interface
  2. * 接口比抽象类更加的“抽象”,意义在于规范设计和实现代码分离
  3. * 接口中只有:常量,抽象方法!
  4. * 接口能被子类实现 implements
  5. * 普通类只能单继承,但是接口支持多继承!
  6. * 不能实例化,即不能用 new 来实例化
  7.  
  8. public interface MyInterface {
  9. // 接口中只有:常量,抽象方法
  10. // 定义常量:public static final ...,可省略
  11. String MAX_GREAD = "BOSS";
  12. int MAX_SPEED = 100;
  13. // 定义方法:public abstract ...,可省略
  14. void test01();
  15. int test02(int a, int b);
  16. }
  17.  
  18. // 接口支持多继承
  19. interface Interface03 extends Interface01, Interface02 ...{
  20. }

7.  多态性

  1. 1. 多态性是 OOP 中的一个重要特性,主要是用来实现动态联编的。换句话说,就是程序最终状态只有在执行过程中才能被决定,而不是在编译期间就决定,这对于大型系统来说能提高系统的灵活性和扩展性
  2. 2. 多态的存在要有 3 个必要条件:
  3. a.要有继承 b.要有方法重写 c.父类引用指向子类对象
  4.  
  5. public class Fruit {
  6. private String color;
  7. public void name(){
  8. System.out.println("fruit");
  9. }
  10. }
  11. public class Apple extends Fruit{ // 继承
  12. @Override
  13. public void name(){ // 重写父类方法
  14. System.out.println("apple");
  15. }
  16. }
  17. public class Test{
  18. public static void main(String[] args) {
  19. Fruit f = new Apple(); // 父类引用指向子类对象
  20. f.name();
  21. }
  22. } // 运行结果:apple

8.  内部类

  1. 内部类分为静态内部类和动态内部类
  2. * 1.内部类使用的场合:由于内部类提供了更好的封装性,并且可以很方便的访问外部类的属性。所以,通常在只为所在外部类提供服务的情况下优先使用内部类
  3. * 2.内部类被当成其所在外部类的内部属性
  4. * 3.动态内部类可以直接访问外部类的私有属性和方法;静态内部类只能直接访问外部类的静态属性和静态方法,访问非静态成员需要实例化外部类对象
  5. * 4.内部类不允许除了其所在的外部类以外的其他类直接访问
  6.  
  7. public class TestInnerclass {
  8. public static void main(String[] args) {
  9. // 其他类访问动态内部类,先实例化外部类对象,再实例化动态内部类
  10. World w = new World();
  11. Human human = w.new Human();
  12. human.hello();
  13.  
  14. // 其他类访问静态内部类,直接实例化静态内部类对象
  15. Animal animal = new World.Animal();
  16. animal.hello();
  17. }
  18. }
  19. public class World{
  20. private String hi = "hello";
  21. public void say(String name){
  22. System.out.println("hello,"+name);
  23. }
  24. // 动态内部类
  25. class Human{
  26. String name = "man";
  27. void hello(){
  28. //动态内部类直接访问所在外部类的私有属性和方法
  29. System.out.println(hi);
  30. say(name);
  31. }
  32. }
  33. // 静态内部类
  34. static class Animal{
  35. String name = "animal";
  36. void hello(){
  37. //静态内部类访问所在外部类的非静态属性和非静态方法必须先实例化外部类对象
  38. World w = new World();
  39. System.out.println(w.hi);
  40. w.say(name);
  41. }
  42. }
  43. }

9.  匿名内部类

  1. 匿名内部类,一种特殊的内部类,是一个没有显式的名字的内部类
  2. * 1.匿名内部类会隐式的继承一个类或者实现一个接口
  3. * 2.常用于在多线程的实现上,因为要实现多线程必须继承 Thread 类或是实现 Runnable 接口
  4. * 3.匿名内部类只能访问 final 修饰的所在外部类变量及方法参数
  5. * 4.接口本身是不可以通过 new 来实例化的,其实匿名内部类是对接口的实现类的实例化
  6.  
  7. // Thread 类的匿名内部类
  8. public class Demo {
  9. public static void main(String[] args) {
  10. Thread t = new Thread() {
  11. public void run() {
  12. for (int i = 1; i <= 6; i++) {
  13. System.out.print(i + " ");
  14. }
  15. }
  16. };
  17. t.start();
  18. }
  19. }
  20.  
  21. // Runnable 接口的匿名内部类
  22. public class Demo {
  23. public static void main(String[] args) {
  24. Runnable r = new Runnable() {
  25. public void run() {
  26. for (int i = 1; i <= 6; i++) {
  27. System.out.print(i + " ");
  28. }
  29. }
  30. };
  31. Thread t = new Thread(r);
  32. t.start();
  33. }
  34. }
  35. //运行结果:1 2 3 4 5 6

10.  异常处理

  1. 1. JDK 中定义了很多异常类,所有的异常对象都是派生于 Throwable 类的一个实例,如果内置的异常类不能满足需要,还可以创建自己的异常类
  2. * Throwable
  3. * / \
  4. * Error Exception
  5. * / / \
  6. * Unchecked Exception Checked Exception Runtime Exception
  7. * |
  8. * Unchecked Exception
  9.  
  10. 2. 使用异常机制建议:
  11. * 1.只在异常情况下使用异常机制,避免使用异常处理代替错误处理,这样会降低程序的清晰性,并且效率低
  12. * 2.应该将整个任务包装在一个 try 语句中,不要进行小颗粒的异常处理,即一个 try 语句可以伴随多个 catch,不要一个 catch 一个 try
  13. * 3.异常往往在高层处理
  14.  
  15. 3. Checked exception 异常的处理方法之一:捕获异常处理,try{...}catch(Exception e){e.printStackTrace();}finally{...}
  16. * “亲自处理”
  17. *
  18. * 1.try 语句指定代码就是一次捕获并处理的范围
  19. * 2.每个 try 语句可以伴随一个或多个 catch 语句,用于处理可能产生的不同类型异常
  20. * 3.当异常处理的代码执行后,是不会回到 try 语句去执行尚未执行的代码
  21. *
  22. * 4.catch 常用的方法:
  23. * e.printStackTrace();// 用来跟踪异常事件发生时堆栈的内容
  24. * e.getMessage();// 只显示产生异常的原因,但不显示异常的类名
  25. * e.toString();// 显示异常的原因和异常的类名
  26. * 这些方法均继承自 Throwable
  27. *
  28. * 5.catch 捕获异常的顺序:如果异常类之间有继承关系,在顺序安排上需注意:
  29. * 越是顶层的类,越放在下面,即越是父类,越放下面
  30. * 如:IOException FileNotFoundException 的父类,如果父类在前面是不会去 catch 子类异常
  31. * 再不然就直接把多余的 catch 省掉
  32. *
  33. * 6.finally 指定段的语句,不管是否发生异常,都必须执行!
  34. * 通常通过 finally 来“关闭程序块已打开的资源”,比如:关闭IO流、释放数据库连接等
  35. *
  36. * 7.执行顺序:trycatchreturn ——> 执行 finally
  37. * 8.由执行顺序可知:不要在 finally 中使用 return 语句,因为会覆盖掉 try 语句中的存在的 return 语句
  38.  
  39. 4. Checked exception 异常的处理方法之二:声明异常,throws * “谁调我,谁处理”
  40. *
  41. * 1. Checked exception 产生时,不一定要立刻处理它,可以把异常 throws 出去
  42. * 2.当一个方法出现多个 Checked exception,就必须在方法首部列出所有异常,之间用逗号隔开
  43. *
  44. * 3.@Override 方法重写时声明异常的规则:
  45. * 1.父类方法没有声明异常,子类方法也不能声明异常;
  46. * 2.子类方法不可抛出父类方法抛出异常类的父类或更上层类;
  47. * 3.子类方法抛出的 异常类型的数目 不可以比父类方法抛出的还多(指不同异常类型个数)
  48.  
  49. 5. Checked exception 异常的处理方法之三:手动抛出异常,throw
  50. * 对于一个已经存在的异常类,手动抛出异常对象过程如下:
  51. * 1.找到一个合适的异常类
  52. * 2.创建一个该类的对象
  53. * 3.将异常对象抛出
  54.  
  55. File f = new File("C:/a.txt");
  56. if(!f.exists){
  57. try{
  58. throw new FileNotFoundException("File can't be found!");
  59. }catch(FileNotFoundException e){
  60. e.printStackTrace();
  61. }
  62. }
  63.  
  64. 6. 自定义异常处理
  65. * 1.遇到标准异常类都无法充分描述的异常时可以创建自己的异常类
  66. * 2. Exception 类或者它的子类派生一个子类即可
  67. * 3.习惯上,定义的异常类应该包含2个构造器: “无参构造器” “带有详细信息的构造器”
  68.  
  69. public class MyException extends Exception{
  70. //无参构造器
  71. public MyException(){
  72. }
  73. //带有详细信息的构造器
  74. public MyException(String message){
  75. super(message);
  76. }
  77. }

Java SE 开篇的更多相关文章

  1. Using Headless Mode in the Java SE Platform--转

    原文地址: By Artem Ananiev and Alla Redko, June 2006     Articles Index This article explains how to use ...

  2. Mac下打开eclipse 始终提示 你需要安装Java SE 6 Runtime

    Mac下打开eclipse 始终提示 你需要安装Java SE 6 Runtime        周银辉 我的mac os 版本是10.9.2,  JDK配置得好好的,但打开eclipse时还是提示需 ...

  3. mac下需要安装旧 Java SE 6 才能打开程序解决办法

    今天我在mac系统下面安装myeclipse2014(myeclipse-pro-2014-GA-offline-installer-macosx.dmg)的时候,发现显示错误: 您需要安装旧 Jav ...

  4. ubuntu配置 Java SE 1.6

    今天编译android 4.0时提示如下错误:   You are attempting to build with the incorrect version of java. Your versi ...

  5. 《写给大忙人看的java se 8》笔记

    现在才来了解java8,是不是后知后觉了点? 新的编程技术,个人不喜欢第一时间跟进. 待社区已有实践积淀再切入似乎更划算些? 一点点精明的考虑. 不多说,上代码. //读<写给大忙人看的java ...

  6. Java SE 基础:注释

    Java SE 基础:注释 一.注释定义 用于解释说明程序的文字. 二.注释的作用 1.解释说明程序,提高程序的可读性 2.可以帮助我们调试程序:通过注释代码块,检测错误位置 三.格式 1.单行注释 ...

  7. Java SE 基础:标识(zhì)符

    Java SE 基础:标识(zhì)符 一.标识符定义 标识符,就是给类.接口.方法.变量等起名字时的字符序列 二.组成规则与注意事项 1.组成规则 英文大小写字母 数组 $ 和 _ 2.注意事项 不 ...

  8. Java SE 基础:常用关键字

    Java SE 基础:常用关键字 常用关键字表

  9. Java SE 简介 & 环境变量的配置

    Java SE 简介 & 环境变量的配置 一.Java 技术的三个方向 Java 技术分为三个方向 javaSE( Java Platform Standard Edition 标准版)用来开 ...

随机推荐

  1. CSS 空中飘动的云动画

    <!doctype html> <html> <head> <meta charset="utf-8"> <title> ...

  2. 拷贝地图 CopyAndOverwriteMap()

    private void CopyAndOverwriteMap() { //Get IObjectCopy interface IObjectCopy objectCopy = new Object ...

  3. 【APUE】进程间通信之信号量

    信号量是一个计数器,用于多进程对共享数据对象的访问 为了获得共享资源,进程需要执行下列操作: 1)测试控制该资源的信号量 2)若此信号量为正,则进程可以使用该资源,进程将信号量减1,表示它使用了一个资 ...

  4. 了解kaggle

    Kaggle官网 数据挖掘的比赛,主要是特征工程 Kaggle 数据挖掘比赛经验分享 Kaggle 机器学习竞赛冠军及优胜者的源代码汇总 程序化广告交易中的点击率预估

  5. IntelliJ 中类似于Eclipse ctrl+o的是ctrl+F12

    IntelliJ 中类似于Eclipse ctrl+o的是ctrl+F12 学习了:https://blog.csdn.net/sjzylc/article/details/47979815

  6. [转] When to use what language and why

    Published by Seraphimsan Oct 13, 2010 (last update: Oct 14, 2010) When to use what language and why ...

  7. 关于axis2.1.6与websphere7的包冲突问题的解决方式

    1,复制axis2.1.6内的module目录内的全部文件到lib 并改动扩展名为.jar 2,删除module目录(可选,不删除也能够) 3,部署到was 4,设置was相应应用程序的类载入方案为父 ...

  8. VS2010打开高版本VS解决方案

    http://blog.csdn.net/backspace110/article/details/62111273 Microsoft Visual Studio Solution File, Fo ...

  9. <label>标签for属性

    label 元素不会向用户呈现任何特殊效果.不过,它为鼠标用户改进了可用性.如果您在 label 元素内点击文本,就会触发此控件.就是说,当用户选择该标签时,浏览器就会自动将焦点转到和标签相关的表单控 ...

  10. SE11 数据表中 日志数据更改 勾选的作用

        [园工]HF-abap-Rainy(574570549)  11:10:12这个有啥作用,勾上了怎么查修改日志呢,[园丁]SH-CRM-ALEX(8738890)  11:13:53SCU3[ ...