黑马程序员1-4天视频总结

第一天总结
J2SE 标准版总结
java依靠自己独立的能解析java软件的解析器：
java虚拟机实现的跨平台性，但是java虚拟机也是一个软件，
虚拟机调用到系统底层的东西，本身不能跨平台，
就是说在xp，Linux，mac要用到专有的java虚拟机。

设置java环境变量
JRE（Java Runtime Envionment Java运行环境，包含虚拟机）
JDK（Java Development Kit java开发工具包）
用JDK开发完成的Java程序，交给JRE去运行

我的环境变量设置
CLASSPATH
.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\toos.jar
JAVA_HOME
C:\Program Files\Java\jdk1.7.0_03


Hello小程序思路：
需求：定义一个hello world小程序
思路：
1，
2，
步骤：
1，通过class关键字定义一个类，将代码都编写到该类中
2，为了保证独立运行，在类中定义一个主函数。格式public static void main(String[] args){}
3,保存成一个扩展名为java的文件
4，在dos控制台中通过javac工具对java文件进行编译
5，在通过java命令对生成的class文件进行执行


Hello.java是原文件 Hello.class是 运行文件。java.exe就会去调用jre里面的虚拟机
执行 Hello.class文件


class  DemoTest  //class是java当中的一关键字，用于定义类。DemoTest类名。{}类的区间
{
public static void main(String[] args) //主函数，保证程序独立运行
{
System.out.println("Hello World!");
}
}
语法规范：类名通常由单词所组成，首字母一般会大写


我犯过的错误 ：存文件存成 DemoTest.java文件，前面多了一个空格，
而存好的文件是看不出前面多了一个空格的，而cmd下报错找不到DemoTest.java文件。
找了半天，才找到，这个比文件拓展名隐藏难找多了。


第二天总结
Java中的名称规范
包名：多单词组成是所有字母都小写 xxxyyyzzz
类名接口名：多单词组成是所有单词首字母大小XxxYyyZzz
常量名：所有字母都大写，多单词是每个单词都用下滑下连接起来XXX_YYY_ZZZ，
和c的宏定义蛮像的啊


将自己的思想先整理出来，再用代码去实现
因为代码仅仅是思想的一种体现形式。
之前我功利性太强了，以为自己学过c就没有注意看这些基础知识，
并且只注重了代码，忽略了思想，难怪代码写不出来。还需脚踏实地的重新再过一遍。

常量的概念：就是将不确定的数据进行存储，也就是需要在内存中开辟一个空间
该区域有自己的名称（变量名）和类型（数据类型）
该区域的数据可以在同一类型范围内不断变化

如何开辟内存空间呢？
就是通过明确数据类型，变量名称数据来完成
为什么要定义变量：用来不断的存放同一类型的常量，并可以重复使用

变量，类型转换（char，int的类型提升和强制转换），算术运算符运算。
class  YunSuanTest
{
public static void main(String[] args) 
{
System.out.println("5+5="+5+5);//结果是55
System.out.println("5+5="+(5+5));//结果是10
//字符串数据和任何数据使用+都是相连接，最终都会变成字符串
//加了括号就是真的（5+5=10）。没加只是字符串，没有进行运算

System.out.println("64<<2="+(64<<2));//64<<2=256 
System.out.println("64>>2="+(64>>2));//64>>2=16
//位运算 <<左移乘以2的移动位数次幂（补张图，13位运算）
}
}

//不用第三方变量交换数据：
//第一种  a=a+b;
// b=a-b;
// a=a-b;
//缺点a，b值非常大，容易会超出该范围。

//第二种 异或(位运算，不会有范围超出的事情) //可以用于加密
// a=a^b;
// b=a^b;
// a=a^b;         

3-4函数，数组小结
语句：

if (条件表达式)
{
执行语句
}
switch ()
{
case :
}
while (条件表达式)    先判断后执行
{
执行语句
}


do //先执行后判断(会先执行一次)
{
执行语句      
}
while (条件表达式);


for(int x = 0;x<3;x++)
{
System.out.println("x="+x); //定义在for语句中的变量，在for语句执行完毕，该变量在内存中被释放
}
步骤 
1 初始化表达式int x=0； （初始化表达式只执行一次，）
2 循环条件表达式接着判断x是否小于3
3 满足执行语句 System.out.println("x="+x);
4 之后执行循环后的表达式x++
5 继续循环条件表达式判断x是否小于3，x<3;

break(跳出） 应用范围选择结构和循环结构  跳出循环，结束循环结构
continue（继续） 应用于 循环语句结束本次循环继续下次循环


函数的定义：
函数是定义在类中的具有特定功能的一段独立小程序，函数也称为方法，//以前一直不知道原来方法就是函数
作用：提高代码的复用性，对代码进行抽取，将这部分定义成一个独立的功能。
函数的格式：（由于之前不重视这些基础的知识导致我进度缓慢，不能深刻理解）


修饰符 返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数2，...)
{
执行语句;
return 返回值;
}
返回值类型：函数运行后的结果的数据类型
参数类型：是形式参数的数据类型
形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数
实际参数：传递给形式参数的具体数值
返回值：该值会返回给调用者


如何定义函数?
1,函数是一个独立的功能，需要先明确该功能的运算结果
2，再明确在定义该功能的过程中是否需要未知的内容参与运算

函数的重载（overload）
重载的特点：与返回值无关，只看参数列表即（参数类型 形式参数1，。。。）
其中 形式参数也是有顺序的
class Overload 
{
public static void main(String[] args) 
{
System.out.println(add(4,5));

System.out.println(add(4,5,6));
}
public static int add(int x ,int y)
{
return x+y;
}
public static int add(int x ,int y,int z)
{
return add(x,y)+z;
}
}
什么时候用重载？当定义的功能相同，但参与运算的未知内容不同
那么，这时就定义一个函数名称以表示功能，方便阅读
而通过参数列表的不同来区分多个同名函数


/*
void show(int a,char b,double c){}
a.
void show(int x,char y,double z){}//没有，因为和原函数一样。
b.
int show(int a,double c,char b){}//重载，因为参数类型不同。注意：重载和返回值类型没关系。
c.
void show(int a,double c,char b){}//重载，因为参数类型不同。注意：重载和返回值类型没关系。
d.
boolean show(int c,char b){}//重载了，因为参数个数不同。
e.
void show(double c){}//重载了，因为参数个数不同。
f.
double show(int x,char y,double z){}//没有，这个函数不可以和给定函数同时存在与一个类中。
*/


数组（数组是同一种类型数据的集合，数组就是一个容器）
数组能自动给存在里面的元素进行编号即：数组a[3]包括有a[0],a[1],a[2]三个元素
栈：数据使用完毕，会自动释放
堆：通过垃圾回收机制释放
-
选择排序
public static void xuanze(int[] arr)
{
for(int x=0;x<arr.length;x++)
{
for(int y=x+1;y<arr.length-1;y++)
{
if(arr[x]<arr[y])
{
int temp = arr[x];
arr[x]=arr[y];
arr[y]=temp;
}
}
}
}

冒泡排序 小的值往前跑，大的值往后跑就像冒泡一样
最值出现在最后位
public static void maopao(int[] arr)
{
for(int x=0;x<arr.length-1;x++)
{
for(int y=0;y<arr.length-x-1;y++)
{
if(arr[y]>arr[y+1])
{
int temp = arr[y];
arr[y]=arr[y+1];
arr[y+1]=temp;
}
}
}
}
Arrays.sort();//排序java自带的。需要import java.util.*;


折半查找
//定义功能，获取key第一次出现在数组中的位置。如果返回-1，那么代表该key在数组中不存在
public static int getIndex(int[] arr,int key)
{
for(int x=0;x<arr.length;x++)
{
if(arr[x]==key)
return x;
}
return -1;
}

我做的 A-Z随即选取，再进行顺序排序

/*
1要用到随机数Random，在类的上面添加 util
2想要获得随机数位置 Random 名字 = new Random（）；
int n 来接受一个随机数 int n =名字.nextIn(数值);代表的是0-数值范围内的随机数
*/
import java.util.*;
class Demo3 
{
	public static void main(String[] args) 
	{
		
		
		int arr []={'7','3','9','8','2','5'};
		
		printchay(ch);//排序前
		maoPao(ch);
		printchay(ch);//排序后
	}
	public static void printchay(int[] arr) //遍历打印数组功能
	{
		System.out.print("[");
		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 maoPao(int[] arr)
	{
		for(int x=0;x<arr.length-1;x++) 
		{
			for(int y=0;y<arr.length-x-1;y++)//ch.length控制数组长度 ；逐级减少比较次数用-x；为控制越界问题-1
			{
				/互换元素 
				if(arr[y]>arr[y+1])//前面元素和后面元素比较大小。最值（最小值）出现右面的方法
				{
					//这边理论优化应该将互换元素重新作为一个方法，不过估计就和别人代码一样了
					int temp = arr[y];  //通过临时的temp存储前面一个元素 
					arr[y]=arr[y+1];
					arr[y+1]=temp; //  
				}
			}
		}
	}
}