java基础知识总结1

一、 java开发工具

Editplus：Editplus与jdk的连接配置，如：javac（编译）、java（运行）、javap(查看字节码)
a) 配置内容：
i. javac（编译）：参数为 -d . (FileName)；初始目录(FileDir)
ii. java（运行）：参数为 (CurSel).(FileNameNoExt)；初始目录：(FileDir)iii.javap(查看字节码)：参数为(FileNameNoExt)；初始目录：$(FileDir)

二、 java初始

：
a) 通过HelloWorld类讲解了关键字、命名规范、修饰符；
pubic class HelloWorld{
public static void main(String[] args){
System.out.println(“Hello World!”);
}
}
b) jdk与jre的区别；内容、范围///开发、运行//里面包含了各种类库和工具、java程序的运行环境JVM
jar；java下的压缩文件
javac；编译
javadoc；可形成帮助文档
共有：java；运行
native2ascii；本地码改成ASCII码
javap;查看字节码文件
c) 字节码；是java跨平台的一个机制，是一段二进制代码，是一种包含执行程序、
由一序列 op 代码(操作码)/数据对组成的二进制文件。字节码是一种中间码，它比机器码更抽象，是包含一个执行程序的二进制文件（.class）
数据单位的进制；K是千 M是兆 G是吉咖 T是太拉 8bit(位)=1Byte(字节)
1024Byte(字节)=1KB 1024KB=1MB 1024MB=1GB 1024GB=1TB
　　java中，字节码是CPU构架（JVM）的具有可移植性的机器语言。
d) 四个目标；
1、java简介；历史和地位—跨平台纯面向对象的语言–第三代语言：继承、封装、多态：方法同名，体不同
C++ — 类函数
.NET—跨语言的平台
SQL–结构化查询语言–第四代语言
Lisp、Prolog人工智能语言—第五代语言
自身发展：95年后变成javaSE
java体系：javase、javaee、javame
特点：面向对象、平台无关、健壮性：无指针、内存的申请与释放（内存分配）
2、工作原理
I java虚拟机
Java虚拟机（JVM）是以 字节码 为机器指令的系统，编译虚拟机的指令集与编译微处理器的指令集非常类似。
Java虚拟机包括一套字节码指令集、一组寄存器、一个栈、一个垃圾回收堆和一个存储方法域。——堆，栈，本地方法栈，方法区，pc寄存器
.java—.class
Ii 垃圾回收机制(GC);不再使用的内存空间应该回收起来
java 的垃圾回收机制：Java的垃圾回收机制是Java虚拟机提供的能力，用于在空闲时间以不定时的方式动态回收无任何引用的对象占据的内存空间。需要注意的是：垃圾回收回收的是无任何引用的对象占据的内存空间而不是对象本身
1.垃圾回收是由虚拟机自动执行，不能人为地干预。
2.系统比较空闲（垃圾回收线程）执行
3.对象不在被引用.对象处于引用的隔离岛状态（隔离引用），对象具备了回收的条件
4.gc()方法，可以建议虚拟机执行垃圾回收，但是不能确定是否会执行回收。
iii、开发环境搭建
tools:JCreator\Eclipse\MyEclipse\Jbuilder\NetBeans

iv、第一个java程序
java源文件；.java
基本组成是class，只能有一个public类，命名与其一致
java运行（JVM）： 类装载器、字节码校验、解释器
java中只有值传递

三、 数据类型与转换

（标示符和关键字、常量与变量、基本数据类型，自动转换，强制转换、转义字符、表达式）
a) 标示符:标示符的格式要求：
i. 定义：java对各种变量、方法和类等要素的命名时使用的字符序列，均须遵守标示符的规则
ii. 规则：
1. 由字母、下划线_、美元符$、数字组成
2. 开头不能是数字
3. 大小写敏感，长度无限制(区别C)
4. 类名首字母一般要大写，方法名一般要小写，并且遵循骆驼命名规则，如：ActiveDemo
b) 关键字
i. 定义：java中一些赋以特定的含义，用作专门用途的字符串
ii. 所有关键字都必须小写
iii. 常用的关键字用
1. 用于数据类型的：int、long、short、String、byte、char、float、double、boolean
2. 用于流程控制的：if、else、for、switch、case、do、while、break、continue
3. 访问控制符：public、protected、default、private
4. 用于异常的：try、catch、finally、throw、throws
5. 返回类型的：native、super、null、void、return、synchronized(同步)
6. 实例：instanceof、this、new
7. 面向对象：class、extends、interface、abstract、final、implements、import、package、static
8. goto和const用来破坏程序入口，也是关键字
c) 常量与变量
i. 常量：（public static final 常量名；）
1. 定义：始终不变的值，可以是数值、字符、字符串
2. 规则：习惯上命名时要大写
ii. 变量：（type varName [=value]；）
1. 注意：局部变量使用前必须先初始化不然编译失败！
iii. 调用格式：
1. 调用同文件中的其他类的变/常量格式为：对象.变量
2. 同类中调用其它函数的实例变/常量格式为:new 对象（）.变量名
3. 同类中调用其它函数的类变/常量格式为: 类名.变量名
d) 数据类型
i. 基本数据类型：byte、short、int、long、char、float、double、boolean
1. 默认值(范围是-2^(n-1)∽2^(n-1)-1)
a) Byte//1、short//2、int//4、long//8——默认值为0
b) char //2——–字符0—–范围是0~65535—unicode编码
c) float//4、double//8——–0.0
d) Boolean//2—————false
ii. 引用数据类型：数组、类、接口
e) 自动转换（隐式转换）(由小转大)
i. 定义：自动类型转换，也称隐式类型转换，是指不需要书写代码，由系统自动完成的类型转换
ii. 转换规则：byte?short（char）?int?long?float?double
iii. 示例代码：
1. int i = 4;
2. float n = i;
f) 强制转换（由大转小）
i. 转换规则：double→float→long→int→short(char)→byte
ii. 格式：（转换到的类型）需要转换的数值
iii. 示例代码：
1. double d = 3.10;
2. int n = (int)d;
iv. 注意：强制转换通常都会导致精度的损失
g) 转义字符
i. \b退格
ii. \n换行
iii. \r回车
iv. \’单引号
v. \”双引号
vi. \反斜杠
h) 运算符——表达式
i. 定义：表达式是由数字、算符、数字分组符号(括号)、自由变量和约束变量等以能求得数值的有意义排列方法所得的组合。约束变量在表达式中已被指定数值，而自由变量则可以在表达式之外另行指定数值
ii. 算术运算符：
1. 单目: ++（自加1）、–（自减1）、+（取正）、-（取负）
2. 双目: ＋ 、－ 、* 、/、 ％
3. 三目: ？： 如：a>b?a:b
iii. 关系运算符：——-返回结果true/false
1. 等于符号:==
2. 不等于符号:!=
3. 大于符号:>
4. 小于符号:<
5. 大于等于符号:>=
6. 小于等于符号:<=
iv. 逻辑运算符：——返回结果true/false
1. 与（&&）：假短路
2. 或（||）：真短路
3. 非（！）：
v. 位运算符：—–将原数转化为二进制计算
1. 与（&）： 如 1100&1010=1000
2. 或（|）： 如 1100|1010=1110
3. 非（！）： 如 !1100=0011
4. 异或（^）： 如 1100^1010=0110
5. << 带符号左移 ——相当于乘以2
6. >>带符号右移 ——-相当于除以2
7. >>> 无号右移
8. 异或的规律：
a) a ^ a = 0
b) a ^ b = b ^ a
c) a ^ b ^ c = a ^ (b ^ c) = (a ^ b) ^ c;
d) d = a ^ b ^ c 可以推出 a = d ^ b ^ c.
e) a ^ b ^ a = b
vi. 赋值运算符：
1. =、+=、-=、*=、/=、%=、&=、^=、|=、<<=、>>=
vii. Intanceof:—-归属
1. 定义：为双目运算符，左边操作元是一个对象，右边是一个类。当左边的对象是右边类的对象时，返回true
2. 格式：result = object instanceof class 如：a = b instaceof B;//true
viii. 优先级：（从高到低、从左到右）
1. () []
2. ! +(正) -(负) ~ ++ –
3. * / %
4. +(加) -(减)
5. << >> >>>
6. < <= > >= instanceof
7. == !=
8. &(按位与)
9. ^（位异或）
10. |（位非）
11. &&
12. ||
13. ？：
14. = += -= *= /= %= &= |= ^= ~= <<= >>=>>>=

四、 流程控制语句（分支、循环）

a) If…else: 例1.1:
i. If（a>b）{
ii. System.out.println(a);
iii. }else if(b>c){
iv. System.out.println(b);
v. }else{
vi. System.out.println(b);
vii. }
b) 分支：（switch）
i. 格式：switch（条件语句）{
case ：
case ：
…..
default ：
}
ii. 例1.2:switch(month){
case 1：System.out.println(“spring”);break;
case 1：System.out.println(“spring”);break;
case 1：System.out.println(“spring”);break;
case 1：System.out.println(“spring”);break;
default: System.out.println(“spring”);break;//一定会执行的语句
}
c) For循环
i. 格式：For(初始化语句;条件语句;控制语句){
循环体；
}
ii. 例1.3：for（int i=1;i<101;i++）{
int sum = 0;
sum += i;
}
d) while
i. 格式：while(条件语句){
//初始化语句；
循环体；
//控制语句；
}
ii. 例1.4：int i=1;
while(i<101){
int sum=0;
sum += i;
}
e) Do….while()
i. 格式: do{
循环体；
}while(条件语句);
ii. 例1.5：int i =1;
do{
int sum = 0;
sum += i;
}while(i>101);
f) 增强型for循环———-主要用于打印数组元素
i. 格式：for(e:数组名){
循环体
}
ii. 例1.6：int[] a = new int[10];
for(e:a){
System.out.println(e);
}

五、 方法与递归

a) 方法—函数
i. 定义：一段用来完成特定功能的代码片段
ii. 声明格式：【修饰符】返回类型 方法名（形参列表）{
方法体；
}
iii. 语法解释：
1. 形式参数：在方法被调用时用于接收外界输入的数据
2. 实参：调用方法时实际传给方法的数据
3. 返回值：方法在执行完毕后返回给调用它的环境的数据
4. 返回值类型：事先约定的返回值的数据类型，无返回值，必须给出返回类型void
5. return语句中止方法的运行并指定要返回的数据
iv. 调用格式：
1. 静态方法（又称类方法）的调用：类名.方法名(实际参数)
2. 实例方法的调用：对象名.方法名(实际参数)
3. 调用中传递参数时，遵循的规则是：基本数据类型是该数据本身，引用数据类型传递的是对象的引用（地址），不是对象本身—-基本数据类型：值传递；引用数据类型：地址传递。
v. 例1：
public class DemoMethod{
public static void main(String[] args){//静态方法（又称类方法）的调用：类名.方法名(实际参数)
show(“i am a girl”);
//实例方法的调用：对象名.方法名(实际参数)//如何产生对象(Object)，格式：new 构造方法()
//和类同名的方法称为构造方法
//什么是构造方法(Constructor)？每个类都有一个和类名相同的构造方法，且自动产生
// new DemoMethod().display();
new DemoMethod().visiable(12,”aaa”,3.0f);
}
//静态方法的定义【有关键字static修饰的方法】
public static void show(String s){//自定义方法
System.out.println(s);
}
//实例方法的定义【没有关键字static修饰的方法】
public int display(){System.out.println(“welcome to jiangxi”);return (85);//返回结果，可以用括弧，也可以不用}
//多个参数的实例方法
public void visiable(int x,String y,float f){System.out.println(“=======================”);}
}
b) 递归———-必须要有出口
i. 定义：递归用于让一个函数从其内部调用其自身
ii. 特点：
1. 程序代码简练，易于理解但浪费内存
2. 一定要有返回类型
3. 一定有if…….else……且if中有终止条件

六、 类（面向对象技术基础、类的声明与使用、对象的声明与使用、构造方法）

a) 面向对象技术基础
i. 面向对象设计的方法论【OOA（分析）?OOD(设计)?OOP（编程）?Test（测试）?部署】
ii. 面向对象（Object Oriented,OO）特点：
1. 对象唯一性：每个对象都有自身唯一的标识，通过这种标识，可以找到相应的对象。在对象的整个生命期中，它的标志都是不改变的，不同的对象不能有相同的标识（地址）。
2. 封装性（抽象性）：把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。
3. 继承性：继承性是子类自动共享父类数据结构和方法的机制，这是类之间的一种关系，java中的类只支持单继承，接口支持多继承
4. 多态性（多形性）：多态性是指相同的操作或方法、过程可作用于多种类型的对象上并获得不同的结果。不同的对象，收到同一消息可以产生不同的结果，这种现象称为多态性
5. 总结作用：封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。
iii. 面向对象（OO）基本特征
1. 封装（package）
2. 继承（inheritance）——关联关系
a) 继承（泛化generalize）
i. 实现继承
ii. 可视继承
b) 组合（聚合）
i. 接口继承
3. 多态（Polymorphism）
a) 重写（override）
i. 方法
ii. 接口（interface）
b) 重载（overload）
i. 同名函数
b) 类的声明和使用
i. 声明格式：
【修饰符】class【类名】{
方法体；
}
ii. 例1：
public static class Demo{
System.out.println()；
}
c) 对象的声明与使用
i. 格式：类名 对象的引用变量 = new 类名（）;
ii. 例2：Demo d = new Demo();
d) 类与对象的比较
i. 类就是对象的模板，对象是类的实例
e) 构造方法
i. 定义：定义在类中，用来初始化对象的成员变量的方法，返回的是内存地址
ii. 格式：
1. 【修饰符】方法名（）{}
2. 例3：public Demo（）{}
iii. 要求：
1. 与类同名；2、没有返回值（无void 的修饰）；必须要先创建对象，在对象上进行调用（new）

七、 UML

a) UML定义：（Unified Modeling Language）统一建模语言，一种用于面向对象的软件工程的分析与设计阶段的一种可视化建模语言
b) UML关系（类与类之间的关系）：关联对属性，依赖对方法
i. 关联关系：菱形指向整体 has a
1. 关联关系——若在逻辑上A是B的“一部分”（a part of），则不允许B从A派生，而是要用A和其它东西组合出B
2. 聚合（aggregation）—实线空心菱形
3. 组合—整体与部分不可分开，实线实心菱形
ii. 泛化（Generalization）关系（继承）：用实线空心三角形指向父类 is a
1. 若在逻辑上B是A的“一种”，并且A的所有功能和属性对B而言都有意义，则允许B继承A的功能和属性
iii. 实现关系（接口）：虚线
iv. 依赖(Dependency)关系： A”————>”B(A依赖于B) use a 虚线箭头
c) 修饰符图形
i. + public - private # protected ~ 默认访问
d) 建模图形（9种）：
i. 用例图（Use Case Diagram）：展示系统外部的各类执行者与系统提供的各种用例之间的关系
ii. 类图（Class Diagram）：展示系统中类的静态结构（类是指具有相同属性和行为的对象），类图用来描述系统中各种类之间的静态结构
iii. 对象图（Object Diagram）：是类图中的一种实例化图（是对类图的实例化）
iv. 顺序图（时序图）序列图（Sequence Diagram）：展示对象之间的一种动态协作关系（一组对象组成，随时间推移对象之间交换消息的过程，突出时间关系）
v. 协作图（合作图）（Collaboration Diagram）：从另一个角度展示对象之间的动态协作关系（对象间动态协作关系，突出信息收发关系）
vi. 状态图（Statechart Diagram）：描述一类对象具有的所有可能的状态及其转移关系（展示对象所具有的所有可能的状态以及特定事件发生时状态的转移情况）
vii. 活动图（Activity Diagram）：展示系统中各种活动的执行流程（各种活动的执行顺序、执行流程）
viii. 构件图（Component Diagram）：展示程序代码的物理结构（描述程序代码的组织结构，各种构件之间的依赖关系）
ix. 部署图（Deployment Diagram）：展示软件在硬件环境中（特别是在分布式及网络环境中）的配置关系（系统中硬件和软件的物理配置情况和系统体系结构）

八、 自定义类

a) 类的定义：类是具有相同属性和相同操作的对象集合，类是对象的模板，一个类可以产生对个对象，产生单个对象的话就是单例模式，类是对现实世界中实体的抽象，对象是对现实世界中实体的实例
b) 类的组成：字段（成员变量）+方法+初始化块（静态初始化块+对象初始化块）
c) 命名规则：类名的首字母大写；变量名和方法名（构造方法除外）的首字母小写，采用骆驼名命名标识
d) 字段（实例变量+类变量（静态变量））的定义格式：
【修饰符（4p、static、final）】 数据类型 属性名【=默认值】；
e) 方法的定义格式：【修饰符（4p、static、final、abstract）】 返回值 方法名（【参数列表】）{ 代码块；}
f) 初始化顺序：静态初始化块?类变量，实例变量初始化?对象初始化块和成员变量初始化（在程序代码中的先后顺序来定）?构造方法
g) JavaBean规范：
i. 必须是公共类，并将其访问属性设置为public,如：public class Stu{}
ii. 必须有一个空的构造方法（public、无参）：必须有一个不带参数的公共构造器
iii. 字段（实例变量）要私有化，首字母要小写，用private修饰 如：private int id；
iv. 字段应该通过一组存取方法（getter和setter）来访问，一般是用Eclipse、JBuilder、IDE等工具生成getter和setter方法
v. setter和getter规范：字段首字母小写——如：
1. public class Demo{
a) private String name;
b) public Demo(){}
c) public Demo(){
System.out.println(“不错”);
d) }
e) public void setName(String name){
this.name = name;
f) }
g) public String getName(){
return name;
h) }
}

九、 数组（一维数组、二维数组、排序、Arrays.sort）

a) 一维数组
i. 定义：数组就是相同类型元素的集合
ii. 数组变量是引用类型，栈stack（FILO，自动回收）引用堆heap（new出来的，树形结构，JVM回收）中的数据；
iii. 格式：int[] a = new int[3];
int[] a = {1,2,4};
iv. 使用for循环遍历输出，获得数组长度length，访问元素
For…each: 增强型for循环
for(String i:a){//增强型for循环System.out.println(i);}
//冒泡排序
public class SortTest {
public void sort(int[] args){
System.out.println(“排序前 “);
for(int m : args){System.out.print(args[m]+”,”);}
int time1 = 0,time2 = 0;
for(int i = 0 ; i < args.length-1 ; i++){for(int j = i+1 ; j < args.length ; j++){int temp ;if(args[i] > args[j]){temp = args[j];args[j] = args[i];args[i] = temp;}}}System.out.println();System.out.println(“排序后 “);for(int n : args){System.out.print(n+”,”);}}public static void main(String[] args) {int[] arg = new int[]{2,1,4,5,8,7,6,3,9,0};new SortTest().sort(arg);}
}
b) 二维数组—–实质是一维数组引用另一维数组
i. 声明：Int[][] arr;//4个字节
ii. 创建时必须创建行，初始化就是对每个元素进行初始化，使用增强型for循环

十、 Object类

a) Object类是所有类的超类；
b) 常用方法：HashCode()—-哈希值，如：
i. IntegertoHexString(p1.hashCode());//把哈希码的无符号十六进制转换成十进制
c) getClass()//获取运行时的类
d) toString()//返回字符，相当于getClass().getName()+”@”+Integer.toHexString(HashCode());
e) clone()//创建一个与源对象完全相同的对象，但新对相象与源对象不相等
i. 子类重写clone（）要求：1、创建一个类A实现cloneable接口；2、重写Object的clone()，调用super.clone()
ii. 代码实现：如
public class Person implements Cloneable{
int as ;
protected Object clone() throws CloneNotSupportedException{Person p = (Person)super.clone();
}
}
public class PersonDemo{public static void main()throws CloneNotSupportedException{Person p = new Person();p.as=11；System.out.println(“Before clone”+p.as);Person p1 = (Person)p1.clone();p1.as=22;System.out.println(“After clone”+p.as);}}