java基础第21天

day1:
1：安装与卸载JDK。
2：配置环境变量。
修改path，添加JDK的安装目录的bin。
3：JDK,JRE,JVM的区别
JDK = JRE + 开发工具
JRE = JVM + 核心类库


java语言是跨平台的吗？JVM是跨平台的吗？
4：HelloWorld
源文件 -- 编译 -- 运行
5：常见的DOS命令
盘符的切换
cd
cd..


day02：
1：关键字
java中的所有的关键字都是小写的
goto,const是java中的保留字


2：标识符
起的名字就叫标识符


组成规则：
数字，字母和_及$组成。
数字不能开头。
不能使用关键字。

命名规则：见名知意，驼峰命名。
包：
全部小写，多层包之间用.分割。
举例：cn.itcast
类和接口：
如果是一个单词，首字母大写。举例：Student
如果是多个单词，每个单词的首字母大写。举例：HelloWorld
方法和变量：
如果是一个单词，首字母小写。举例：age,name
如果是多个单词，从第二个单词开始每个单词的首字母大写。举例：getAge()
常量：
全部大写。多个单词用_分割。
举例：AGE,STUDNET_AGE
3：注释
解释说明程序的文字。


分类：
单行注释 //
多行注释 /*    */
文档注释 /**   */


作用：
解释说明程序。
调试程序。


断点调试，debug调试
4：常量
5：变量
内存中的一小块区域，在某个范围内变化的量。


定义变量的格式：
数据类型 变量名 = 初始值;


6：数据类型
java中的数据类型分为：基本数据类型和引用数据类型。
基本类型：4类8种
整数：
byte
short
int 
long
浮点数：
float
double
字符型：
char
布尔型：
boolean


注意：
整数默认是int，浮点数默认是double。
long或者float的定义，一般要在其后添加l或者f。


参与运算的值得数据类型必须一致，所以在运算的过程中就需要有类型转换：
隐式转换：从小到大
byte,short,char -- int -- long -- float -- double


强制转换：从大到小
可能会有精度的损失，一般不建议转换。


float f = (float)12.5;
float f = 12.5f;


注意：boolean类型不参与转换。


引用数据类型：
类
接口
数组
7：运算符
算术运算符
+,-,*,/,%,++,--
赋值运算符
+=,-=,*=,/=,%=
左边必须是一个变量。
关系运算符
>,>=,<,<=,==,!=
运算结果是boolean类型。
逻辑运算符
&,|,!,^,&&,||
运算结果是boolean类型。
位运算符
不回顾了。
三元运算符
条件表达式?值1:值2;

8：数据的交换
int a = 10;
int b = 20;

第一种方式：开发中使用
int c = a;
a = b;
b = c;


第二种方式：面试中使用
左边：a,b,a
右边：a^b
a = a^b;
b = a^b;
a = a^b;


day03：
1：if语句
if(表达式){}


if(表达式){}
else {}

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


注意事项：
表达式无论简单还是复杂，结果必须是boolean类型。
if语句本身是一个整体，是一条语句。
只有if后面跟表达式。

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


注意事项：
表达式的类型：byte,short,int,char
JDK5以后，可以使用枚举。
JDK7以后，可以使用字符串。
最后的一个break是可以省略的，中间的break根据情况看。一般不建议省略。
default也是可以省略，一般不建议省略。它相当于if语句的else。

3：循环语句
while
while(表达式){循环体语句}
do...while
do{循环体语句}while(表达式);
for
for(初始化值;条件判断;增量的变化){循环体语句}
4：continue和break
continue:结束本次循环，继续下一次循环。
break:结束当前循环。


day04-05：
1：函数
完成某个功能的一段独立的程序。


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


修饰符:权限修饰符,static,final,abstract 组合使用。
返回值类型:功能结果的类型。
函数名:起个名字，方便调用。
参数列表：
实际参数 实际参与运算的变量
形式参数 接受实际参数的变量
函数体:完成功能的逻辑代码
return 返回值:把结果返回给调用者


特点：
函数只有被调用才执行。

函数的调用。


函数的编写：
两个明确
明确返回值类型
以及参数列表


举例：求两个整数之和。
明确:
int
int a,int b


public int sum(int a,int b)
{
return a+b;
}


重载：
函数名相同，参数列表不同(个数以及对应的类型)。
跟返回值无关。

2：数组
存储同一种数据类型的多个元素的容器。

特点：
数组有索引。可以快速获取值。


定义数组：
int[] arr = new int[3];
int arr[] = new int[3];
int[] arr = new int[]{1,2,3};
int[] arr = {1,2,3};

注意：int[] x,y[];

数组的操作：离不开索引。
A:遍历
public void printArray(int[] arr)
{
for(int x=0; x<arr.length; x++)
{
System.out.println(arr[x]);
}
}


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



C:排序
冒泡排序
原理：相邻元素两两比较，较大的往后放。


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];
arr[y] = arr[y+1];
arr[y+1] = temp;
}
}
}


选择排序
原理：从0索引开始，和后面的依次比较，较小往前放。


for(int x=0; x<arr.length-1; x++)
{
for(int y=x+1; y<arr.length; y++)
{
if(arr[y]<arr[x])
{
int tmep = arr[y];
arr[y] = arr[x];
arr[x] = temp;
}
}
}


D:查找
普通查找
public 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 int getIndex(int[] arr,int value)
{
int start = 0;
int end = arr.length-1;
int middle = (start+end)/2;


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


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


middle = (start+end)/2;
}


return middle;
}


二维数组：
int[][] arr = new int[2][3];


遍历。


for(int x=0; x<arr.length; x++)
{
for(int y=0;y<arr[x].length; y++)
{
System.out.println(arr[x][y]);
}
}


day06-day11：面向对象

面向对象：是相对于面向过程而言的，是一种思想。
强调的是对象，结果。
面向过程：按照正常的逻辑完成功能。强调的是过程。


举例：
把大象装进冰箱。

面向过程：
步骤：
打开冰箱门
装进大象
关闭冰箱门

class Demo
{
public static void main(String[] args)
{
open();
in();
close();
}


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


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


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


面向对象：
提取对象。名词提取法。(UML)


大象：
冰箱：


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();
}
}


类的组成：
成员变量
成员方法
构造方法

封装：
隐藏内部的实现细节，对外提供公共的访问方式。
成员变量给私有化，提供get/set方法。


继承：
继承的出现，可以让子类具备父类的非私有的功能。提高了代码的复用性。


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


class B
{
public void show(){sop("show")}
}
假如，我们把方法定义在一个C类中，然后让A或者B类与C类产生一个关系，
就能够使用C中的内容，java就提供了继承这种实现。


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


class A extends C{}
class B extends C{}


注意事项：
java类中的继承只能单继承，但是可以多层继承。


继续看：代码如下
class A
{
public void show(){sop("A")}
}


class B
{
public void show(){sop("B")}
}
针对这种方法声明一样，方法体不一样的情况，java中也可以采用继承的方式体现：


public abstract class C
{
//当方法没有方法体的时候，这个方法必须定义为抽象方法
public abstract void show();


//有很多的非抽象方法。
}


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

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


继续看：代码如下
class A
{
public void show(){sop("A")}
}


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


用抽象类改进：
public abstract class C
{
//当方法没有方法体的时候，这个方法必须定义为抽象方法
public abstract void show();
}


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

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


发现在C类中的方法全部是抽象的，针对这种情况，java又提供了一种新的技术：接口
代码体现：
public interface C
{
//当方法没有方法体的时候，这个方法必须定义为抽象方法
public abstract void show();
}


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

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


抽象类和接口的区别？
1：成员的区别
抽象类：
成员变量：可以有成员变量，也可以是常量。
成员方法：可以有抽象方法，也可以由非抽象方法。
构造方法：有。用于子类实例化使用。
接口：
成员变量：只能是常量
默认的修饰符：public static final
成员方法：只能是抽象方法
默认的修饰符：public abstract


2：继承与实现的区别
类与类是继承关系，而且是单继承。
类与接口是实现关系，可以在继承一个类的同时实现多个接口。
接口与接口是继承关系，可以单继承，也可以多继承。


3：抽象类被继承体现的是一种："is a"的关系。
在这个体系中，抽象类一般定义的是体系的共性内容。
  接口被实现体现的是一种："like a"的关系。
在这个体系中，接口一般定义的是扩展功能。


多态：
同一个对象在不同时刻表现出来的多种形态。
举例：
水：液体，气态，固态
狗：狗，动物


前提：
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");
}
}


Fu f = new Fu();
f.show();//Fu


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


//多态
Fu f = new Zi();
f.show();//Zi
sop(f.num);//10


结论：
变量：编译和运行都看左边。
方法：编译看左边，运行看右边。


因为：方法存在着重写关系的。


举例：孔子装爹


孔子爹：教书("java")，age = 40
孔子：教书("论语"),玩游戏(),age = 20


孔子爹 k爹 = new 孔子();  //孔子就穿上爹的衣服，带上眼睛。向上转型
k爹.教书();//论语
sop(k爹.age);//40


孔子 k = (孔子)k爹;  //脱去衣服，穿上自己的，去掉眼睛。向下转型
k.教书();//论语
sop(k.age);//20
k.玩游戏();


在后面使用到了，我在复习。
异常
内部类
多线程


常用的API中的类：
String：
模拟用户登录。
只给3次机会，并在每次登录失败的时候提示还有几次机会。