Learn Java until I am Die...

Jb01_HelloWorld.java

@@ -0,0 +1,9 @@
+public class Jb01_HelloWorld	//类名与文件名保持一致，由26个大小写字母、数字及_$组成。不能以数字开头，禁止使用关键字，
+{
+	//定义主函数
+	public static void main(String[] args)	//args即arguments
+	{
+		System.out.println("HelloWorld");	//打印输出HelloWorld,ln表示换行!
+		//public class等表示关键字，由Java定义
+	}
+}

Jb02_VarDemo1.java

@@ -0,0 +1,31 @@
+public class Jb02_VarDemo1
+{
+	public static void main(String[] args) 
+	{
+		/*
+		byte	1字节
+		boolean 1字节
+		short	2字节
+		char	2字节
+		int		4字节
+		float	4字节
+		long	8字节
+		double	8字节
+		*/
+		//数据类型 变量名 = 初始化值;
+		byte b = 1;	//定义变量b,初始化值为1
+		short s = 2;
+		int i = 3;
+		long l = 4;
+		float f = 5.5f;
+		double d = 6.6;
+		char c = 'c';
+		boolean bo = true;
+		bo = false;
+		{
+			int x = 9;
+			System.out.println("x");	//局部变量x
+		}
+		System.out.println(c);
+	}
+}

Jb03_VarDemo2.java

@@ -0,0 +1,23 @@
+public class Jb03_VarDemo2
+{
+	public static void main(String[] args) 
+	{
+		/*
+		int x = 1;
+		x = x + 1;
+		byte b = 2;
+		x = x + b;	//自动类型转换
+		b = (byte)(b + 2);	//强制类型转换
+		System.out.println(b);	
+		*/
+		byte b = 1;
+		byte b1 = 2;
+		byte b2 = 3;
+	//	b = b1 + b2;	b1与b2是变量，无法判断并赋值
+		
+		int x;
+		int x1 = Integer.MAX_VALUE;
+		int x2 = 2;
+		x = x1 + x2;	//int是默认类型，自动强制转换
+	}
+}

Jb04_Operate2.java

@@ -0,0 +1,10 @@
+public class Jb04_Operate2
+{
+	public static void main(String[] args) 
+	{
+		short s = 1;
+		s+=2;	//自动转换 相当于s = (short)(s+2);
+	//	s = s+2;	右边s是变量，可能会出现精度丢失。
+		System.out.println(s);
+	}
+}

Jb05_Operate3.java

@@ -0,0 +1,23 @@
+public class Jb05_Operate3
+{
+	public static void main(String[] args) 
+	{
+		//比较运算符，结果只能是true或false
+		/*
+		逻辑运算符，用于连接boolean类型的表达式
+		&运算符特点：运算的两边只有一个是false，结果是false；两边都为true，结果是true
+
+		|运算特点：两边有一个是true，结果是true;两边都是false，结果是false
+
+		^运算特点：两边结果相同，结果是false；两边结果不同，结果是true
+
+		!运算特点：非真则假，非假则真
+
+		&&运算特点：运算结果和&相同。区别：左边是false时，右边不参与运算
+
+		||运算特点：运算结果和|相同。区别：左边是true时，右边不参与运算
+
+		位运算：对二进制进行运算
+		*/
+	}
+}

Jb06_Operate4.java

@@ -0,0 +1,11 @@
+public class Jb06_Operate4
+{
+	public static void main(String[] args) 
+	{
+	//	三元运算符：（条件表达式）?表达式1:表达式2;
+	//	如果条件表达式结果是true，结果是表达式1。否则结果是表达式2。
+		int x = 1,y;
+		y = (x>3)?21:27;
+		System.out.println(y);
+	}
+}

Jb07_IfDemo.java

@@ -0,0 +1,28 @@
+public class Jb07_IfDemo
+{
+	public static void main(String[] args) 
+	{
+	//	判断结构：
+	//	当if else运算后，由具体结果时，可简化成三元运算符
+
+		int x = 1;
+		if (x>3)
+		{
+			System.out.println("yeah");
+		}
+		else if (x>2)
+		{
+			System.out.println("OK");
+		}
+		else
+		{
+			System.out.pintln("欧了");
+		}
+		//局部代码块可定义局部变量的生命周期。
+		{
+			int y = 3;
+		}
+
+		System.out.println("over"+y);	//y在局部代码块里，会出现错误。
+	}
+}

Jb08_IfTest.java

@@ -0,0 +1,42 @@
+public class Jb08_IfTest
+{
+	public static void main(String[] args) 
+	{
+	//	需求：用户输入具体数值，判断出对应的星期
+		int week = 3;
+		if (week==1)
+		{
+			System.out.println(week+"是星期一");
+		}
+		else if (week==2)
+		{
+			System.out.println(week+"是星期二");
+		}
+		else if (week==3)
+		{
+			System.out.println(week+"是星期三");
+		}else
+		{
+			System.out.println("输入错误，请输入1-3的数字");
+		}
+	
+	//	需求：根据用户输入数值，输出对应的季度。
+		int month = 3;
+		if (month<1 || month>12)
+		{
+			System.out.println("没有此季节");
+		}
+		else if (month>=3 && month<=5)
+		{
+			System.out.println(month+"月是春季");
+		}
+		else if (month>=6 && month<=8)
+		{
+			System.out.println(month+"月是夏季");
+		}
+		else
+		{
+			System.out.println(month+"月是冬季");
+		}
+	}
+}

Jb09_SwitchDemo.java

@@ -0,0 +1,45 @@
+public class Jb09_SwitchDemo
+{
+	public static void main(String[] args) 
+	{
+	//	选择结构：Switch
+	/*
+		switch (表达式)
+		{
+		case 取值1:
+			执行语句;
+			break;
+		case 取值2:
+			执行语句2;
+			break;
+			......
+		default:
+			执行语句;
+			break;
+		}
+	*/
+		//根据输入数字，输出对应季节
+		int month = 3;
+		switch (month)
+		{
+		case 3:
+		case 4:
+		case 5:
+			System.out.println("是春季");
+			break;
+		default:
+			System.out.println("没有对应的季节");
+			break;	//此处break可省略
+		}
+		/*
+	if与switch的应用场景：
+if:
+	1、对具体的值进行判断
+	2、对区间判断
+	3、对运算结果是boolean类型的表达式进行判断
+switch：
+	1、对具体的值进行判断
+	2、值的个数是固定的，对于只有几个固定的数值进行判断，建议用switch，效率更高。
+	*/
+	}
+}

Jb10_WhileDemo.java

@@ -0,0 +1,45 @@
+public class Jb10_WhileDemo
+{
+	public static void main(String[] args) 
+	{
+	//	循环结构
+	/*
+	while语句格式：
+	while (条件表达式)
+	{
+		执行语句;
+	}
+	do
+	{
+		执行语句;
+	}
+	while (条件表达式);
+	do while特点：
+		无论条件是否满足，循环体至少执行一次
+	*/
+	/*
+		int x = 1;
+		do
+		{	
+			System.out.println("x="+x);
+			x++;
+		}
+		while (x<2);
+
+		int y = 1;
+		while (y<2)
+		{
+			System.out.println("y="+y);
+		}
+		*/
+		//获取1到100数字的和:————累加思想
+		int x = 1;
+		int sum = 0;
+		while (x<=100)
+		{
+			sum+=x;
+			x++;
+		}
+		System.out.println("sum="+sum);
+	}
+}

Jb11_WhileTest.java

@@ -0,0 +1,18 @@
+public class Jb11_WhileTest
+{
+	public static void main(String[] args) 
+	{
+		//输出1到100之间里，2的倍数有几个。计数器思想
+		int x = 1;
+		int count = 0;
+		while (x<=100)
+		{
+			if (x%2==0)
+			{
+				count++;
+			}
+			x++;
+		}
+		System.out.println("1~100之间2的倍数个数总共是"+count);
+	}
+}

Jb12_ForDemo.java

@@ -0,0 +1,23 @@
+public class Jb12_ForDemo
+{
+	public static void main(String[] args) 
+	{
+	/*
+	for (初始化表达式;循环条件表达式;循环后的操作表达式)
+	{
+		执行语句;(循环体)
+	}
+	while与for可互换，
+	区别：for为循环定义的变量在循环结束后就从内存释放
+	while循环使用的变量在循环结束后仍可以继续使用
+	*/
+	//for完成累加
+		int sum = 0;
+		for (int x=1; x<=100; x++)
+		{
+			sum+=x;
+		}
+		System.out.println(sum);
+		//System.out.println(x);	此处会提示找不到变量x错误，因x已在内存中释放	
+	}
+}

Jb13_ForTest.java

@@ -0,0 +1,51 @@
+public class Jb13_ForTest
+{
+	public static void main(String[] args) 
+	{
+		/*打印矩形,不成文规律：外循环控制行，内循环控制列
+		for (int x=1;x<=4; x++)
+		{
+			for (int y=1;y<=4 ;y++ )
+			{
+				System.out.print("*");
+			}
+			System.out.println("*");
+		}
+		*/
+
+		/*打印倒三角
+		//int z = 5;
+		for (int x=1;x<=5; x++)	//1-5 1-4 1-3	//1-5 2-5 3-5
+		{
+			for (int y=x;y<=5 ;y++ )
+			{
+				System.out.print("*");
+			}
+			System.out.println("*");
+				//z--;
+		}
+		*/
+
+		/*
+		for (int x=1;x<=5; x++)
+		{
+			for (int y=5;y>=x ;y-- )
+			{
+				System.out.print(y);
+			}
+			System.out.println();
+		}
+		*/
+
+		/*打印99乘法表 \n:回车 \t：制表符 \b：退格 \r：按下回车键
+		for (int x=1;x<=9 ;x++ )
+		{
+			for (int y=1;y<=x ;y++ )
+			{
+				System.out.print(y+"*"+x+"="+x*y+"\t");
+			}
+			System.out.println();
+		}
+		*/
+	}
+}

Jb14_Function.java

@@ -0,0 +1,21 @@
+public class Jb14_Function
+{
+	public static void main(String[] args) 
+	{
+		/*函数格式：
+		修饰符 返回值类型 函数名(参数类型 形式参数1,参数类型 形式参数2,.......)
+			{
+				执行语句;
+				return返回值;
+			}
+		*/
+		//定义一个功能，求两数之和
+		int sum = add(6,2);
+		System.out.println(sum);
+	}
+	public static int add(int a,int b)
+		{
+			int sum = a+b;
+			return sum;
+		}
+}

Jb15_Function2.java

@@ -0,0 +1,41 @@
+public class Jb15_Function2
+{
+	public static void main(String[] args) 
+	{
+		//draw(7,8);
+		getLevel(99);
+	}
+	/*定义输出矩形函数功能
+	public static void draw(int row,int col)
+	{
+		for (int x=1;x<=row ;x++ )
+		{
+			for (int y=1;y<=col ;y++ )
+			{
+				System.out.print("*");
+			}
+			System.out.println();
+		}
+		return;	//此处return可省略，即返回值具体类型不确定，使用void时，可省略return
+	}
+	*/
+	//根据分数输出对应等级
+	public static void getLevel(int grade)
+	{
+		if (grade<0 || grade>100)
+		{
+			System.out.println("错误");
+		}
+		else if (grade>=90 && grade<=100)
+		{
+			System.out.println("A");
+		}
+		else if (grade>=60 && grade<=89)
+		{
+			System.out.println("B");
+		}
+		else
+			System.out.println("C");
+		return;
+	}
+}

Jb16_Function3.java

@@ -0,0 +1,18 @@
+public class Jb16_Function3
+{
+	public static void main(String[] args) 
+	{
+	/*函数的重载概念：在同一类中，允许一个以上的同名函数，只要它们的参数个数或参数类型不同即可。
+	重载特点：与返回值类型无关，只看参数列表*/
+	}
+	//两小数之和
+	public static double add(double a,double b)
+	{
+		return a+b;
+	}
+	//三整数之和
+	public static double add(int a,int b,int c)
+	{
+		return a+b+c;
+	}
+}

Jb17_ArrDemo.java

@@ -0,0 +1,34 @@
+public class Jb17_ArrDemo
+{
+	public static void main(String[] args) 
+	{
+		/*数组定义格式1：
+		元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
+		格式2：
+		元素类型[] 数组名 = new 元素类型[] {元素,元素,........};
+		数组的操作，对角标进行操作，从0角标开始。
+		*/
+		//int [] arr = new int[]{2,54,4,5,4,4,5,79};
+		int [] arr = {-2,-5,-79,-9};
+		for (int x=0;x<arr.length ; x++)
+		{
+			System.out.println("arr["+x+"] = "+arr[x]);
+		}
+
+		int max = getMax(arr);
+		System.out.println("最大值是"+max);
+	}
+	//定义功能求数组最大值
+	public static int getMax(int[] arr)
+	{
+		int max = arr[0];
+		for (int x=1 ;x<arr.length ;x++ )
+		{
+			if (arr[x]>max)
+			{
+				max = arr[x];
+			}
+		}
+		return max;
+	}
+}

Jb18_ArrSort.java

@@ -0,0 +1,58 @@
+import java.util.*;
+
+public class Jb18_ArrSort
+{
+    public static void main(String[] args)
+    {
+        int[] arr = {71,15,4,50,54,55,5,45,454,496,78,};
+        ergodic(arr);
+        //selectSort(arr);	//调用选择排序
+        //bubbleSort(arr);	//调用冒泡排序
+        Arrays.sort(arr);	//调用Java定义好的排序功能
+        ergodic(arr);
+    }
+    //遍历数组
+    public static void ergodic(int[] arr)
+    {
+        for (int x=0; x<arr.length; x++)
+        {
+            if (x!=arr.length-1)
+                System.out.print(arr[x]+",");
+            else
+                System.out.println(arr[x]);
+        }
+    }
+    /*选择排序
+    public static void selectSort(int[] arr)
+    {
+    	for (int x=0;x<arr.length-1 ;x++ )
+    	{
+    		for (int y=x+1;y<arr.length ; y++)
+    		{
+    			if (arr[x]>arr[y])
+    			{
+    				int temp = arr[x];
+    				arr[x] = arr[y];
+    				arr[y] = temp;
+    			}
+    		}
+    	}
+    }
+    */
+    //冒泡排序
+    public static void bubbleSort(int[] arr)
+    {
+        for (int x=0; x<arr.length-1; x++)
+        {
+            for (int y=0;y<arr.length-x-1 ;y++ )	//-x代表
+            {
+                if (arr[y]>arr[y+1])
+                {
+                    int temp = arr[y];
+                    arr[y] = arr[y+1];
+                    arr[y+1] = temp;
+                }
+            }
+        }
+    }
+}

Jb19_ArrSearch.java

@@ -0,0 +1,59 @@
+public class Jb19_ArrSearch
+{
+	public static void main(String[] args) 
+	{
+		int[] arr = {0,1,2,3,4,5,6,7,8,9};
+		int index = binarySearch_2(arr,7);
+		System.out.println(index);
+	}
+	/*数组查找功能
+	public static int getIndex(int[] arr,int key)
+	{
+		for (int x=0;x<arr.length ;x++ )
+		{
+			if (arr[x]==key)
+			{
+				return x;
+			}
+		}
+		return -1;
+	}
+	*/
+	//二分查找法
+	public static int binarySearch(int arr[],int key)
+	{
+		int max,min,mid;
+		min = 0;
+		max = arr.length-1;
+		mid = (max+min)/2;
+		while (arr[mid]!=key)
+		{
+			if (key>arr[mid])
+				min = mid + 1;
+			else if (key<arr[mid])
+				max = mid - 1;
+			if (max<min)
+				return -1;
+			mid = (max+min)/2;
+		}
+		return mid;
+	}
+	//第二种写法
+	public static int binarySearch_2(int[] arr,int key)
+	{
+		int max,mid,min;
+		min = 0;
+		max = arr.length-1;
+		while (min<=max)
+		{
+			mid = (max+min)>>1;	//右移一位相当于除以2的一次幂
+			if(key>arr[mid])
+				min = mid + 1;
+			else if(key<arr[mid])
+				max = mid - 1;
+			else
+				return mid;
+		}
+		return -1;
+	}
+}

Jb20_Object.java

@@ -0,0 +1,65 @@
+public class Jb20_Object
+{
+	public static void main(String[] args) 
+	{
+		Car benz = new Car();	//通过new关键字创建一个Car的实例
+		benz.wheel = 4;
+		benz.color = "green";
+		benz.run();	//调用对象中的run功能
+
+		Car gtr1 = new Car();
+		Car gtr2 = new Car();
+		show(gtr1);
+		show(gtr2);
+	}
+	/*
+	匿名对象
+	Car benz = new Car();
+	benz.run();
+	匿名对象写法：
+	new Car().run();
+
+	对象对方法只有一次调用的时候，可简化为匿名对象
+	匿名对象可以作为实际参数进行传递
+	Car gtr1 = new Car();
+	show(gtr1);
+	show(new new Car());
+	*/
+
+	public static void show(Car car)	//类类型的变量一定指向对象，否则就为null
+	{
+		car.wheel = 6;
+		car.color = "red";
+		System.out.println(car.wheel+"\t"+car.color);
+	}
+}
+
+class Car
+{
+	int wheel;	//int wheel = 4;显示初始化值为4
+	String color;
+	void run()
+	{
+		//int num = 6;	局部变量，打印num为6
+		System.out.println(wheel+"\t"+color);
+	}
+}
+/*
+类是对象的实例化体现
+定义类：定义类中的成员
+成员：成员变量>>:属性，成员函数>>:行为
+
+成员变量与局部变量的区别：
+成员变量定义在类中，所在类中都可以访问
+局部变量定义在函数、语句和局部代码块中，只在所属区域有效
+
+成员变量存在堆内存的对象里
+局部变量存在栈内存的方法里
+
+成员变量：对象创建而存在，对象消失而消失
+局部变量：所属区域执行而存在，所属区域结束而消失
+
+成员变量都有默认初始化值
+局部变量没有默认初始化值
+
+*/

Jb21_DataTransmit.java

@@ -0,0 +1,30 @@
+public class Jb21_DataTransmit
+{
+	//基本数据类型参数传递
+	public static void main(String[] args) 
+	{
+		int x = 1;
+		show(x);
+		System.out.println(x);	//输出1
+	}
+	public static void show(int x)
+	{
+		x = 2;
+	}
+}
+//引用数据类型参数传递
+class Demo
+{
+	int x = 1;
+	public static void main(String[] args) 
+	{
+		Demo data = new Demo();
+		data.x = 3;
+		show(data);
+		System.out.println(data.x);	//输出为2
+	}
+	public static void show(Demo data)
+	{
+		data.x = 2;
+	}
+}

Jb22_EncampsObj.java

@@ -0,0 +1,28 @@
+public class Jb22_EncampsObj
+{
+	//面向对象的封装
+	public static void main(String[] args) 
+	{
+		Person xiaoMing = new Person();
+		xiaoMing.getAge(21);
+		xiaoMing.speak();
+	}
+}
+
+class Person
+{
+	private int age;
+	public void getAge(int num)
+	{
+		if(num>=0 && num<=150)
+		{
+			age = num;
+		}
+		else
+			System.out.println("错误，输出年龄范围在0~150");
+	}
+	void speak()
+	{
+		System.out.println("年龄是"+age);
+	}
+}

Jb23_ArrTool.java

@@ -0,0 +1,76 @@
+/**
+文档注释
+创建一个操作数组的工具类，包含对数组操作的函数
+@author XiaoMing
+@version V1.0
+*/
+
+public class Jb23_ArrTool
+{
+	/*该类的方法都是静态的，固该类不需要创建对象，节省内存
+	为了确保不让其他程序创建该类对象，将该类的构造函数进行初始化。*/
+    private Jb23_ArrTool(){}
+
+	/**获取整数数组的最大值
+	@param arr 接收一个元素为int类型的数组
+	@return 该数组中的最大元素值*/
+    public static int getMax(int[] arr)
+    {
+        int maxIndex = 0;
+        for (int x=1;x<arr.length ;x++ )
+        {
+            if (arr[x]>arr[maxIndex])
+            {
+                arr[maxIndex] = arr[x];
+            }
+        }
+        return arr[maxIndex];
+    }
+	//数组选择排序
+	public static void selectSort(int[] arr)
+	{
+		for (int x=0;x<arr.length-1 ;x++ )
+		{
+			for (int y=x+1; y<arr.length; y++)
+			{
+				if (arr[x]>arr[y])
+				{
+					swap(arr,x,y);
+				}
+			}
+		}
+	}
+	//数组元素的位置换位
+	public static void swap (int[] arr,int x,int y)
+	{
+		int temp = arr[x];
+		arr[x] = arr[y];
+		arr[y] = temp;
+	}
+	//获取指定元素在指定数组的角标，不存在返回-1
+	public static int getIndex(int[] arr,int key)
+	{
+		for (int x=0;x<arr.length ;x++ )
+		{
+			if (arr[x]==key)
+			{
+				return x;
+			}
+		}
+		return -1;
+	}
+	//将int数组转换成字符串
+	public static String arrayToString(int[] arr)
+	{
+		String s = "";
+		for (int x=0; x<arr.length;x++ )
+		{
+			if (x!=arr.length-1)
+				s = s + arr[x]+",";
+			else
+				s = s + arr[x];
+		}
+		return s;
+	}
+}
+

Jb23_ArrToolDemo.java

@@ -0,0 +1,12 @@
+public class Jb23_ArrToolDemo
+{
+	public static void main(String[] args) 
+	{
+		int[] arr = {0,1,32,5,8,4,9};
+		int index = Jb23_ArrTool.getIndex(arr,43);	//获取数字43在数组中的角标
+		System.out.println(index);
+
+		int max = getMax(arr);
+        System.out.println("数组最大值是"+max);
+	}
+}

Jb24_Single.java

@@ -0,0 +1,20 @@
+public class Jb24_Single
+{
+	//单例设计模式
+	//解决问题：确保一个类在内存中的对象唯一性
+	public static void main(String[] args) 
+	{
+		//Single sDemo = Single.getInstance();
+		Single sDemo = Single.s;	//等同于Single sDemo = Single.getInstance();
+	}
+}
+
+class Single
+{
+	static Single s = new single();
+	private Single(){};
+	public static Single getInstance()
+	{
+		return s;
+	}
+}

Jb25_ObjExtends.java

@@ -0,0 +1,29 @@
+public class Jb25_ObjExtends
+{
+	public static void main(String[] args) 
+	{
+		Student a = new Student();
+		a.name = "xiaoming";
+		a.age = 17;
+		a.study();
+	}
+}
+/*
+继承的优点:
+提高代码复用性
+类与类之间产生了关系，给第三个特征多态提供了前提
+*/
+
+class Person
+{
+	String name;
+	int age;
+}
+
+class Student extends Person
+{
+	void study()
+	{
+		System.out.println(age+"岁的"+name+"正在学习");
+	}
+}

Jb26_Final.java

@@ -0,0 +1,34 @@
+public class Jb26_Final
+{
+	public static void main(String[] args) 
+	{
+		
+		System.out.println("Hello World!");
+	}
+}
+//继承的弊端:打破了封装性，会覆盖父类方法
+		/*
+		final关键字可以修饰类、方法和变量
+		修饰的类不能被继承继承
+		修饰的方法不可以被覆盖
+		修饰的变量是个常量，只能被赋值一次
+		内部类只能访问被final修饰的局部变量
+		常量所有字母都要大写，多个单词用_连接
+		*/
+class Fu
+{
+	void method()
+	{
+		//调用底层系统资源	
+	}
+}
+
+class Zi extends Fu
+{
+	void method()
+	{
+		//	final int x = 1;
+		//	x = 2;	此会提示出错，变量x为最终变量，无法赋值
+		System.out.println("OK");
+	}
+}

Jb27_AbstractClass.java

@@ -0,0 +1,56 @@
+public class Jb27_AbstractClass
+{
+	public static void main(String[] args) 
+	{
+		/*
+		抽象类特点：
+		抽象方法只有声明没有具体的实现，此方法既是抽象方法，需要被abstract修饰
+		抽象方法必须定义在抽象类中，该类必须被abstract修饰
+		抽象类不能被实例化！因为调用抽象方法没意义。
+		抽象类必须由其子类覆盖了所有的抽象方法后，该子类才可以实例化，否则子类还是抽象类
+
+		抽象类有构造函数，用于给子类对象进行初始化
+		抽象类可以不定义抽象方法，比较少见，目的就是不让该类创建对象，AWT适配器对象既是这种类
+		通常这个类里的方法有方法体，但没有内容
+		class Demo()
+		{
+			void show1()
+			{}
+		}
+		
+		抽象关键字不可以和private：因为抽象方法需要被子类需要覆盖，私有后无法覆盖
+		不可以和static：因为抽象方法不需要运行，没有具体内容，运行没意义，直接调用类名就行
+		不可以和final：因为不能被子类覆盖
+
+		抽象类与一般类的共同点：都是用来描述事物，在内部定义了成员
+		不同点：一般类有足够信息描述事物。抽象类描述事物的信息可能不足
+		一般类中不能定义抽象方法，只能定义非抽象方法。抽象类中可以定义抽象方法，也可以定义非抽象方法
+		一般类可以被实例化。抽象类不能被实例化。
+
+		抽象类一定是父类。因为需要子类覆盖其方法后才能对子类进行实例化。
+		*/
+		System.out.println("Hello World!");
+	}
+}
+
+abstract class Demo
+{
+	abstract void show();	
+	//将DemoA和DemoB向上抽取共性方法，但是内容不同，具体不清楚，此时用abstract修饰
+}
+
+class DemoA
+{
+	void show()
+	{
+		System.out.println("show A");
+	}
+}
+
+class DemoB
+{
+	void show()
+	{
+		System.out.println("show B");
+	}
+}

Jb28_AbstractTest.java

@@ -0,0 +1,48 @@
+public class Jb28_AbstractTest
+{
+	public static void main(String[] args) 
+	{
+		
+		System.out.println("Hello World!");
+	}
+}
+
+abstract class Staff
+{
+	private String name;
+	private String id;
+	private double pay;
+	Staff(String name,String id,double pay)
+	{
+		this.name = name;	//³õʼ»¯
+		this.id = id;
+		this.pay = pay;
+	}
+	public abstract void work();
+}
+
+class Programmer extends Staff
+{
+	Programmer(String name,String id,double pay)
+	{
+		super(name,id,pay);
+	}
+	public void work()
+	{
+		System.out.println("´ò´úÂë");
+	}
+}
+
+class Manager extends Staff
+{
+	private int bonus;
+	Manager(String name,String id,double pay,int bonus)
+	{
+		super(name,id,pay);
+		this.bonus = bonus;
+	}
+	public void work()
+	{
+		System.out.println("¹ÜÀíÈËÔ±");
+	}
+}

Jb29_Interface.java

@@ -0,0 +1,88 @@
+/*
+当一个类中的方法都是抽象时，可以将该抽象类用接口的形式定义和表示。
+abstract class Demo
+{
+	abstract void show1();
+	abstract void show2();
+}
+
+定义接口的关键是interface
+接口常见的成员：成员都有固定的修饰符
+全局常量：public static final
+抽象方法：public abstract
+固接口中的成员都是public（公共）权限
+*/
+interface Demo
+{
+	public static final int NUM = 4;
+	public abstract void show1();
+	public abstract void show2();
+}
+
+/*类与类之间继承关系。类与接口之间实现关系。接口与接口之间继承关系，且接口可以多继承
+接口不能实例化，只能由实现接口的子类并覆盖了接口所有抽象方法后，该子类才能实例化
+否则，该子类是一个抽象类
+*/
+class DemoImpl implements Demo
+{
+	public void show1()
+	{}
+	public void show2()
+	{}
+}
+
+/*
+Java中不支持多继承，因为会出现调用的不确定性
+用多实现来替代。一个类可以实现多个接口
+
+*/
+
+interface A
+{
+	public void show1();
+}
+
+interface B
+{
+	public void show2();
+}
+
+class Test implements A,B	//多实现
+{
+	public void show()
+	{
+		System.out.println("OK");
+	}
+}
+
+//一个类继承另一个类的同时，还可实现多个接口
+class C
+{
+	public void method()
+	{}
+}
+
+abstract class Test2 extends C implements A,B
+{
+	
+}
+
+public class Jb29_Interface
+{
+	public static void main(String[] args) 
+	{
+		/*DemoImpl inf = new DemoImpl();
+		System.out.println(inf.NUM);
+		System.out.println(DemoImpl.NUM);
+		System.out.println(Demo.NUM);*/
+
+	}
+}
+/*
+接口和抽象类的相同点：都是不断向上抽取而来
+不同点：抽象类需要被继承，而且只能单继承。接口需要被实现，可以多继承
+抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法
+接口只能定义抽象方法，必须由子类实现
+抽象类的继承，定义该体系的基本共性内容
+接口的实现，定义该体系的额外功能
+*/

Jb30_Interface2.java

@@ -0,0 +1,31 @@
+public class Jb30_Interface2
+{
+	//实现电脑USB接口功能
+	public static void main(String[] args) 
+	{
+		useUSB(new Upan());
+	}
+	public static void useUSB(USB u)	//接口类型的引用，用于接收（指向）接口的子类对象
+	{
+		u.open();
+		u.close();
+	}
+}
+
+interface USB
+{
+	public void open();
+	public void close();
+}
+
+class Upan implements USB
+{
+	public void open()
+	{
+		System.out.println("开启");
+	}
+	public void close()
+	{
+		System.out.println("关闭");
+	}
+}

Jb31_ObjPol.java

@@ -0,0 +1,76 @@
+public class Jb31_ObjPol
+{
+	//对象的多态性;代码中的体现就是父类或接口的引用指向其子类的对象
+	public static void main(String[] args) 
+	{
+		/*自动类型提升(向上转型)，猫对象提升为动物类型.但特有功能无法访问
+		作用是限制对特有功能的访问*/
+		Animal a = new Cat();	
+		a.eat();
+		//如果仍要使用猫的特用功能，可将对象向下转型
+		//自始至终都是子类对象进行类型的变换
+		Cat c = (Cat)a;	//向下转型目的是为了使用子类的特用方法
+		c.eat();
+		c.catch();
+		/*
+		Cat c = new Cat();
+		//Dog d = new Dog();
+		//c.eat();
+		method(c);
+		method(new Dog());
+		*/
+		method(new Cat());
+	}
+	/*多态好处：提高代码的扩展性，前面定义的代码可使用后期的内容
+	弊端：前期定义的内容不能使用（调用）后期子类的特有内容
+	使用多态前提：必须有关系、继承、实现
+	要有方法覆盖
+	
+	*/
+	public static void method(Animal a)
+	{
+		a.eat();
+		if (a instanceof Cat)
+		//instanceof 用于判断对象的具体类型，只能用于引用数据类型判断
+		//通常在向下转型前用于健壮性的判断
+		{
+			Cat c2 = (Cat)a;
+			c2.catch();
+		}
+		else if (a instanceof Dog)
+		{
+			Dog d2 = (Dog)a;
+			d2.watchHome();
+		}
+		
+	}
+}
+
+abstract class Animal
+{
+	abstract void eat();
+}
+
+class Dog extends Animal
+{
+	public void eat()
+	{
+		System.out.println("吃屎");
+	}
+	public void watchHome()
+	{
+		System.out.println("看家");
+	}
+}
+
+class Cat extends Animal
+{
+	public void eat()
+	{
+		System.out.println("吃鱼");
+	}
+	public void catch()
+	{
+		System.out.println("捉老鼠");
+	}
+}

Jb32_PolMember.java

@@ -0,0 +1,54 @@
+public class Jb32_PolMember
+{
+    /*
+    多态时，成员的特点
+    成员变量：
+    编译时：参考引用型变量所属的类中是否有调用的成员变量，有则编译通过，否则编译失败
+    运行时：参考引用型变量所属的类中是否有调用的成员变量，并运行该所属类型的成员变量
+    通俗的讲：编译和运行都参考等号左边！Fu f = new Zi();
+
+    成员函数(非静态)：
+    编译时：参考引用型变量所属的类中是否有调用的函数，有则编译通过，否则编译失败
+    编译时：参考的是对象所属的类中是否有调用的函数
+    通俗的讲：编译参考等号左边，运行参考等号右边
+
+    静态函数：
+	编译时：参考引用型变量所属的类中是否有调用的静态方法
+	运行时：参考引用型变量所属的类中是否有调用的静态方法
+	通俗的讲：编译和运行都参考等号左边
+	静态方法，不需要对象也行，直接用类名调用
+    */
+    public static void main(String[] args)
+    {
+        Fu f = new Zi();
+        f.method();	//可以不需要对象来调用，等同于直接用类名调用Fu.method();,
+        //f.show();
+        //System.out.println(f.num);
+    }
+}
+
+class Fu
+{
+    int num = 1;
+    void show()
+    {
+        System.out.println("FU");
+    }
+    static void method()
+    {
+        System.out.println("FU static");
+    }
+}
+
+class Zi extends Fu
+{
+    int num = 2;
+    void show()
+    {
+        System.out.println("ZI");
+    }
+    static void method()
+    {
+        System.out.println("ZI static");
+    }
+}

Jb33_InnerClass.java

@@ -0,0 +1,54 @@
+public class Jb33_InnerClass
+{
+	public static void main(String[] args) 
+	{
+		//Outer out = new Outer();
+		//out.method();
+
+		//直接访问外部类中的内部类中的成员,内部类共有时
+		//Outer.Inner in = new Outer().new Inner();
+		//in.show();
+		
+		//如果内部类是静态的，相当于一个外部类
+		//Ouer.Inner in = new Outer.Inner();
+		//in.show();
+
+		//如果内部类是静态的，成员是静态的
+		Ouer.Inner.fun();
+	}
+}
+
+/*
+内部类访问特点：
+内部类可以直接访问外部类中的成员，包括私有成员
+而外部类要访问内部类中的成员必须要建立内部类的对象
+*/
+class Outer
+{
+	private static int num = 1;
+
+	class Inner	//内部类
+	{
+		void show()
+		{
+			System.out.println("嘿嘿"+num);
+		}
+		/*
+		static void fun()	//如果内部类中定义了静态方法，该内部类必须是静态的
+		{
+			System.out.println("fun 嘿嘿"+num);
+		}
+		*/
+	}
+	public void method()	//外部类访问内部类方法
+	{
+		Inner in = new Inner();
+		in.show();
+	}
+}
+/*
+内部类一般用于类的设计
+分析事物时，发现该事物描述里还有事物，这个事物仍访问被描述事物的内容
+这时就将还有的事物定义为内部类描述
+
+*/

Jb34_InnerClass2.java

@@ -0,0 +1,53 @@
+public class Jb34_InnerClass2
+{
+	public static void main(String[] args) 
+	{
+		new Outer().method();
+		new Outer2().method();
+	}
+}
+
+/*
+为什么内部类可以直接访问外部类中的成员
+内部类持有外部类的引用。	外部类名.this
+*/
+class Outer
+{
+	int num = 1;
+	class Inner
+	{
+		int num = 2;
+		void show()
+		{
+			int num = 3;
+			System.out.println(num);	//打印show方法内的成员
+			System.out.println(this.num);	//打印内部中的成员
+			System.out.println(Outer.this.num);	//打印外部类中的成员
+		}
+	}
+	void method()
+	{
+		new Inner().show();
+	}
+}
+
+//JDK1.7之前，内部类在局部位置上只能访问局部中被final修饰的局部变量
+//JDK1.8时，内部类在局部位置上可以直接访问局部变量
+class Outer2
+{
+	int num = 1;
+	void method()
+	{
+		int x = 2;	//局部变量x
+		class Inner2
+		{
+			void show()
+			{
+				System.out.println("show"+x);
+			}
+		}
+		Inner2 in = new Inner2();
+		in.show();
+	}
+	
+}

Jb35_AnsInnerClass.java

@@ -0,0 +1,39 @@
+public class Jb35_AnsInnerClass
+{
+	/*匿名内部类使用前提：内部类必须继承或者实现一个外部类或者接口
+	匿名内部类，其实就是匿名子类对象
+	*/
+	public static void main(String[] args) 
+	{
+		new Outer().method();
+	}
+}
+
+class Outer
+{
+	/*
+	class Inner extends Demo
+	{
+		void show()
+		{
+			System.out.println("呵呵"+num);
+		}
+	}
+	*/
+	public void method()
+	{
+		//new Inner().show();
+		new Demo()
+		{
+			void show()
+			{
+				System.out.println("呵呵呵呵"+num);
+			}
+		}.show();
+	}
+}
+
+abstract class Demo
+{
+	abstract void show();
+}

Jb36_AnsInnerClass2.java

@@ -0,0 +1,46 @@
+public class Jb36_AnsInnerClass2
+{
+	/*
+	匿名内部类使用场景之一：当函数参数是接口类型，而且接口中的方法不超过三个
+	可以作为匿名内部类作为实际参数传递
+	*/
+	public static void main(String[] args) 
+	{
+		show(new Inf()
+		{
+			public void show1()
+			{}
+			public void show2()
+			{}
+		});
+	}
+
+	public static void show(Inf in)
+	{
+		in.show1();
+		in.show2();
+	}
+}
+
+interface Inf
+{
+	void show1();
+	void show2();
+}
+
+//匿名内部类的使用
+class Outer
+{
+	public void method()
+	{
+		Inf in = new Inf()
+		{
+			public void show1()
+			{}
+			public void show2()
+			{}
+		};
+		in.show1();
+		in.show2();
+	}
+}

Jb37_ObjExcep.java

@@ -0,0 +1,78 @@
+public class Jb37_ObjExcep
+{
+	/*异常：运行时发生的不正常情况
+	分类：
+		Throwable:Error和Exception
+
+		异常处理:捕捉形式
+	格式：
+	try
+	{
+		需要被检测异常的代码
+	}
+	catch (异常类 变量) 变量用于接收发生异常的对象
+	{
+		处理异常的代码
+	}
+	finally
+	{
+		一定被执行的代码
+	}
+	*/
+	
+	public static void main(String[] args)	//声明：throws MinusIndexException
+	{
+		int [] arr = new int[3];
+		Demo d = new Demo();
+		try
+		{
+			int num = d.method(arr,-27);
+			System.out.println("Hello World!"+num);
+		}
+		catch (MinusIndexException m)	//多个catch，要把父类exception放在最后
+		{
+			m.printStackTrace();//JVM默认的异常处理机制
+			System.out.println("角标不为负");
+			//System.exit(0);//退出JVM
+		}
+		finally	//通常用于释放资源
+		{
+			System.out.println("finally");
+		}
+	}
+}
+
+class Demo
+{
+	public int method (int[] arr,int index)throws MinusIndexException	//声明:
+	{
+		if (arr==null)
+		{
+			throw new NullPointerException("数组引用不能为空");
+		}
+		if (index>=arr.length)
+		{
+			throw new ArrayIndexOutOfBoundsException("角标越界"+index);
+		}
+		if (index<0)
+		{
+			throw new MinusIndexException();
+		}
+		return arr[index];
+	}
+}
+
+/*自定义异常类
+想要一个类成为异常类，必须继承异常体系。
+只有异常体系的子类具有可抛性，才能被关键字throws和throw所操作
+*/
+class MinusIndexException extends Exception
+{
+	MinusIndexException()
+	{
+	}
+	MinusIndexException(String msg)
+	{
+		super(msg);
+	}
+}

Jb38_ObjClass.java

@@ -0,0 +1,50 @@
+public class Jb38_ObjClass
+{
+	public static void main(String[] args) 
+	{
+		Dog d1 = new Dog("daHei");
+		Dog d2 = new Dog("daHei");
+		Dog d3 = d1;
+		Demo d = new Demo();
+		System.out.println(d1==d2);
+		System.out.println(d1.equals(d2));
+		//System.out.println(d1.equals(d));
+		System.out.println(d1);
+		System.out.println(d1.hashCode());
+
+		Class c1 = d1.getClass();
+		Class c2 = d2.getClass();
+		System.out.println(c1==c2);
+
+		System.out.println(d1.getClass().getName());
+	}
+}
+
+class Dog extends Object
+{
+	private String name;
+	Dog(String name)
+	{
+		this.name = name;
+	}
+	/*
+	一般都会覆盖此方法，根据对象的特有内容，建立判断对象是否有相同的依据
+	*/
+	public boolean equals(Object obj)
+	{
+		if (!(obj instanceof Dog))
+		{
+			throw new ClassCastException("类型与定义不同，错误");
+		}
+		Dog d = (Dog)obj;
+		return this.name == d.name;
+	}
+	public String toString()
+	{
+		return "Dog:"+name;
+	}
+}
+
+class Demo
+{
+}

Jb39_Multithread.java

@@ -0,0 +1,55 @@
+public class Jb39_Multithread
+{
+	/*
+	进程：真正运行的程序，是系统进行资源分配和调度的基本单位
+	线程：进程中一个负责程序执行的控制单元，一个进程中可多执行路径
+	一个进程至少一个线程。
+	创建线程方式之一：继承Thread类
+	步骤：
+	1、定义一个类继承Thread类
+	2、覆盖Thread类中的run方法
+	3、直接创建Thread的子类对象创建线程
+	4、调用start方法开启线程并调用run方法开始执行
+	*/
+	public static void main(String[] args) 
+	{
+		Thread t1 = new Thread();
+		Thread t2 = new Thread();
+		
+		Demo d1 = new Demo("线程1");
+		Demo d2 = new Demo("线程......二");
+		d1.start();	//开启线程1,调用run方法
+		d2.start();
+		System.out.println("Hello World!");	//线程三
+	}
+}
+
+class Demo extends Thread
+{
+	private String name;
+	Demo(String name)
+	{
+		this.name = name;
+	}
+	public void run()
+	{
+		for (int x=0;x<9 ;x++)
+		{
+			for (int y=0; y<27; y++)
+			{
+			}
+			System.out.println(name+Thread.currentThread().getName()+"..."+x);	//通过Thread的getName方法获取对象的名称
+		}
+	}
+
+/*	public void show()
+	{
+		for (int x=0;x<10 ;x++ )
+		{
+			for (int y=0;y<100 ;y++ )
+			{
+				System.out.println(name+"x="+x);
+			}
+		}		
+	}*/
+}