8月18号--Java基础查漏补缺

JVM(Java Virtual Machine)java虚拟机
源文件.java->编译器->字节码文件（多数操作系统都能识别）.class->解释器(JVM)，来实现跨平台
JDK：java开发工具包

JRE：java运行时环境

填写图片摘要（选填）
​
在控制台运行一个 Java 程序 Test . class ，使用的命令正确的是java Test
Eclipse：
IDE集成开发环境是一种软件，将程序开发环境和程序调试环境集合在一起，提高开发效率
​
导出导入
导出，通过(属性)property找到文件位置，直接复制
导入，开发列表中直接点击空白处右键，导入，已存在的项目，找到文件完成导入
常量
我们可以理解为是一种特殊的变量，它的值被设定后，在程序运行过程中不允许改变。
语法：final 常量名 = 值;
调试
代码行最左边双击，用运行旁边类似甲壳虫的标准运行代码，进行调试(debug)
Arrays 类
Java 中提供的一个工具类，在 java.util 包中。该类中包含了一些方法用来直接操作数组，比如可直接实现数组的排序、搜索等（关于类和方法的相关内容在后面的章节中会详细讲解滴~~）。
Arrays 中常用的方法：
1、 排序
语法：  Arrays.sort(数组名);
可以使用 sort( ) 方法实现对数组的排序，只要将数组名放在 sort( ) 方法的括号中，就可以完成对该数组的排序（按升序排列
2、 将数组转换为字符串
语法：  Arrays.toString(数组名);
可以使用 toString( ) 方法将一个数组转换成字符串，该方法按顺序把多个数组元素连接在一起，多个元素之间使用逗号和空格隔开
冒泡算法：

public class Test {    public static void main(String[] args) throws Exception {        int[] scores = {1, 4, 7, 3, 8, 2, 9, 6, 5};        int temp = 0;        for (int i = 0; i <= scores.length; i++) {            for (int j = i; j < scores.length; j++) {                if (scores[i] > scores[j]) {                    temp = scores[i];                    scores[i] = scores[j];                    scores[j] = temp;                }            }        }        for(int i = 0;i<scores.length;i++){            System.out.println(scores[i]);        }    }}

成员变量和局部变量的区别：
局部变量的作用于仅限于定义他的方法，成员变量的作用域在整个类内部都是可见的
在同一方法中，不允许有同名局部变量，在不同方法中，可以有同名局部变量
java会给成员变量一个初始值，不会给局部变量。
静态变量，静态方法
public static int i= 100；​
静态初始化块：
static {
num = 83;
}调用该变量时，可直接用类名，不必用对象名
​java封装：
将类的某些信息隐藏在类内部，不允许外部程序直接访问
而是通过该类提供的方法来实现对隐藏信息的操作和访问。
好处：只能通过规定的方法访问数据，隐藏类的实例细节，方便修改和实现
修改可见性   private
创建getter/setter
在getter/setter中添加控制语句
​
内部类（ Inner Class ）
就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类。
问：那为什么要将一个类定义在另一个类里面呢？清清爽爽的独立的一个类多好啊！！
答：1. 内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类
2. 内部类的方法可以直接访问外部类的所有数据，包括私有的数据
3. 内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便类：

public class HelloWorld {    private String name = "hello";    static String b = "2";    int a = 1;    public class Inner {        String name = "helloWorld";        // 内部类的方法        public void show() {            System.out.println(HelloWorld.this.name);//访问外部类的变量            System.out.println(name);        }    }    public static class Inner11 {        int b = 2;        // 内部类的方法        public void show() {            System.out.println(HelloWorld.b);//访问外部静态变量            System.out.println(b);        }    }    public void show() {        // 定义方法内部类        class MInner {            int score = 83;            public int getScore() {                return score + 10;            }        }  // 创建方法内部类的对象        MInner mi = new MInner();// 调用内部类的方法        int newScore = mi.getScore();        System.out.println("姓名：" + name + "\n加分后的成绩：" + newScore);    }    public static void main(String[] args) {// 创建外部类对象        HelloWorld hello = new HelloWorld(); // 创建内部类对象        Inner i = hello.new Inner(); // 调用内部类对象的方法        i.show();        Inner11 i1 = new Inner11();        i1.show();        hello.show();//调用外部类的方法    }}

静态内部类是 static 修饰的内部类，这种内部类的特点是：
1、 静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问 
2、 如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员
3、 创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= new 内部类();
方法内部类就是内部类定义在外部类的方法中，方法内部类只在该方法的内部可见，即只在该方法内可以使用。
final 修饰的类不可被继承
​
匿名内部类
直接在main方法中：
接口名 i1 = new 接口名()｛
实现接口的方法
Public void playGame(){
System.out.println("playgame");
}｝;
i1.playGame();
或者
new  接口名()｛
实现接口的方法
Public void playGame(){
System.out.println("playgame");

}｝.playGame();

自定义异常的父类是exception

基本类型和字符串之间的转换：
//基本类型是不能调用方法的，而其包装类具有很多方法
int c = 10;
String str1 = Interger.toString(c);
String str2 = String.valueOf(c);
String str3 = c+"";
String str="8";
int d=Integer.parseInt(str);

int e = Integer.valueOf(str);   //Double.valueOf

Date获取当前时间：
Date d = new Date();
结果：Tue Aug 18 20:31:07 GMT+08:00 2015
上面的写法不太友好可以这样：
Date d = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");//yyyy年MM月dd日 HH:mm:ss
String today = sdf.format(d);
System.out.println(today);
输出结果：2015-52-18 20:52:33

2015年08月18日 21:00:56

Calendar 类
是一个抽象类，可以通过调用 getInstance() 静态方法获取一个 Calendar 对象，此对象已由当前日期时间初始化，即默认代表当前时间，如 Calendar c = Calendar.getInstance();
Date d = c.getTime();
int year= c.get(Calendar.YEAR);
int mouth = c.get(Calendar.MONTH)+1;
int day = c.get(Calendar.DAY_OF_MONTH);
int hour = c.get(Calendar.HOUR_OF_DAY);
int minute = c.get(Calendar.MINUTE);
int second = c.get(Calendar.SECOND);
Long time = c.getTimeInMillis();
System.out.println(year+"-"+mouth+"-"+day+" "+hour+":"+minute+":"+second);
System.out.println(d);
System.out.println(time);
结果是：
2015-8-18 21:17:23
Tue Aug 18 21:17:23 GMT+08:00 2015
1439903843902