20190708学习笔记

20190708学习笔记

一、throws IOException

throws IOException是Java中的throws语句。
throws是方法可能抛出异常的声明。(用在声明方法时，表示该方法可能要抛出异常)
语法：(修饰符)(返回值类型)(方法名)([参数列表])[throws(异常类)]{…}

public void doA(int a) throws 
Exception1,Exception3{......}

举例：
throws
E1,E2,E3只是告诉程序这个方法可能会抛出这些异常，方法的调用者可能要处理这些异常，而这些异常E1，E2，E3可能是该函数体产生的。
throw则是明确了这个地方要抛出这个异常。
如：

void doA(int a) throws IOException,{
try{
......
}catch(Exception1 e){
throw e;
}catch(Exception2 e){
System.out.println("出错了！");
}
if(a!=b)
throw new Exception3("自定义异常");
}

二、读写文件

(1)FileInputStream

该流用于从文件读取数据，它的对象可以用关键字 new 来创建。
有多种构造方法可用来创建对象。

可以使用字符串类型的文件名来创建一个输入流对象来读取文件：
InputStream f = new FileInputStream(“C:/java/hello”);

也可以使用一个文件对象来创建一个输入流对象来读取文件。我们首先得使用 File() 方法来创建一个文件对象：
File f = new File(“C:/java/hello”);
InputStream out = new FileInputStream(f);

(2)FileOutputStream

该类用来创建一个文件并向文件中写数据。
如果该流在打开文件进行输出前，目标文件不存在，那么该流会创建该文件。
有两个构造方法可以用来创建 FileOutputStream 对象。

使用字符串类型的文件名来创建一个输出流对象：
OutputStream f = new FileOutputStream(“C:/java/hello”)

也可以使用一个文件对象来创建一个输出流来写文件。我们首先得使用File()方法来创建一个文件对象：
File f = new File(“C:/java/hello”);
OutputStream f = new FileOutputStream(f);

package com;

import java.io.IOException;
import java.io.*;

public class FileAndStream {
public static void main(String args[]) throws IOException{
	try {
		byte bWrite[]= {11,21,3,40,5};
		OutputStream os=new FileOutputStream("test.txt");
		for(int x=0;x<bWrite.length;x++) {
			os.write(bWrite[x]);
		}
		os.close();
	}catch(IOException e){
		System.out.println("Exception");
	}
	
 }
}

输出结果(有乱码）：

输出：FileOuputStream + OutputStreamWriter
写入：FileInputStream + InputStreamReader

package com;

import java.io.IOException;
import java.io.*;

public class FileAndStream {
public static void main(String args[]) throws IOException{
	
	File f=new File("a.txt");
	FileOutputStream fop=new FileOutputStream(f);
	//构建FileOutputStream对象，文件不存在时自动新建
	
	OutputStreamWriter writer=new OutputStreamWriter(fop,"UTF-8");
	//构建OutputStreamWrite对象，参数可以指定编码
	
	writer.append("中文输入：");
	//写到缓冲区
	
	writer.append("\r\n");
	writer.append("English");
	
	writer.close();
	//关闭写入流，同时会把缓冲区内容写入文件
	
	fop.close();
	//关闭输出流，释放系统资源
	
	FileInputStream fip=new FileInputStream(f);
	//构建FileInputStream对象
	
	InputStreamReader reader=new InputStreamReader(fip,"UTF-8");
	//构建InputStreamReader对象，编码与写入的相同
	
	StringBuffer sb=new StringBuffer();
	while(reader.ready()) {
		sb.append((char)reader.read());
		//转成char加到StringBuffer对象中
	}
	System.out.println(sb.toString());
	reader.close();
	//关闭读取流
	
	fip.close();
	//关闭输入流，释放系统资源
 }
}

用这种方式输出就没有乱码了

三、继承

（1）动物类

要开发动物类，其中动物分别企鹅以及老鼠，要求如下：
企鹅：属性（姓名，id），方法（吃，睡，自我介绍）
老鼠：属性（姓名，id），方法（吃，睡，自我介绍）
企鹅类：

public class Penguin{
	private String name;
	private int id;
	public Penguin(String myName,int myid) {
		name=myName;
		id=myid;
	}
	public void eat() {
		System.out.println(name+"正在吃");
	}
	public void sleep() {
		System.out.println(name+"正在睡");
	}
	public void introduction() {
		System.out.println("大家好！我是"+id+"号"+name);
	}
}

老鼠类：

public class Mouse { 
    private String name; 
    private int id; 
    public Mouse(String myName, int  myid) { 
        name = myName; 
        id = myid; 
    } 
    public void eat(){ 
        System.out.println(name+"正在吃"); 
    }
    public void sleep(){
        System.out.println(name+"正在睡");
    }
    public void introduction() { 
        System.out.println("大家好！我是" + id + "号" + name + "."); 
    } 
}

可以发现其实这两个类的代码存在重复了，代码多又难维护，为了解决这种情况，可以用到继承。

写一个公共的父类：

public class Animal{
	 private String name;  
	    private int id; 
	    public Animal(String myName, int myid) { 
	        name = myName; 
	        id = myid;
	    } 
	    public void eat(){ 
	        System.out.println(name+"正在吃"); 
	    }
	    public void sleep(){
	        System.out.println(name+"正在睡");
	    }
	    public void introduction() { 
	        System.out.println("大家好！我是"+ id + "号" + name + "."); 
	    } 
}

有了公共类企鹅类就可以改写成：

public class Penguin extends Animal{

	public Penguin(String myName, int myid) {
		super(myName, myid);
	}
	
}

老鼠类改写成：

public class Mouse extends Animal{

	public Mouse(String myName, int myid) {
		super(myName, myid);
	}
}

（2）继承关键字extends、implements

extends关键字：
（只能继承一个类）

public class Animal{
......
}
public class Penguin extends Animal{

}

implements关键字：
（可以继承多个接口）

public interface A{
......
}
public interface B{
......
}
public class C implements A,B{
}

（3）关键字super和this

class Animals{
	void eat() {
		System.out.println("animal:eat");
	}
}

class Dog extends Animals{
	void eat() {
		System.out.println("dog:eat");
	}
	void eatTest() {
		this.eat();//调用自己的方法
		super.eat();//调用父类的方法
	}
}

public class Penguin{
	public static void main(String[] args) {
		Animals a=new Animals();
		a.eat();
		Dog d=new Dog();
		d.eatTest();
	}
}

输出结果：

（4）final关键字

final 关键字声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写。
声明类：
final class 类名{ //类体 }
声明方法：
修饰符(public/private/default/protexted)final 返回值类型 方法名(){//方法体 }