helloworld至多态的总结

基本要求：
A:用记事本写一个HelloWorld,在控制台输出你的名称,并编译运行。
B:在类Demo中，有两个方法，一个是main方法，一个是compare方法(用于比较两个整数是否相等)
  最后在main里面进行测试。
C:写两个类,一个类是Demo2，一个类是Test。
  Demo2类中有一个方法getMax()，返回三个整数中最大的整数。
  最后在Test类中的main方法中进行测试。

day01:
	A:JDK的下载，安装与卸载。
	B:JDK,JRE,JVM的关系
		JDK:JRE+tools 开发工具
		JRE:JVM+API中的类 运行工具
		JVM:保证Java语言跨平台

		Java语言是跨平台的吗？是
		JVM是跨平台的吗？不是
			假设法。
	Ｃ:Java的环境变量的配置
		配置JAVA_HOME
		修改path
	D:HelloWorld程序的编写

day02:
	A:关键字
		java赋予了特殊含义的单词。
		特点:
			都是小写
			goto和const是java的保留字
	B:标识符
		就是给java中的类,接口,变量,方法等起的名字
		规则:
			见名知意,驼峰命名
		组成规则:
			大小写英文字母
			数字
			下划线,$
			
			注意：
				不能以数字开头
				不能使用java的关键字
		常见的命名规则：
			包:全部小写,如果多级包,用"."隔开
				举例:cn.itcast,com.baidu
			类或者接口:
				一个单词,首字母大写
					举例：Demo,Student
				多个单词,每个单词的首字母大写
					举例：HelloWorld,ArrayList
			方法或者变量:
				一个单词,小写
					举例：name,age,number,count
				多个单词,从第二个单词开始,每个单词的首字母大写
					举例：getName(),studentName
			常量:单词大写,如果多个单词组成,用"_"连接
				举例：MAX_NUMBER
	C:注释
		单行注释 //
		多行注释 /* */
		文档注释 /** */

		用途：
			解释说明程序。
			做程序的调试。断点调试。
作业			***作业：把见到过的异常给我总结出来(讲完IO后我们检查)
				格式：
					异常名
						NullPointException
					解释
						空指针异常，可能是...
					解决
						Person p = null;
						Person p = new Person();
	D:常量
		字符串常量,字符常量,整数常量,浮点数常量,布尔常量,null常量
		"hello",'A',12,12.5,true,null
	E:变量
		变量：在指定范围内可以改变的量叫变量。
		格式：
			数据类型 变量名 = 初始化值;
	F:数据类型
		基本数据类型
			4类8种
				整数
					byte,short,int,long
				浮点数
					float,double
				字符
					char
				布尔
					boolean
			注意：
				不同数据类型占用的内存空间大小不一样。	
				整数默认是int类型,浮点数默认是double类型。
				long最好以L或者l结尾
				float最好以F或者f结尾
		引用数据类型
			类,接口,数组

		数据类型转换:
			byte,short,char--int--long(2^63-1)--float(10^38)--double
作业				***自学BigDecimal。实现dobule数据的减法。
			参与运算的时候，我们要求数据类型一致。如果数据类型不一致，就会有类型转换。
			自动转换，隐式转换：从小到大
			强制转换，从大到小：一般不建议使用，因为会有精度的损失。
	G:运算符
		算数运算符
			+,-,*,/,%,++,--
		赋值运算符
			=,+=,-=,...
		关系运算符
			==,!=,>,>=,<,<=
			特点：结果是boolean类型
		逻辑运算符
			&,|,^,
			常用：&&,||,!
		位运算符(了解)
			&,|,^,~,>>,>>>,<<
		三元运算符
			表达式?值1:值2;

		表达式：用运算符把变量和常量等数据连接起来的式子。
	H:面试题
		short s = 1;
		s+=1;
		s = s + 1;

		两个数据的交换：
			开发：
				第三方变量
				int a = 10;
				int b = 20;
		
				int temp = a;
				a = b;
				b = temp;
			面试：
				左边a,b,a。
				右边a ^ b;
			
day03:
	语句

	A: if语句:
		格式：
			if(表达式){}

			if(表达式){}
			else {}

			if(表达式){}
			else if(表达式){}
			else if(表达式){}
			...
			else{}

			注意事项：
				表达式无论简单还是复杂，结果是boolean类型。
				if语句如果控制的是一条语句，{}可以省略。但是，不建议这样做。
				else后面不跟表达式
				if语句不管是第几种格式，它其实是一条语句。

	switch语句:
		格式：
			switch(表达式)
			{
				case 值1:
					语句;
					break;
				case 值2:
					语句;
					break;
				case 值3:
					语句;
					break;
				...
				default:
					语句n;
					break;
			}

			注意事项：
				表达式可以是:byte,short,int,char
					JDK5以后可以是枚举,JDK7以后可以是String
				值不能是相同的。
				default里面的break是可以省略的。其他地方break一般不建议省略。
				但是，如果是为了完成某些功能，是可以省略的。
				switch语句的结束是遇到break或者结尾。

	循环语句:
		while:
			while(表达式){}

		do...while:
			do {
				
			}while(表达式);

		for:
			for(表达式1;表达式2;表达式3)
			{
			
			}

		注意：
			do...while和其他循环的区别在于：它至少执行一次循环体。
			while循环和for循环式可以等价转换的。

	break和continue:
		break:结束当前循环
		continue:结束本次循环

	练习：
		for循环:
			水仙花数:
				满足这样条件的三位数,它的各个位的立方和等于该数本身。
				举例：153 = 1^3 + 5^3 + 3^3 = 1 + 125 + 27 = 153

		while循环:
			我们进行排队，3个人一队，余下2人。
				      5个人一队，余下3人。
				      7个人一队，余下2人。
			假如我们的人数在200以内，请把这样可能的人数给列出来。

day04:
	A:函数(方法)：能完成特定功能的代码块。
		好处：提高代码的复用性
		特点：只有被调用才执行

	B:格式：
		修饰符 返回值类型 函数名(参数列表)
		{
			//方法体
			return 返回值;
		}

		修饰符:这个时候，你可以先默认 public static
		返回值类型:功能一般来说应该有结果，这里放的是结果的类型
		函数名:就是给函数起个名字,方便调用
		参数列表:
			实参：就是实际参与操作的数据
			形参：就是接收实际数据的变量
		方法体:就是具体的逻辑代码
		return 返回值:如果功能有结果，必须使用return带回。
	C:不同类型的调用
		void类型:
			直接调用。
		非void类型:明确的数据类型
			直接调用,但是没有意义。一般不这样做。
			输出调用,但是一般也这样做。因为我们可能需要根据返回的结果继续进行操作。
			赋值调用.推荐使用方式

		public void show(){}
		public int sum(int a,int b){}
	D:函数的重载
		方法的名称一定要有意义。
		重载:在同一个类中，方法名相同，参数列表不同(个数和对应的数据类型)

day05:
	A:数组 存储同一种数据类型的多个元素的容器。
		
		特点：每一个元素都有索引，可以直接通过索引获取该元素。
	B:格式
		//int arr[] = new int[3];
		int[] arr = new int[3];
		int[] arr = new int[]{1,2,3}; //避免了类型不安全的隐患
		int[] arr = {1,2,3};
	C:操作
		遍历:
			public static void printArray(int[] arr)
			{
				for(int x=0; x<arr.length; x++)
				{
					System.out.println(arr[x]);
				}
			}

		获取最值:
			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;
			}

		排序:
			选择排序:从0索引位置开始往后比较,第一次比较完毕后，最小值出现在了0索引处
			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[y]<arr[x])
						{
							//数据交换
							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-1-x; y++)
					{
						if(arr[y]>arr[y+1])
						{
							//数据交换
							int temp = arr[y+1];
							arr[y+1] = arr[y];
							arr[y] = temp;
						}
					}
				}
			}

		查找:
			普通查找:
				public static int getIndex(int[] arr,int value)
				{
					int index = -1;
					for(int x=0; x<arr.length; x++)
					{
						if(arr[x]==value)
						{
							index = x;
							break;
						}
					}
					return index;
				}
			
			折半查找,二分查找:
				前提：前提是数据必须先有序

				public static int getIndex(int[] arr,int value)
				{
					int start = 0;
					int end = arr.length-1;
					int mid = (start+end)/2;

					while(arr[mid]!=value)
					{
						if(arr[mid]>value)
						{
							end = mid - 1;
						}
						else if(arr[mid]<value)
						{
							start = mid + 1;
						}

						if(start>end)
						{
							return -1;
						}

						mid = (start+end)/2;
					}

					return mid;
				}

day06-day11:
	A:面向对象
		面向对象是一种编程思想。
		是相对于面向过程而言的。

		面向过程：就是一步一步的解决问题，关注过程
		面向对象：创建对象，使用功能，关注结果
	
	  举例：
		把大象装进冰箱。
		洗衣服,做饭。
			
	  面向过程：
		步骤：
			1:打开冰箱门
			2:把大象放进去
			3:关上冰箱门
		public class Demo
		{
			public static void main(String[] args)
			{
				//System.out.println("打开冰箱门");
				//System.out.println("把大象放进去");
				//System.out.println("关上冰箱门");

				open();
				in();
				close();
			}

			public static void open()
			{
				System.out.println("打开冰箱门");
			}

			public static void in()
			{
				System.out.println("把大象放进去");
			}

			public static void close()
			{
				System.out.println("关上冰箱门");
			}
		}

	面向对象：
		如何使用面向对象的思想分析和解决问题？
			1:分析这个问题中有哪些类
			2:每个类应该有哪些成员
			3:类与类之间的关系

		1:分析这个问题中有哪些类(UML 统一建模语言)
			名词提取法
			  大象
			  冰箱
			  测试类
		2:每个类应该有哪些成员
			  大象
				in()
			  冰箱
				open()
				close()
			  测试类
				main
		3:类与类之间的关系
			  就是在测试类中创建大象及冰箱的对象来调用功能

		代码:
			public class 大象
			{
				public void in()
				{
					System.out.println("把大象放进去");
				}
			}

			public class 冰箱
			{
				public void open()
				{
					System.out.println("打开冰箱门");
				}

				public void close()
				{
					System.out.println("关上冰箱门");
				}
			}

			public class Test
			{
				public static void main(String[] args)
				{
					冰箱 b = new 冰箱();
					b.open();

					大象 d = new 大象();
					d.in();

					b.close();
				}

			}
	B:类与对象
		类：类就是对现实世界事物的抽象描述。
		对象：对象就是事物的具体存在。

		比如：
			Student:
				name,age 成员变量
				study() 成员方法

			比如：
				Student 班长 = new Student();
				班长.study();
	C:面向对象的三大特性
		封装
			隐藏实现细节，提供公共的访问方式。
			举例：电脑开机,人的心脏

			把类的成员变量给私有。就是使用private修饰符。
			提供public修饰符的getXxx()/setXxx()。
		
		继承
			为什么会有继承？
				提高代码的复用性
				多态的前提

			class A
			{
				public void show(){sop("show")}
			}

			class B
			{
				public void show(){sop("show")}
			}

			我们发现上面的代码功能是一致的。这样的话，我们就发现功能重复度很高。
			所以，我们思考，能不能通过一种方式：我只在一个类里面写功能，然后让
			其他的类与这个类产生一个关系，其他的类就不需要写功能了。
			恭喜你，可以。因为java提供了一种技术：继承 extends
			有了继承，这个代码就可以做改进了：
			class Demo
			{
				public void show(){sop("show")}
			}

			class A extends Demo{}
			class B extends Demo{}

		抽象类：
			class A
			{
				public void show(){sop("A")}
			}

			class B
			{
				public void show(){sop("B")}
			}
			我们发现上面的代码好像也可是使用继承体现，但是，如果直接使用继承后，
			我们就发现，这样的做法是不对的。因为他们的功能实现是不一样的。
			那么，针对这种情况，java又提供了一种技术：抽象
			我们只抽取功能的声明。

			abstract class Demo
			{
				//抽取方法的声明的方法，也就是没有方法体的方法，java中用抽象关键字表示
				//abstract
				//如果一个类中有抽象方法，那么，这个类必须定义为抽象类
				public abstract void show();
			}
			
			class A extends Demo
			{
				public void show(){sop("A")}
			}

			class B extends Demo
			{
				public void show(){sop("B")}
			}

			class C extends Demo
			{
				public void show(){sop("C")}
			}

			问题：这简化了代码的编写吗？目前没有。
			那么，抽象类的出现有什么好处呢？
				抽象类里面可以有非抽象方法，将来也可以实现方法的复用。
				抽象类就是用来规定某个体系必须实现某些功能的。
		接口:
			class A
			{
				public void show(){sop("A")}
			}

			class B
			{
				public void show(){sop("B")}
			}

			后来我们采用抽象类进行改进

			abstract class Demo
			{
				public abstract void show();
			}
			而我们又发现，这个类中只有抽象方法，像这种情况，java又提供了
			一种技术：接口 interface

			interface Demo
			{
				public abstract void show();
			}

			这个时候，我们的代码体现：
			class B implements Demo
			{
				public void show(){sop("B")}
			}

			class C implements Demo
			{
				public void show(){sop("C")}
			}

		抽象类与接口的区别？
			A:成员不同
				抽象类
					成员变量:
						在抽象类里面，可以是变量，也可以是常量
					成员方法:
						在抽象类里面，方法可以是抽象的，也可以是非抽象的。
					构造方法:
						可以有构造方法
				接口：
					成员变量:
						在接口里面，只有常量
						原因：接口中的成员变量都有默认修饰符
							public static final
					成员方法:
						在接口里面，只有抽象方法
						原因：接口中的成员方法都有默认修饰符
							public abstract

					注意：虽然，接口中的成员都有默认修饰符，但是，建议自己加上。

			B:类的继承和接口的实现
				类与类:
					继承关系，但是，只能是单继承。可以是多(重)层继承
				类与接口:
					实现关系，可以单实现，也可以多实现。
					还可以在继承一个类的同时实现多个接口。
					所以：java中接口的出现，避免了单继承的局限性。
				接口与接口:
					继承关系，可以单继承，也可以多继承。

			C:设计理念不同
				抽象类被继承体现的是"is a"的关系
				接口被实现体现的是"like a"的关系

				在设计的时候，是定义类还是接口呢，得根据情况来分析。
				如果类之间存在着:is a的关系。
					采用假设法。
					比如说：有A类和B类。
					我先假设A和B之间有is a的关系。
					那么，我们就可以说A is B的一种

			D:体现不同
				抽象类中定义的是继承体系的共性内容
				接口中定义的是继承体系的扩展内容

				高内聚(自己完成功能的能力)
				低耦合(类与类之间的关系)

		多态
			对象在不同时刻表现出来的不同状态。
			
			举例：
				猫(猫,动物)
				水(液态,固态,气态)

			前提：
				A:要有类的继承或者接口的实现
				B:要有方法的重写
				C:父类(接口)引用指向子类对象

			class Fu
			{
				int num = 10;
				public void show()
				{
					sop("fu");
				}
			}

			class Zi extends Fu
			{
				int num = 20;
				public void show()
				{
					sop("zi");
				}

				public void paly()
				{
					sop("魔兽世界");
				}
			}

			class Zi2 extends Fu
			{
				public void show()
				{
					sop("zi2");
				}
			}

			class Test
			{
				public static void main(String[] args)
				{
					//Fu f = new Fu();
					//Zi z = new Zi();
					
					//多态
				
					Fu f = new Zi();
					f.show(); //zi
					sop(f.num);//10

					f = new Zi2();
					f.show();

					//f.play();
					

					/*
					Zi z = new Zi();
					z.show();

					Zi2 z2 = new Zi2();
					z2.show();
					*/
				}
			}

			有疑问？因为方法有重写，而成员变量是没有的。
			多态的好处：可以操作同一体系的多个对象完成功能。
				弊端：使用多态的方式的时候，是不能使用每个具体子类的特殊功能。
		转型：
			向上转型
			向下转型


			Fu f = new Zi(); //向上转型
			f.show();

			//Zi z = new Zi();
			Zi z = (Zi)f; //向下转型
			z.play();
		
			f = new Zi2();
			f.show();

			Zi z = (Zi)f; //ClassCastException
			z.play();