Java进阶笔记03

final

public class test {

	/**
	 * @param args
	 * 
	 * final关键字
	 * 
	 * final修饰的类无法被继承
	 * final修饰的方法无法被覆盖
	 * final修饰的变量无法被第二次赋值
	 * 在构造方法调用结束之前 手动赋值 不能采用系统默认值
	 * final修饰的成员变量 一般和static一起用 称为常量 大写
	 * final 可以修饰实例化的变量 也是只能被赋值一次
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}

}
//final修饰的类无法被继承
//final class A {}
//class B extends A {}


//final修饰的方法无法被覆盖
//class A {
//	public final void m1(){}
//	
//}
//class B extends A {
//	public void m1(){}
//}

//final修饰的变量无法被第二次赋值
//class A{
//	public void m1(){
//		final int i;
//		i=1;
//		i=2; //不能重新赋值
//	}
//}

抽象类abstract

public abstract class test {

	/**
	 * @param args
	 * 
	 * 
	 * 抽象类  
	 * 无法被实例化
	 * 有构造方法 
	 * 抽象类的构造方法给子类用的
	 * 抽象类可以定义抽象方法
	 * 抽象方法必须出现在抽象类中 但是抽象类不一定要有抽象方法
	 * 非抽象的类继承抽象类 必须将抽象类覆盖 因为A不是抽象类但是继承了抽象类方法 而抽象方法必须出现在抽象类中 所以要将查询类中的抽象方法覆盖 重写
	 */
	
	test(){System.out.println("test");}
	
	abstract void m1(); //抽象方法
	
	
	
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		test t=new A(); //多态 抽象类中有构造方法 是给子类用的
	}

}
class A extends test{
	
	 void m1(){}; //重写父类中的抽象方法
	A(){System.out.println("A");}
}

equals 重写

public class test {

	/**
	 * @param args
	 * 
	 * 
	 * object 的equals 是比较内存地址  
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		A a1=new A(1,"A");
		A a2=new A(1,"A");

		System.out.println(a1.equals(a2));
	}

}
class A{
	int id;
	String name;
	public A(int id,String name){
		this.id=id;
		this.name=name;
	}
	
	public boolean equals(Object obj){ // 重写了object的equals方法 比较内容
		if(this==obj) return true;   //如果内存地址一样返回true
		
		if(obj instanceof A){ //如果obj是 A类型的 则强制类型转换
			A a=(A)obj;
			if(this.id==a.id && this.name.equals(a.name)){
				return true;
			}
		}
		
		return false;
		
	}
}

接口 insterface

public class mainclass {

	/**
	 * @param args
	 * 接口的目的 ：项目分层 开发效率提高  耦合度降低
	 * 如果一个项目分成两组进行 
	 * 第一组 只需要查看接口A中有需要什么功能    写在A1()中 implement A 实现    作用是打印
	 * 第二组 只需要查看接口A中有什么功能 直接在main调用就可
	 */
	public static void main(String[] args) {
		// 
		A a=new A1(); //多态

		a.m3();
		a.m31();
		a.m32();
	}

}

	/**
	 * @param args
	 * 接口：
	 * public interface 接口名（）
	 * 接口只能出现 常量 和抽象方法       
	 * 接口是完全抽象
	 * 没有构造方法   无法实例化
	 * 接口和接口之间可以多继承
	 * 一个类可以实现多个接口
	 * 一个类实现接口需要将接口中的所有方法重写 、覆盖
	 * 
	 */


public interface test{
	//常量必须定义 pubilic static final  
	public static final String I="i";
	int j=1; //接口中 可以省略pubilic static final 
	
	public abstract void m1(); //抽象方法必须 pubilc abstract 定义
	void m2(); //接口中可以省略pubilc abstract
}
interface A{
	void m3(); //需要实现打印
	void m31();
	void m32();
}
interface B{
	void m1();
}

interface C extends A,B{
	void m2();
} //一个接口可以继承多个接口


//一个类去实现接口 需要加关键字 implements  
//extends 单继承
//implements 多继承 所以写
class Myclass implements B,A{

	@Override
	public void m3() {
		// 一个类实现接口需要将接口中的所有方法重写 、覆盖
		System.out.println("m3");
	}

	@Override
	public void m1() {
		// 一个类实现接口需要将接口中的所有方法重写 、覆盖
		System.out.println("m1");
	}

	@Override
	public void m31() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void m32() {
		// TODO Auto-generated method stub
		
	} 
}
class Myclass2 implements C{

	@Override
	public void m3() {
		// 因为C接口继承A B 所以需要重新C A B 的抽象方法
		System.out.println("m3");
	}

	@Override
	public void m1() {
		// 
		System.out.println("m1");
	}

	@Override
	public void m2() {
		//
		System.out.println("m2");
	}

	@Override
	public void m31() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void m32() {
		// TODO Auto-generated method stub
		
	}
	
}


class A1 implements A{

	@Override
	public void m3() {
		// TODO Auto-generated method stub
		System.out.println("A1--m3");
	}

	@Override
	public void m31() {
		// TODO Auto-generated method stub
		System.out.println("A1--m31");
	}

	@Override
	public void m32() {
		// TODO Auto-generated method stub
		System.out.println("A1--m32");
	}
	
}

public_private_protected_default

修饰符
访问控制权限

一下可以访问：
public 本类中 同包中 子类 任何地方
protected 本类中 同包中 子类
default 本类中 同包中
private 本类中

垃圾回收机制（GC）与finalize

Person P=new Person()
P=null //使p成为空指针
System.gc()

class Person{
//重写object中的finalize方法
public void finaliz（） throws Throwable{
system.out.pringln(“被回收”)
}
}

打印输出 被回收

运行垃圾回收机制（gc）的时候 会调用finalize

异常

java异常都是类
在异常的对象中会携带一些信息给我们
我们可以通过异常对象把信息取出来

编译异常和运行异常都继承 Exception

编译异常程序员必须对其处理
1.捕捉 try…catch
2.抛出 在方法声明的位置写throws

throws

import java.io.FileInputStream;
import java.io.FileNotFoundException;


public class test {

	/**
	 * @param args
	 * 
	 * 
	 * 异常处理 
	 * 	throws 谁调用就推给谁
	 * try catch
	 * @throws FileNotFoundException 
	 */
	public static void main(String[] args) throws FileNotFoundException {
		// TODO Auto-generated method stub

		FileInputStream fis=new FileInputStream("d:/ab.txt");
	}

}

深入throws

import java.io.FileInputStream;
import java.io.FileNotFoundException;


public class test2 {

	/**
	 * @param args
	 * 深入throws
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		m1();
	}
	public static void m1(){
		
	}

	public static void m2(){
		
	}
	public static void m3() throws FileNotFoundException{
		new FileInputStream("d:/ab.txt");
	}
}

try catch

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;


public class test3 {

	/**
	 * @param args
	 * 
	 * 
	 * try catch
	 */
	public static void main(String[] args) {

//		try {
//			FileInputStream fis=new FileInputStream("d:/ab.txt"); //可能出现异常的代码
//
//		} catch (FileNotFoundException e) {
//
//			e.printStackTrace();       //异常处理代码
//		}
//		
		
		try {
			FileInputStream fis=new FileInputStream("d:/ab.txt"); //可能出现异常的代码

			fis.read();
		} catch (IOException e) {   //IOException包含FileNotFoundException

			e.printStackTrace();       //异常处理代码
		}
	}

}

try catch finally

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;


public class test5 {

	/**
	 * @param args
	 * 
	 * 
	 *try catch finally
	 *finally 是一定会执行的  只要没有退出JVM
	 */
	public static void main(String[] args) {

		
		try {
			FileInputStream fis=new FileInputStream("d:/ab.txt"); //可能出现异常的代码

		} catch (FileNotFoundException e) {   //IOException包含FileNotFoundException
			

//			e.printStackTrace(); //比getmess age更详细的报错
			String msg=e.getMessage();//异常处理代码
			System.out.println(msg);
		}finally{
			System.out.println("执行");
		}
		
		
		System.out.println(m1());
		
		
		
		
		
		

	}

	public static int m1(){
		int i=10;
		try{

			return i;
		}finally{
			
			i++;
			System.out.println("finally="+i);
		}
				
				
		
		
	}
}

getMessage_printStackTrace

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;


public class test4 {

	/**
	 * @param args
	 * 
	 * 
	 * getMessage
	 * printStackTrace
	 */
	public static void main(String[] args) {

		
		try {
			FileInputStream fis=new FileInputStream("d:/ab.txt"); //可能出现异常的代码

		} catch (FileNotFoundException e) {   //IOException包含FileNotFoundException
			

//			e.printStackTrace(); //比getmess age更详细的报错
			String msg=e.getMessage();//异常处理代码
			System.out.println(msg);
		}
	}

}

自定义异常

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;



public class IllegalNameExceptinon extends Exception{
	public IllegalNameExceptinon(){}
	public IllegalNameExceptinon(String msg){ super(msg);}
	
} 

class m1{

	/**
	 * @param args
	 * 自定义异常
	 * 
	 */
	public static void main(String[] args) {
		
		try {
			m2 m=new m2("123456");
		} catch (IllegalNameExceptinon e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		

	}

}
class m2{
	
	m2(String str) throws IllegalNameExceptinon{
		if(str.length()<6){
			
			
//			IllegalNameExceptinon e =new IllegalNameExceptinon("同户名长度少6位"); //创建异常
//			throw e; //手动抛出异常
			
			throw new IllegalNameExceptinon("同户名长度少6位");
			
		}
		System.out.println("成功");
	}
}

UML

extends继承 泛化
类和类 接口和接口 实线空心箭头指向父类

interface implement接口 实现
虚线空心箭头指向父接口

关联 同一等级 同一层次 盆友和我
实线的箭头
在当前类中含有其他类的引用
public class me{
Friend f;
}

public class Friend{
	
}

依赖 虚线箭头
class A{
void m1{
B b=new B() //依赖关系 局部变量
}
}
class B{

}

聚合 不在同一等级 整体和部分 汽车和轮胎
空心菱形

合成 和聚合相似 整体和部分紧密相连 人和四肢
实心菱形

数组

public class test {

	/**
	 * @param args
	 * 
	 * 数组
	 * 数组一旦创建长度无法改变
	 * 		System.arraycopy(src, srcPos, dest, destPos, length) 系统提供的数组拷贝
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
//
//		int[] i={1,2,3}; //静态声明数组
//		int i1[]={1,2,3};
//		int[] i2= new int[3]; //动态声明数组 默认值0
//		System.out.println(i1[0]);
//		int i2[]=new int[2]; 
		
		int[] a={1,11,111,1111};
		int[] j={2,22,222,2222};
		System.arraycopy(a, 0, j, 2, 1);
		
		for(int i=0;i<j.length;i++){System.out.println(j[i]);}

	}

}

main方法中的args

import com.sun.org.apache.xpath.internal.operations.Equals;


public class test2 {

	/**
	 * @param args
	 * 
	 * main方法中的args 是用来接收命令行参数的
		java array abc def aaa //以空格隔开
		输出三个字符元素
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		if(args.length!=2){
			System.out.println("需要输入 java test2 用户名 密码");
		}else if("cwz".equals(args[0]) && "123".equals(args[1])){ //"cwz".equals(args[0] 这种方式可以避免空指针异常
			System.out.println(args[0]+"欢迎！");
		}else{
			System.out.println("用户名密码错误");
		}
		
		
		
	}

}

数组工具类

import java.util.Arrays;


public class test3 {

	/**
	 * @param args
	 * 数组工具类
	 * Arrays
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		int a[]={2,4,1,5,3};
		
		Arrays.sort(a); //对数组进行排序
		
		System.out.println(Arrays.binarySearch(a, 3)); //对数组进行下标查找
		
		for(int i=0;i<a.length;i++){
			System.out.println(a[i]);
			
		}
		
	}

}

数组模拟栈

文件目录

SException

public class SException extends Exception {

	public SException(){}
	public SException(String msg){ super(msg);}
}

Stack

//栈：先进后出



public class Stack {

	Object[] elements; //使用数组存储数据
	
	int index;//栈的元素帧
	
	Stack(){ this(5); }  //调用有参构造方法
	
	Stack(int max){  elements = new Object[max];} //初始化栈容量5
	
	public void push(Object element) throws SException{ //压栈方法
		
		if(index==elements.length){
			throw new SException("满了");
		}
		elements[index++] = element;
		
	}
	
	public Object pop() throws SException{
		
		if(index==0){
			throw new SException("空了");
		}
		return elements[--index];
		
		
	}
}

User

public class User {

	String name;
	
	

	User(String name){
		this.name=name;
	}


	@Override
	public String toString() {
		return "User [name=" + name + "]";
	}
	
	
}

test

public class test {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Stack s =new Stack();
		
		User u1 =new User("1231");
		User u2 =new User("1232");
		User u3 =new User("1233");
		User u4 =new User("1234");
		User u5 =new User("1235");
		
		try {
			s.push(u1);
			s.push(u2);
			s.push(u3);
			s.push(u4);
			s.push(u5);
			
//			s.push(u5);//报错 栈满了
		} catch (SException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		
		try {
			System.out.println(s.pop().toString());
			System.out.println(s.pop()); //默认会调用tostring方法
			System.out.println(s.pop());
			System.out.println(s.pop());
			System.out.println(s.pop());
			
//			System.out.println(s.pop());//报错 栈空了
		} catch (SException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} 

		
	}

}