Java进阶笔记01

java语言特性 加载与执行

可移植性

JDK java工具箱
JRE 运行环境
JVM java虚拟机

健壮性

JVM自动垃圾回收 不用手动释放

加载执行

编译阶段：
.java编译.class
运行阶段：
.class装载到JVM虚拟机 虚拟机编译成二进制

环境变量 Windows 搜索path
javac 是编译文件 javac d:…
需要编译带包名的.java文件 javac -d . ***.java

java 是运行文件 跟类名 java HelloWord
需要运行带包名的.class文件 java ***.***.***.HelloWord

pubilc class与class

.java文件 可以有多个class 可以没有pubilc class
如果有 只能有一个 并且跟文件名保持一致

return break continue

return: 结束整个方法
break：结束当前离他最近的循环
continue:结束本一次循环 直接进入下一次循环

break可以指定结束某个循环
退出名字为abc的循环:
abc:for(){
for(){
if(){
break abc;
}
}

}

面向对象

面向过程（蛋炒饭）
面向对象（盖饭）
面向对象的特征：封装 继承 多态

Switch

public class switchtest {

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

		double a=11.1;
		int b=(int) (a/10);
		switch (b){
		case 1:
			System.out.println("10-19");
			break;
		default:
			System.out.println("2");
		}

			
	}

}

方法的递归

public class Test {

	/**
	 * @param args
	 * 
	 * 递归就是方法自己调用自己
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		int n=5;
		System.out.println(A.method(n));
		System.out.println(B.method2(n));
	}


}
//1-N的和
class A{
	public static int method(int s) {
		if(s==1){
			return 1;
		}else{
			return s+method(s-1);
		}
	}

}
//1-N的阶乘
class B{
	public static int method2(int s) {
		if(s==1){
			return 1;
		}else{
			return s*method2(s-1);
		}
	}
	
	
	
}

方法的使用

public class Method {

	/**
	 * @param args
	 * 
	 * class 类的使用
	 */
	public static void main(String[] args) {

		method1();//可以省略类名. 因为在本类中调用
		
		a.metho2();//这里不能省略a. 因为不在本类
		System.out.println(a.metho(0));//方法的重载使用
		System.out.println(a.metho(null));//方法的重载使用
	}
	//	方法的定义
	public static void method1(){
		System.out.println("111");
	}
}


class a{
	public static void metho2(){
		System.out.println("222");
	}
	
//	方法的重载 返回值不同            类型不一样    个数不一样  顺序不一样 都可以构成重载
	public static int metho(int i){
		return i;
	}
	public static String metho(String i){
		return i;
	}

}

数据结构 算法

冒泡排序

public class test {

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

		int arr[]={10,2,4,60,3};
		
		for(int i=arr.length-1;i>0;i--){
			for(int j=0;j<i;j++){
				if(arr[j]>arr[j+1]){
					int temp;
					temp=arr[j];
					arr[j]=arr[j+1];
					arr[j+1]=temp;
				}

				
			}
		}
			
		for(int i1=0;i1<arr.length;i1++){
			System.out.print(arr[i1]+"-");
		
			
		}
	}

}
		

选择排序

public class test {

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

		int arr[]={2,3,10,1,9};
		
		for(int i=0;i<arr.length-1;i++){
			int min=i;
			
			for(int j=i+1;j<arr.length;j++){
				if(arr[min]>arr[j]){
					min=j;
				}
		
			}
			
			if(min!=i){
				int temp;
				temp=arr[min];
				arr[min]=arr[i];
				arr[i]=temp;
				
			}
		}
		
		for(int i=0;i<arr.length;i++){
			System.out.println(arr[i]);
			
		}
	}

}

折半查找

public class test {

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

		int i[]={1,2,3,4,5,6,7,8,9,10};
		int destElement=10;
		int index=binarySearch(i,destElement);
		
		System.out.println((destElement==-1)?"不存在":"下标是"+index);
	}

	private static int binarySearch(int[] i, int destElement) {
		// TODO Auto-generated method stub
		int begin=0;
		int end=i.length-1;
		
		while(begin <= end){
			int mid=(begin+end)/2;
			
			if(i[mid]==destElement){
				return mid;
				
			}else if(i[mid]<destElement){
				begin=mid+1;
				
			}else if(i[mid]>destElement){
				end=mid-1;
			}
			
		}

		return -1;
	}

}

栈

1.方法在调用的时候才会在内存中分配空间
2.没有调用是不会分配空间
3.方法在调用的时候在’栈’中分配空间。（JVM内存中有一块是栈内存）
4.方法调用就是进栈
5.方法结束就是出栈