Java学习笔记(2) java基本原理概述

Java基本原理
首次调用 [从物理到内存] –> Interpreter 校验
再次调用 [从内存加载]
改变内容：runtime stop -> restart (冷部署)

JVM：Java虚拟机

Java Doc 注释：

////**

Enter
@ 调用符号
导出Java Doc：项目名称[R] -> Export… -> Java -> Javadoc
(默认不支持中文 –> 加参数(百度))
问题：@调用return和exception报错

新建类
New -> class -> [Name]

书写规范
类：所有单词首字母大写
方法、变量：第一个单词首字母不大写，其余大写
package：全小写
每行80字符

public static void main(String[] args){    ...}

main：启动函数
String[] args (better) or String args[]

Run As -> Run Conf -> Java Application 运行有参数程序

参数类型
[值]int：可直接进行运算
[对象]Interger：作为类调用参与运算
eg:

int x=100;Integer y=new Integer(100);System.out.println(x+y.intValue());String

eg:

String a=”123”;String b=”123”;String b=new String(“123”);if(a==b) System.out.println(“a=b”);if(a.equals(b)) System.out.println(“a=b”);  //通常用.equals()：不知道字符是怎么传过来的                              //自定义新类的缺省行为是比较reference，需要重写else System.out.println(“a!=b”);

result:

a=b a!=ba=b

char a=’A’ 单引号
(int)a 字符的ASCII码
char c 不赋初始值，不会自动初始化 -> 直接使用报错
（声明对象尽量给初始值[NULL…]）

StringBuffer 必须通过声明来实例

String a=”123”;StringBuffer sb=new StringBuffer(“123”); System.out.println(sb.reverse());

result:

321

StringBuffer的效率远远大于String，高性能开发时几乎不用String。

String d=a+b+c;   //a、b、c中间变量占用内存sb.append(“456”).append(“789”);System.out.println(sb.toString());

result:

123456789

浮点类型float 数值后加f，否则默认为double

隐性转换：

long x=100;   //等号左边类型大

强制转换：

int x=(int)100l;

二维数组

String[][] j=new String[3][];

不规则数组：

j[0]=new String[1];j[0][0]=”1”;j[1]=new String[2];j[1][0]=”2”;j[1][1]=”3”;j[2]=new String[3];j[2][0]=”4”;j[2][1]=”5”;j[2][2]=”6”;for(int i=0;i<j.length;i++){    for(int k=0;k<j[i].length;k++){        System.out.print(j[i][k]);        if(k==j[i].length-1){            System.out.println();        }    }}

result:

123456

(x轴固定)

switch(x){    case..:        ..        break;    default:        ..        break; }

x只能为char或int类型，string、double、long…都不可以。

中断循环：标签 -> 复杂跳转

OOP
public：谁都能调用
private：只有自身能调用
protected：有继承关系才可以调用，protected也赋予成员package权限，即同一个package中的其他类也可以访问protected元素。
friend：package权限。方法、变量前不加关键字即为friend
当两个类在同一个package下，friend类型的变量、方法可以相互调用。
选择最小作用域的范围来定义，减小漏洞。
类只有两种访问权限：package权限和public。

public class Father{    ...    protected int getPocketMoney(int toGiveSon){    return toGiveSon；    }    protected abstract void functionA();   //抽象方法：知道有方法，不知道如何执行}public class Son extends Father{    ...    protected void functionA(){    //抽象方法在子类中要给出实例    }}

Java只能够单亲继承，不能交叉继承。即不能extends Father, Mother
extends只留给最重要的，就近继承。
面向对象开发：最大父类Object。(单根继承体系)

接口interface
A是B：extends继承; A有B的功能：接口

public class Son extends Father implements MyInterface{    ...    public void methodA(){};    public void methodB(){};}public interface MyInterface{    public void methodA(){}     public void methodB(){}}

聚合

public class Show{    private int year;    private int month;    private int day;    private int getLastDay(int year,int month,int day){        return 1;    }}public Show(){    Calendar c=Calendar.getInstance();    c.set(7890,2,1);   //java月份从0开始，3月1日    c.add(Calendar.DATE, -1);    System.out.println(c.getTime());}

多态polymorphsm

Public class Staff extends Employee{}Public class Manager extends Staff{}Public class Show{    Public Show(){        Staff s=new Staff();        Manager m=new Manager();        calcSalary(s);        calcSalary(m);    }    private void calcSalary(Employee e){ //接受父类作为参数        if (e instanceof Staff){         //从Staff传过来            Staff s=(Staff)e;            //解压缩            ...        }else if(e instanceof Manager){            Manager m=(Manager)e;            ...        }    }}

JavaBean
Blank[R] -> Source -> Generate…
属性get/set实现

Public class MyJavaBean{    private String attr1=null;  //成员通常是私有的    private int attr2=0;    public MyJavaBean(){    //空的构造函数，调用super()父类        super();    }}

以上仅能本地调用
跨平台调用：

public class MyJavaBean implements Serializable{    ...}

serializable[R] -> Source -> Organize…
垃圾回收站(garbage collector - GC)
回收站机制
jdk -> bin -> jconsole / jvisualvm

年轻代 (自动)

年老代 (手动)

永久代 -> 简单对象：int… / Employee(?)

手动回收：

attr1=null;

自动回收：

System.gc();   //强制进行finalization

new -> 年轻代、年老代