JAVA学习记录2(第二周)

一、抽象

(1).抽象类、抽象方法: abstract

        a.抽象类可以包含属性、方法、构造方法，不能被new，只能被子类调用。

        b.因为不能new，只能被子类调用，且必须被子类实现。

public abstract/*  定义抽象方法的类必须也是抽象类*/ class chouxiangfangfa {
	abstract public void shout() ;    //abstract定义抽象类
								      //第一：没有实现。第二：子类必须实现 
	public void run() {
		System.out.println("奔跑");      //抽象类也可以定义普通方法
	}
	
	public static void main(String[] args) {
		chouxiangfangfa a=new Dog();
		a.shout();
	}
}

class Dog extends chouxiangfangfa{
	public void shout() {
	System.out.println("嗨嗨嗨");	   //子类必须实现父类定义的抽象方法
	}
}

(2).接口: interface

        a.接口名：和类名采用相同命名机制。

        b.extends：接口可以实现多继承。

        c.接口里只能定义常量（因为很稳定）。

        d.接口里面全都是抽象方法，定义的时候使用 public interface+类名 / interface+类名，不用class。

/*public static final*/int max=100;      //被final修饰，常量
	/*public abstract*/void test01();		 //定义的方法被abstract修饰，抽象

二、内部类、冒泡排序、二分法查找、arrays

(1).内部类

public class neibulei {
	public static void main(String[] args) {
		//创建内部类对象
		Outer.Inner inner=new Outer().new Inner();      //new的时候必须先创建内部类
		inner.show();                                   //执行内部类中的代码
	}
}

class Outer{
	private int age=10;
	
	public void testOuter() {
		this.age=age;
	}
	//虽然类定义在外部类内部，但仍然是一个独立的类
	class Inner{
		int age=20;
		public void show() {
			int age=30;
			System.out.println("外部类成员变量age:"+Outer.this.age);//内部类可以直接访问外 
                                                                  //部类,尽管用private修饰
			System.out.println("内部类成员变量age"+this.age);
			System.out.println("局部变量age"+age);
		}
	}
}

(2).冒泡序列算法的实现

         核心点1是比较两个数值的大小，然后交换两个数的次序，并且两个数值不能被改变。但是如果一个变量a赋予了另一个变量b的值，只达到了单方向的交换次序效果，因为变量a的值被改变，所以此时需要引入一个新的变量t，提前将变量a的值储存到变量t中，在交换次序后再将变量t储存的值返还，这样就达到了交换次序且值不改变的效果。

         核心点2是嵌套循环，持续的让交换次序后的值与后面的数值作比较，直到达到要求。

for(int i=0;i<values.length-1;i++) {//外循环
			
		for(int j=0;j<values.length-1;j++) {
			//比较大小，换顺序
			
			if(values[j]>values[j+1]) {  //t=j  			
				temp =values[j];		//j=j+1
				values[j]=values[j+1];	//j+1=t=j
				values[j+1]=temp;
			}
			System.out.println(Arrays.toString(values));
		}
		System.out.println("######");
	}

(3).二分法查找

         原理是对一组一维数组中的数据先进行排序，然后找出中间数，让中间数给需要找的数值做比较，根据大小关系再在两边的数据中查找，再次二分，每次取一半，直到找到所求值或者没有找到。

(4).arrays

import java.util.Arrays;					//使用前先调包

public class arrays {
	public static void main(String[] args) {
		
		int[] a= {100,20,30,5,150,80,200};
		
		System.out.println(a);							 //打印数组地址
		
		System.out.println(Arrays.toString(a));          //打印数组内容
		Arrays.sort(a);
		System.out.println(Arrays.toString(a));          //给数组排序,排序后打印
		
		System.out.println(Arrays.binarySearch(a, 30));  //查找数据，输出索引位置
		System.out.println(Arrays.binarySearch(a, -30)); //如果没有查找到，就返回负数
	}

}

三、时间类

(1).date

        a.java用long类型的变量来表示时间。

        b.计算机元时间是1970年1月1日00:00:00，以毫秒为单位。

        c.调用时间类也需要架包。

import java.util.Date;

public class date {
	public static void main(String[] args) {
		long now=System.currentTimeMillis();  //获取当前时间
		System.out.println(now);
		Date d=new Date(2000);
		
		System.out.println(d);//
		
		System.out.println(d.getTime());     //获得毫秒数
		
	}
}

(2).dateFormat

//把时间对象按照"格式字符串指定的格式"转成相应的格式
	DateFormat df=new SimpleDateFormat("yyyy年MM月dd日hh:mm:ss");
	
	String str=df.format(new Date(4000000));
	System.out.println(str);
	
	DateFormat df2=new SimpleDateFormat("yyyy年MM月dd日hh时mm分ss秒");
	
	//Date date=df2.parse("1983年5月10日10时45分59秒");
	
	//测试其他的格式字符
	DateFormat df3=new SimpleDateFormat("D");//获得今年今天是这一年的第几天,查API表
	
	String str3=df3.format(new Date());
	System.out.println(str3);

四、File

        File类与文件相关，可以获得有关文件的信息，或者可以通过File的用法新建一个文件、文档等。同样需要架包。

        

import java.io.File;
import java.io.IOException;
import java.util.Date;

public class file {
	public static void main(String[] args) throws IOException {
		
	//File f=new File("a:a.txt");
	File f=new File("d:\\a.txt");
	System.out.println(f);
	f.renameTo(new File("d:/bb.txt"));
	
	
	System.out.println(System.getProperty("user.dir"));//用户空间
	
	File f2=new File("gg.txt");
	f2.createNewFile();
	//f2.delete;       删除文件
	
	System.out.println("File是否存在："+f2.exists());
	System.out.println("File是否是目录："+f2.isDirectory());
	System.out.println("File是否是文件："+f2.isFile());
	System.out.println("File最后修改时间："+new Date(f2.lastModified()));
	System.out.println("File的大小："+f2.length());
	System.out.println("File的文件名："+f2.getName());
	System.out.println("File的目录路径："+f2.getAbsolutePath());//获得绝对路径
	
	
	File f3=new File("d:/电影/华语/大陆");
	//boolean flag =f3.mkdir();  //目录结构中有一个不存在，则不会创建整个目录树   
	boolean flag =f3.mkdirs(); //用mkdirs则会创建整个目录树 
	System.out.println(flag);//创建失败
	   }
}

递归打印目录树

import java.io.File;

public class digui {
	public static void main(String[] args) {
		File f=new File("d:\\jcode");
		printFile(f,0);
	}


static void printFile(File file,int level) {
	
	for(int i=0;i<level;i++) {
		System.out.print("-");
	}
	
	System.out.println(file.getName());
	if(file.isDirectory()) {
		File[] files=file.listFiles();
		
		for(File temp:files) {
			printFile(temp,level+1);
		}
	}
	}
}

五、异常

(1).error

        这种通常是语法错误，在编译时编译器可以直接找到错误并且指出，如果不改正无法运行程序。

(2).expection

        expection通常在编译的时候发现不了错误，而当在运行程序时会指出异常，异常会生成一个对象，提交给jre。需要程序员自己找到解决方案修改，使代码能运行下去。

a.   try  catch

public class Checked {
	public static void main(String[] args) {
		
		FileReader reader=null;
		
		try {
		 reader=new FileReader("d:/b.txt");
		 System.out.println("step1");
			char c1=(char)reader.read();
			System.out.println(c1);
			
		}catch(FileNotFoundException e) {  //这个是子类
			 System.out.println("step2");//当reader行被执行，没有找到文件时，step1没有被执行,跳到catch
			e.printStackTrace();
		}catch(IOException e) {  //IO是父类，子类在前父类在后，否则异常可能被父类调，子类调不到
			e.printStackTrace();
		}finally {
			System.out.println("step3");//最终到这里执行了step3
			try {
			  if(reader!=null) {
				reader.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}


}

b.  Throws

        抛出，交给调用者处理，谁调用谁处理。

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class Throws {
	public static void main(String[] args) throws IOException {
		readMyFile1();
		}
	
	public static void readMyFile1() throws IOException {
		FileReader reader=null;
		 reader=new FileReader("d:/b.txt");
		 System.out.println("step1");
			char c1=(char)reader.read();
			System.out.println(c1);
						
			  if(reader!=null) {
				reader.close();
				}
			}
	}