Java--OOP细节(一)

一、MyEclipse10中常用的几个快捷键
1).重写方法的快捷键:alt+shift+s->v，或者是在选中实现接口的类，ctrl + 1;
2).生成get和set方法的快捷键:alt+shift+s+r，如果是生成全部的就继续alt+a;
3).生成构造器：alt+shift+s+c，无参构造器；alt+shift+s+o，有参构造器
4).导入包的快捷键：ctrl + shift + o
5).有异常需要捕获：选中代码，ctrl + 1
如果没有异常要捕获，自己想添加代码块：选中代码块，alt+shift+z
6).对指定代码添加(if-else等代码块)：全选中代码，按alt+shift+z，出来后再选择
7).自动对齐格式 ：Ctrl+Shift+f
8).选中要注释的代码：利用“/**/”注释，Ctrl+Shift+\ 取消注释 Ctrl+Shift+/；利用“//”注释，Ctrl+\
9).查看该类中的所有方法：Ctrl + o，如果在该类中没有找到该方法，则继续到其父类中查找
10).配置jdk:在包上右键->Properties->javaCompiler->JDK Compliance下选择下拉框选择

二、浅谈java中与JVM相关的几个类
1. System类
1).运行垃圾回收器: System类提供了静态的gc方法提示JVM努力回收未使用的对象，以便能够快速地重用这些对象当前占用的内存。需要注意的是，并不是调用gc方法之后，JVM就会立即回收未使用对象占用的内存，它只是让JVM尽快地去做这件事。具体什么时候进行是取决于具体的虚拟机的，不同的虚拟机有不同的对策。调用System.gc()实际上等效于调用Runtime.getRuntime().gc()方法。
另外：finalize()方法：
java技术使用finalize()方法在垃圾收集器将对象从内存中清除出去前，做必要的清理工作。它是在Object类中定义的，因此所有的类都继承了它。子类可以覆盖finalize()方法以整理系统资源或者执行其他清理工作。finalize()方法是在垃圾收集器删除对象之前对这个对象调用的，但是垃圾收集器并不能有程序员控制，因此根本无法确定这个方法在什么时候被调用，因此不建议使用finalize()方法来回收对象资源。
2).退出虚拟机:System类的exit(int status)方法可以强行终止单签正在运行的java虚拟机，参数status为状态码。一般的，非0状态码表示异常终止。System.exit(int status);常用在需要强行关闭程序的地方。
2. Runtime类
Runtime类使应用程序能够与其运行的环境进行信息交互。这个类使用的是单例设计模式，通过Runtime.getRuntime()方法来获取唯一的实例。(代码略)
1. 提供获取运行时JVM使用内存的情况
2. 执行指定的命令Runtime.getRuntime().exex(cmd);
上述两个类还将会在常用类中比较详细的介绍

三、几个关键字
1. this关键字
1).每个类的非静态方法(没有被static修饰)都会隐含一个this引用名称，其真正的作用在于解决成员变量与参数的模糊性，即当局部变量(方法的参数或方法体中定义的变量)和成员变量(类的属性)重名时，可以显示地访问成员变量。
2).在同一类中构造器相互调用只能使用this关键字，必须位于第一句,并且只能出现一次。比如this()不能和this(name) 等同时出现，参数可以确定是调用的哪一个构造器。

/** * 测试this * @author Fanff * */public class TestThis {    private String name;    private int age;    public TestThis(){        this("FanFF");    }    public TestThis(String name){        //Demo01(5); 构造器之间错误调用        test();        System.out.println(name);    }    public TestThis(int age){        this();        test();    }    public TestThis(int age, String name){        test();        // this(age); this调用构造器必须位于行首    }    public void test(){    }}

2.super关键字
当使用子类中的构造器来创建一个对象时，子类构造器要负责调用合适的父类构造器来先对父类的属性进行初始化，然后才对自己的属性进行初始化。在默认情况下，子类构造器会调用父类的无参构造器(默认构造器)，但是如果父类没有定义默认构造器或者说是定义了有参构造器时，就需要在子类的构造方法中显示调用父类中的构造器，否则编译报错。
1). super是直接父类对象的引用，可以通过super指针来访问父类中被子类覆盖的方法或属性
2). 任何类的构造函数的第一行代码都是super(),或显示调用或隐式调用

/** * 测试Super关键字 * @author Fanff * */public class TestSuper {    public void fatherMethod(){        System.out.println("父类的方法");    }    public static void main(String[] args) {    }}class TestSuperExtends extends TestSuper{    @Override    public void fatherMethod() {        //super.fatherMethod();// super关键字显示调用父类中被覆盖的方法        fatherMethod();        System.out.println("子类重写父类的方法");    }}class TestSuper1{    private String name;    private int age;    public TestSuper1(String name, int age) {        super();        this.name = name;        this.age = age;    }}class TestSuper1Extends extends TestSuper1{    /*父类有有参构造，子类必须也得有能显示调用父类有参构造的有参构造*/    public TestSuper1Extends(String name, int age, int id) {        super(name, age);    }}class TestSuper2{    public TestSuper2() {        super();        // TODO Auto-generated constructor stub    }}class TestSuper2Extends extends TestSuper{}

3.static关键字
1). 类属性(静态属性)与成员属性(一般属性)不同。JVM加载一个类到内存中是，会先对类属性进行初始化，且只初始化一次，这个步骤完成之后才会进行其他的。类属性在内存中单独分配这空间，以后任何一个对象对该值的修改都是使该存储空间中的值发生改变，而其他对象在后引用时就跟着发生变化。
2). 静态代码块：用来显示地初始化类属性。这段代码块在JVM第一次加载类到内存中时执行且只执行一次。如果一个类中出现了多个静态代码初始化块，会按照在类中出现的顺序执行。
Static{}
static int[] a;
static{// 静态代码块
a = new int[]{1, 2, 3};
}
3). 调用问题
两种方式：类名.方法(或属性)
static 包名.类名.方法(或属性)
当然也可以使用对象名.方法(或属性),但是不建议这样写
4). 非静态内部类不能有静态成员–>静态成员和方法必须在静态类里面.但静态内部类可以包含静态成员和非静态成员
4.final关键字
1). final修饰的变量为常量，不能被更改
细节如下代码

public class Static_fin {    /*static final 属性在声明时就赋值*/    static final int CONTENT = 5;    static final int[] a;    static{// 静态代码块        a = new int[]{1, 2, 3};    }    /*final属性必须在构造器结束之前被赋值*/    private final int m;    public Static_fin(int m){        this.m = m;    }    public static void f(){        final int n;        /*final局部变量只能被赋值一次*/        n = 1;        System.out.println(n);    }    public static void main(String[] args) {        f();    }}

2). 修饰方法时可重载但不可重写，修饰的类不能被继承

下一篇将围绕OOP中常谈的三大特性(封装、继承、多态)展开