Java课程笔记

该笔记实际完成时间为2020/6/28

数组

方法

类（class）

封装（private）

构造方法

String 类

String类的常用方法

1. 小写转换成大写
   

2. 求字符串长度
   

3. 判断两字符串是否相等
   判断str 在忽略大小写的前提下是否相等
   
   判断两字符串在不忽略大小写的前提下是否相等
   

4. 获取指定索引位置的字符
   

5. 获取第一个指定出现字符的索引
   

6. 获取最后一次出现指定字符的索引
   

7. 获取指定子串在字符串中出现的索引位置
   

8. 获取字符串中指定索引区间的子串
   

9. 将str中的所有‘I’替换成‘x’后输出

10. 将字符串str转换为字符数组，并将字符数组中的每个字符打印出来

this关键字

static关键字（全局、所有对象共享）

Static属性是类的全局属性，在对象实例化之前就存在了，所以可以用 类名.属性名 调用 且一次修改，所有对象的该属性均改变

继承

继承的基本实现(extends)

继承的进一步研究（先调用父类构造再调用子类构造）

default 就是什么都不写

范例——继承的应用

数组排序方法：

java.util.Arrays.sort(a);  //a：数组名

final关键字（类不能有子类，方法不能被复写，变量->常量）

多态

对象的多态性（向上/向下转型）

范例——不使用对象多态性实现功能

以上程序虽然实现了基本的要求，但是大家应该可以发现：如果按照以上的方式完成程序，则当产生了一个A类的子类时，fun（）方法就要重载一次，这样如果功能扩充，则必须要修改类本身，那么如果使用对象多态性完成呢？

范例——使用对象多态性实现此功能

class A{					//定义类A
	public void fun1(){		//定义fun1()方法
		System.out.println("A-->public void fun1(){}");
	}
	public void fun2(){
		this.fun1();			//调用fun1()方法
	}
};
class B extends A{
	public void fun1(){		//此方法被子类覆写了
		System.out.println("B-->public void fun1(){}");
	}
	public void fun3(){
		System.out.println("B-->public void fun3(){}");
	}
};
class C extends A{
	public void fun1(){		//此方法被子类覆写了
		System.out.println("C-->public void fun1(){}");
	}
	public void fun5(){
		System.out.println("C--public void fun5(){}");
	}
	public class PolDemo05(){
		public static void main(String asrgs[]){
			fun(new B());	//传递B的实例
			fun(new C());	//传递C的实例
		}
		public static void fun(A a){
			a.fun1();		//调用覆写父类中的fun1()方法
		}
	}
};

从以上程序可以发现，此时由于在fun()方法中使用了对象的多态性，所以可以接收任何的子类对象，这样无论子类如何增加，fun()方法都不用做任何的改变，因为一旦发生对象的向上转型关系后，调用的方法一定是被子类覆写过的方法。
子类的对象转换为父类类型后，父类对象不能调用子类的特有方法

instanceof 关键字 （判断对象是否属于某类）

抽象类的基本概念（abstract）

接口

接口的基本概念(interface,接口中的方法都是抽象方法，变量都是常量)

抽象类与接口的应用

实例分析：宠物商店

Object类（是所有类的父类，equals、toString方法）

一个设计良好的类，最好复写 equals（）、hashCode（）、toString（）方法

toString（）方法

equals（）方法

接收任意引用类型的对象（对象、接口、数组）

包装类（Integer、Character、Short等8种）

装箱与拆箱

为什么要装箱和拆箱？
装箱之后变成包装类，便于使用对象的方法（世间万物皆对象）
如下：

异常的基本概念（try…catch…finaly）

处理多种异常

可以使用

e.printStackTrace();

完全输出异常信息

异常的继承结构（可以使用Exception e 捕获所有异常）

throws与throw关键字

包的概念及使用

访问控制权限

JAVA IO

IO操作
方向不要弄反了 以程序为主体，输入就是进入程序
读取文件：输入流
写入文件：输出流
一、 字节文件的写入
a) 创建字节文件输出流

FileOutputStream output=new FileOutputStream(“data.txt”);

b) 获取要写入的数据

String  str=txtValue.getText();
byte[] b=str.getBytes();

c) 将数据写入输出流

output.write(b);

d) 关闭输出流

output.close();

二、 字节文件的读取

a)	从创建字节文件输入流

FileInputStream input=new FileOutStream(“Data.txt”);

b)	定义用于存放数据的字节数组

int len;
len=(int)input.lenth
byte[] b=new byte[len];

c)	读取数据存入字节数组

input.read(b);

d)	关闭输入流

input.close();

File 类

File.separator -> \ 或 /

JAVA IO——字节流与字符流

输入输出是以程序为出发点

字节流

输出字节流（OutputStream）抽象类

输入字节流（InputStream）抽象类

文件输入字节流（FileInputStream）

new String (b) -> 将byte数组变为字符串

read(b)方法的返回的是读取的长度
new String（b,0,len） 可以将b的从0到len截取转变为字符串

文件输出字节流（FileOutputStream）

只能输出byte（字节）数组，将字符串变为byte数组

对象的持久化（ObjectOutputStream、ObjectInputStream）

只能将支持 java.io.Serializable 接口的对象写入流中。每个 serializable 对象的类都被编码，编码内容包括类名和类签名、对象的字段值和数组值，以及从初始对象中引用的其他所有对象的闭包。（对类进行编码存储的意思，未编码的类不能存储）
需要存储的类，应该实现接口：Seriallizable，并声明序列号

public class Goods implements Serializable {
//该序列号的作用：用来验证读取对象时强制转换的类是否与写入对象时用到的类一致
private static final long serialVersionUID=-46843153134854L;  //数字可以任意
…………
}

步骤：
1、把对象写入对象输出流
2、把对象输出流附加到文件输出流

//对象持久化存储（保存到外部文件）实验：
FileOutputStream file=new FileOutputStream("Data.dat");//文件输出流
ObjectOutputStream objStream=new ObjectOutputStream(file);//对象输出流
objStream.writeObject(g);
objStream.flush();//把该流的缓存，全部存入
objStream.close();//关闭
file.close();

步骤：

1. 把文件读入文件输入流
2. 把文件出入流读入到对象输入流

//从外部文件读取数据到程序内部，这是输入流操作
Object obj;
FileInputStream file=new FileInputStream("Data.dat");
ObjectInputStream objStream=new ObjectInputStream(file);
obj= objStream.readObject();
if( obj.getClass().equals(Goods.class))//判断obj是否Goods类型
{
  Goods g=(Goods)obj;
  txtId.setText(g.getId()+"");
  txtName.setText(g.getName());
  txtBrand.setText(g.getBrand());
  txtPrice.setText(g.getPrice()+"");
}
else
  JOptionPane.showMessageDialog(this,"商品获取失败","数据错误",JOptionPane.ERROR_MESSAGE);

字符流

输出字节流（Writer）抽象类

输入字节流（Reader）抽象类

read© 方法只能传字符数组，不可以传byte数组

文件输入字符流（FileReader）

文件输出字符流（FileWriter）

JAVA 常用类库(上)

StringBuffer类（用于经常改变的字符串）

Math类（方法均为静态，直接通过类名调用）

Random类(随机数)

JAVA 常用类库（下）

Date类

Calendar类

SimpleDateFormat类

集合（上）

接口肯定是有抽象方法，需要借助实现这个接口的类去实现这些抽象方法
List与Set区别：
List是有序的、可重复的集合接口
Set是无序的、不可重复的集合接口

List（可重复的、存进去什么样就是什么样)

Vector类

也是集合类，和ArrayList类的操作基本一样，唯一的区别是vector类线程安全，ArrayList线程不安全

LinkedList类

链表存储方式,插入删除效率高
首部添加元素（.addFirst）
尾部（.addLast）

泛型（只能是引用类型，int要用Integer）

泛型存在的意义：集合不用泛型，那么对集合元素的操作就需要进行强制转换
迭代器：用于集合的快捷查询
只要是集合的操作（元素的增删改查），都要用到迭代器

Set

（不可重复的）(HashSet（存在什么位置不知道）、TreeSet（不管存入的顺序是什么，都会自己排好序）)

集合（下）

Iterator(迭代器)

只要是集合的操作（元素的增删改查），都要用到迭代器

Map(key-value)

HashMap（遍历需要通过key->set）

2020/6/28 学习笔记至此