期末不挂科のJAVA

---

JAVA主要特征

• 面向对象
• 分布式
• 跨平台
• 更安全

JAVA名词解释

• JRE（运行环境）
  包括JAVA虚拟机和JAVA程序所需的核心类库

• JDK（开发工具包）
  JDK是提供给JAVA开发人员使用的，其中包含了JAVA的开发工具，也包括了JRE。

• JVM(虚拟机)
  Java程序不是直接运行在操作系统上，而是运行在JVM上。

• JAVAEE（企业版）
  是为开发企业环境下的应用程序提供的一套解决方案。

• JAVASE（标准版）
  是为开发普通桌面和商务应用程序提供的解决方案。

• JAVAME（小型版） 是为开发电子消费产品和嵌入式设备提供的解决方案。

JAVA输出

• System.out.println() 换行输出
• System.out.print() 正常输出
• System.out.printf() 类C输出

JAVA输入

Scanner in = new Scanner(System.in)
int num = in.nextInt(); //读取整数
double num = in.nextDouble(); //读取小数
String str = in.nextLine() //读取一整行 

JAVA标识符（命名字符）

• 只能以字母，“_”,“$”开头
• 只能由数字，字母，“_”，“$”组成
• 不能是关键字
• 类和接口名：每个单词首字母大写
• 方法名：首字母小写，其余单词首字母大写
• 常量名：全部使用的大写字母，单词间用“_”分隔
  用final 关键字来定义常量，被赋值后值不再改变

数据类型

基本类型

• 整数类型：byte,short,int,long（1,2,4,8）
• 浮点类型：double,float（8,4）
• 字符类型：char（2）可以存储汉字
• 布尔类型：boolean 只有true和false

引用类型

• 类
• 接口
• 数组、枚举

类型转换

隐式转换：类型加宽转换时可以自动实现
强制转换：double f = 5.5; int n = (int) f;
Byte,short,char之间不会相互转换，计算时首先转换为int

增强型for

• for(int element:arr)
  {
  System.out.println(element);
  }
• for(String str: list)
  {
  System.out.println(str);
  }

数组

长度固定不可变，同一个数组存储相同类型的元素
静态初始化：

	int[] num1= {1,2,3}; //不能在[]中指定数组长度
	int[][] number = {{1,2}.{3,4}};

动态初始化：

int[] series = new int[4];
for(int I = 0;i<4;i++){
	series[i]=i*3;
}

Arrays类

copyOf(int[] a ,newlength) 数组复制
fill(int[] a ,int val) 数组初始化
sort(int[] a) 数组排序
binarySearch(int[] a,int key) 排序后的数组元素查找

类与对象

类：包含成员属性和成员方法的抽象数据类型
对象：按照类类型创建的实例
面向对象的三大特性：封装、继承、多态
封装性：将属性和方法结合起来，仅对外公开接口实现信息隐藏
继承性：使子类具有父类的各种属性和方法，提高了代码重用率
多态性：相同操作作用于不同类的对象，产生不同结果

类的定义

[private/protected/public] class （首字母大写）类名{}
成员属性一般用private来修饰
访问成员属性的方法用public来修饰

对象的实例化

<类名> <对象名> = new <类名>(参数)
访问属性：<对象名>.<属性名>
访问方法：<对象名>.<方法名>(参数)

值传递和引用传递（参数是基本类型不能改变原值）

值传递:

public class Arithmetic {
    public static void main(String[] args) {
        double percent = 10.0;
        System.out.println("before fun call percent = "+percent);
        tripleValue(percent);
        System.out.println("after fun call percent = "+percent);
        }
    public static void tripleValue(double x){
        x = 3 * x;
    }
}

引用传递

public class Arithmetic {
	private double number;
    public static void main(String[] args) {
    	Arithmetic percent = new Arithmetic();
    	percent.number=10.0;
        System.out.println("before fun call percent = "+percent.number);
        tripleValue(percent);
        System.out.println("after fun call percent = "+percent.number);
        }
    public static void tripleValue(Arithmetic e){
        e.number = 3 * e.number;
    }
}

方法重载

同一个类中的同名方法，参数不同，称为方法重载

构造方法

• 用于初始化对象
• 方法名与类名相同
• 参数可有可无
• 返回值不能写void
• 创建对象时自动调用，只会调用一次

		Student stu1 = new Student(); //调用无参构造方法
        stu1.setName("zhangsan");
        System.out.println(stu1.getName());
        Student stu2 = new Student("lisi"); //调用有参构造方法

this关键字

• 引用本类中的属性和方法
• 调用本类的构造方法，this()只能放在重载构造方法第一行
• 作为返回值，返回调用该方法的对象的引用

继承的实现

[public/private/protected] class 子类名 extends 父类名称{}

• 一个类只能有一个直接基类
• final修饰的类不能有子类，String是典型特例
• Object类时所有java类的顶级基类

继承规则

• 吸收基类成员（除了构造方法）
• 增加派生类成员
• 隐藏同名基类成员
• 派生类只能访问基类中非private类型的属性或方法

构造方法的调用：

• 先调用基类的构造方法，在调用派生类的构造方法
• 若基类中没有无参构造，程序报错

Super关键字

• 调用基类的构造方法（若无，默认调用无参构造）
  只能放在派生类构造方法的第一行
• 引用基类的属性或方法（非private类）

方法重写

在不改变原来代码的基础上，对任意模块进行改造

• 只出现在继承关系中，只能重写继承的基类方法
• 继承的抽象方法，要么重写，要么标识为抽象

重写规则

• 返回值相同或是原类型子类
• 方法名，参数列表相同
• 不能重写final的方法，私有的方法
• 重写的方法不能缩小访问权限

父类的引用可以调用子类的对象
Father f1 = new Son();
可以调用基类中定义的属性和方法
不能调用子类中定义但父类中没有的方法

JAVA的包

• Java.lang 核心包
• Java.net 网络包
• Java.io 文件流包
• Java.util 工具包

抽象类

• 不能实例化对象，可以定义抽象方法

• 抽象方法没有方法体，大括号也不能写

• 继承抽象类的派生类必须实现所有抽象方法，否则也为抽象类

接口

只包含常量和方法的声明

接口的实现

• 一个类可以同时实现多个接口，接口名用“，”分开
• 一个接口可以被多个无关类实现
  必须实现所有抽象方法，否则也为抽象类

接口的继承

一个接口可以继承多个接口

Object 类中的方法

Equals方法

原方法为判断是否具有相同的引用
重写方法为

• 先判断是否为同一个对象（==）
• 判断是否为空
• 判断是否为同类（getClass()）
• 用equals（）判断需要判等的属性

hashCode（） 方法

返回该对象的哈希码值，对于同一对象哈希码值相同

toString 方法

返回该对象的字符串表示，建议重写该方法
getClass().getName()+’@’+Integer.toHexString(hashCode())

多态

• 概念：同一操作作用于不同类的对象，结果不同
• 向上转型：父类的引用指向子类的对象
• 基类中定义的方法，如果派生类重写了，执行重写的方法
• 无法调用基类中没有派生类中有的方法
• 可维护性，可扩展性

包装器类

基本类型的对象形式，一旦赋值不能改变
byte --> Byte
short --> Short
long -->Long
int -->integer
char -->character
float -->Float
double -->Double
boolean -->Boolean

创建包装器类型

• Integer i = new Integer(1);
• Double d = Double.valueOf(3.14);

包装器转换为基本数据类型

装箱与拆箱

自动装箱

Integer y = new Integer(567);
y++;
//注意y++之前和之后所引用的内存地址不同

重载方法调用规则：

直接加宽装箱先装箱后加宽有不定长参数

静态属性

• 权限修饰符 static 数据类型 属性名称
• 所有实例对象共享一个静态属性，实现数据共享
• 既可以用类名访问，也可以用对象名访问

静态方法

只能用于访问静态属性
目的是在实例化对象前就能够访问静态属性
不能是抽象的
权限修饰符 static 返回值类型 方法名（形式参数列表）{}
使用类名.方法名使用
不调用不执行

使用规则（类内部）

• 仅能调用其他静态方法
• 仅能访问静态属性
• 不能使用this super

静态代码块

初始化静态属性
仅在该类被加载时执行一次
子类实例化对象顺序：父类静态代码块，子类静态代码块
父类构造方法，子类构造方法

Static final 修饰常量或不可重写的方法（全局变量）

异常

异常处理机制

捕获异常（try-catch-finally）
try{
//接受监视的程序块
//由catch中指定的程序处理
}catch(Exception e){
//处理异常
} finally{
//资源回收
}
抛出异常（throw,throws）
沿着调用层次向上传递异常

字符串

String类

值不可改变，用于字符串常量
字符串连接 concat(String str)
字符串查找 indexOf(String str)
lastIndexOf(String str)
字符串分割Split(String regex)
字符串比较compareTo(String str)，返回首个不相同字母的ASCII码差值
忽略大小写equalsIsIgnoreCase(String str)
字符串替换replace(char oldChar,char newChar)
字符串求子串 substring(int beginIndex,int endIndex)
大写 toUpperCase()
小写 toUpperCase()

StringBuffer类

对象的值可以修改，主要用于字符串做大量修改操作时
StringBuffer stringBuffer = new StringBuffer(“Hello”);
字符串拼接append（Object obj）
字符串删除delete(int start,int end)
字符串插入insert（int offset,Object obj）
字符串逆序reverse（）
转换为String对象：toString（）

容器

ArrayList 动态数组

ArrayList list = new ArrayList();
list.add(int index,E e)
list.add(e)
list.remove(int index)
list.get(int index);
list.set(int index,E e)
list.size

LinkedList 双向链表

HashSet

无序
不关心顺序，不允许重复
不能存储equals相同的数据
添加指定元素add（E e）
移除所有元素clear()
移除指定元素remove(Object o)
大小size()
判空isEmpty（）
TreeSet
升序
返回最低元素first（）
返回最高元素last（）

LinkedHashSet 以元素插入顺序

Map

Key不允许有重复，value允许有重复
hashMap是非线程安全的
hash.put(K key,V value)
hash.get(K key)
hash.containsKey(K key)
hash.containsValue(V value)
遍历map
Set keySet = hashMap.keySet();
for(Integer key:keySet){
Student value = hashMap.get(key);
System.out.println("key: “+key+”==value: "+value);
}

字节流

字节输入流读取字节InputStream

InputStream input = new InputStream(new File());
int i = 0；
while（i!=-1）{
	i=input.read();
}
Input.close();

字节输出流写入字节OutputStream
I

nputStream input = new InputStream(File ())
OutputStream output = newOutputStream(File())
Int i = 0;
While(i!=-1){
	i=intput.read();
	output.write(i);
}
Input.close();
Output.close();

字符流（纯文本）

• 字符输入流读取字符 Reader

Reader r = new FileReader(new File())
Char[] cbuf = new char[256]
Int len = r.read(cubf);
System.out.println(new String(cbuf,0,len));
r.close();

• 字符输出流写入字符 Writer

Writer w = new FileWriter（new File()）
w.write(cbuf);
w.close();