floata=3.4；是过不去的，在java中小数默认是double（双精度）的
应该写成是floata=3.4f；
不过可以强制转换：
inta=（int）1.2;intb=（int）1.9
5.inta=1;intb=a+1.2;a先是往高精度转换，然后赋给b，就报错改成inta=1;doubleb=a+1.2;或者inta=1;floatb=a+1.2f;就解决了
第4讲流程控制
1.switchcase语句中，switch条件表达式的数据类型应该和后面case的类型一致
2.switchcase语句中，可用的数据类型主要是：
byteshortintcharenum
3.当型循环：
for和while循环
4.直到型循环：
dowhile循环
第5讲类与对象
1.面向对象编程-类与对象
类名首字母大写
类里面的元素叫类的成员变量/属性
2.类的定义
package包名；
class类名extends父类implements
接口名
{
成员变量；
构造方法；
成员方法；
}
3.如何创建对象：
先声明再创建Catcat1；cat1=newCat（）;
一步到位Catcat1=newCat（）;
4.引用传递类似于指针一样
第6讲成员属性成员方法
1.对象总是在内存中的
2.类成员方法：
方法就是指某些行为，表示为函数
public返回数据类型方法名（参数列表）
{
语句；//方法（函数）主题
}
3.类名首字母大写方法名首字母小写驼峰法（匈牙利法）下划线法
4.指针是存储地址的，不因为它的指向的数据的类型而改变大小。
第7讲成员方法（函数）构造方法
1.类的成员方法声明
访问修饰符数据类型函数名（参数列表）；
2.方法的参数列表是多个的，参数列表的数据类型是任意的
3.在调用某个成员方法的时候给出的具体数值的个数和类型要相匹配
4.方法可以没有返回值
5.先设计类，然后根据类创建对象
6.构造方法（构造函数）：
完成对新对象的初始化：
方法名和类名相同
没有返回值
在创建一个类的新对象时，系统会自动调用该类的构造方法完成对新对象的初始化
一个类可以定义多个不同的构造方法
每个类都有一个默认的构造方法
第8讲this类变量
1.this属于类的对象的而不是属于类的
2.5this不能在类的外部使用，只能在类定义时候使用！
3.可以用类名直接访问静态变量
第9讲类方法封装
1.类变量是该类的所有对象共享的对象,一改全改了
2.定义语法：
访问修饰符static数据类型变量名
3.publicclassDemo9
{
staticinti=1;
static
{
System.out.println（"zhixingyicile"）;
i++;
}//会自动执行一次，也只有一次
publicDemo9（）
{
System.out.println（"ffffffff"）;
i++;
}
publicstaticvoidmain（Stringargs[]）
{
Demo9t1=newDemo9（）;
System.out.println（Demo9.i）;
Demo9t2=newDemo9（）;
System.out.println（i）;
}
}
4.类方法（静态方法、静态函数）：
属于所有对象实例的
5.Java中:
类变量（static）原则上用类方法（static）去访问；类方法中不能访问非静态变量
，就是非类变量，但是普通的成员方法可以访问静态变量（类变量）
使用：
类名.类方法名对象名.类方法名
6.非类变量就是实例变量，属于每个对象自己的
7.Java面向对象编程的三（四）大特征：
封装、继承、多态（、抽象）
8.抽象：
把一类事物的共有的属性和行为提取出来，形成一个物理模板，此研究问题的方法就是抽象
9.封装：
把抽象出来的数据和对数据的操作封装在一起，数据被保护在内部，程序的其它部分只有通过被授权的操作（成员方法），才能对数据进行操作。
10.封装的访问控制修饰符
11.四种访问控制符：
公开级别：
public
受保护级别：
对子类和同一个包中的类公开
默认级别：
没有修饰符，向同一个包的类公开，子类不可以访问类中默认级别的元素的
私有级别：
用private修饰，只有类本身才能访问
公开>受保护>默认>私有
12.
13.包的三大作用：
区分相同名字的类当类很多的时候可以很好的管理类控制访问范围
14.包的打包命令：
packagecom.xiaoming一般放在文件的开始的地方
15.引包命令：
improt包名
第10讲访问修饰符重载覆盖
1.一个文家中如果只有public类，那么这个public类可以不用主函数
2.不想被继承就设为protected
3.子类最多只能继承一个父类，Java里面不允许一个子类继承多个父类，C++却可以，如Java中一定要呢，就用接口吧
4.Java的所有类都是Object的子类，继承层次数没有限制
5.JDK6.0里面有202个包，3777个类、接口、异常、枚举、注释和错误
6.在做开发的时候多使用JDK帮助文档
7.方法重载：
类的同一种功能的多种实现方式，取决于调用者传递的参数
8.方法重载注意事项：
方法名相同
方法的参数类型，个数，顺序至少有一项不同
方法的修饰符可以不同
方法的返回类型可以不同
另外：
只是返回类型不一样并不构成重载
只是控制访问修饰符不一样不构成重载
第11讲约瑟夫问题（丢手帕问题）
1.方法覆盖的：
子类有一个方法和父类的某个方法名称、返回类型、参数一样
2.方法覆盖注意：
子类的方法的返回类型、参数、方法名称要和父类的一样，否则编译出错
子类方法不能缩小父类方法的访问权限，但是扩大是可以的
3.丢手帕问题：
第十二讲多态
1.多态性:
访问子类可以通过访问父类：
Animalcat=newCat（）;
Animaldog=newDog（）;
2.在使用多态的时候，如果有使用覆盖函数，那么被覆盖的方法（即是父类中的的那个相应的方法）是要存在的。
3.多态：
一个引用（类型）在不同情况下的多种状态，可使代码更加灵活
4.java允许父类的引用变量引用它子类的实例，是自动完成的
代码：
packagecom.agui;
publicclassDemo5{
publicstaticvoidmain（String[]args）{
//TODOAuto-generatedmethodstub
Dog2ddd=newDog2（）;
ddd.cry（）;
Cat2ccc=newCat2（）;
ccc.cry（）;
Animal2an=newCat2（）;
an.cry（）;
Masterxxx=newMaster（）;
xxx.feed（newDog2（）,newBone（））;
}
}
//动物类
classAnimal2
{
Stringname;
intage;
publicStringgetName（）{
returnname;
}
publicvoidsetName（Stringname）{
this.name=name;
}
publicintgetAge（）{
returnage;
}
publicvoidsetAge（intage）{
this.age=age;
}
//叫
publicvoidcry（）
{
System.out.println（"buxiaodezenmejiao"）;
}
publicvoideat（）
{
System.out.println（"buzhidaochishenme"）;
}
}
classMaster
{
//使用多态，方法就可以用一个了
publicvoidfeed（Animal2an,Foodf）
{
an.eat（）;
f.showName（）;
}
}
classFood
{
Stringname;
publicvoidshowName（）
{
}
}
classFishextendsFood
{
publicvoidshowName（）
{
System.out.println（"yurou"）;
}
}
classBoneextendsFood
{
publicvoidshowName（）
{
System.out.println（"gutou"）;
}
}
classCat2extendsAnimal2
{
//猫自己叫
publicvoidcry（）
{
System.out.println（"maomaojiao"）;
}
publicvoideat（）
{
System.out.println（"aichiyu"）;
}
}
classDog2extendsAnimal2
{
//gou自己叫
publicvoidcry（）
{
System.out.println（"wangwangjiao"）;
}
publicvoideat（）
{
System.out.println（"aichigutou"）;
}
}
第十三讲抽象类接口（难点重点）
1.父类方法的不确定性，用抽象类修饰这个方法，abstract。
2.抽象类还是可以一样被继承
3.当一个类继承的类是抽象的类时候，就要把抽象类中的所有的抽象方法全部方法实现
4.用abstract关键词来修饰的时候，一定是抽象类和抽象方法
5.在使用中不多，公司笔试的时候考很多
6.抽象类不能被实例化，只有被继承以后再去实例化
7.抽象类不一定要包含abstract方法，就算没有abstract方法，也不能实例化它
8.一旦类包含了abstract方法，这个类必须声明为abstract
9.抽象方法不能有主体“{}“
packagecom.s1;
publicclassDemo1{
publicstaticvoidmain（String[]args）{
//TODOAuto-generatedmethodstub
}
}
abstractclassAnimal
{
Stringname;
intage;
abstractpublicvoidcry（）;
}
//当一个类继承的类是抽象的类时候，就要把抽象类中的所有的抽象方法全部方法实现
classCatextendsAnimal
{
publicvoidcry（）
{
//donothing
System.out.println（"喵喵叫"）;
}
}
10.接口就是给出一些没有内容的方法，封装到一起，到某个类要使用的时候，再根据具体情况把这些方法写出来，语法：
class类名implements接口
{
方法；
变量；
}
packagecom.s1;
publicclassDemo2{
publicstaticvoidmain（String[]args）
{
Computercomputer=newComputer（）;
Cameracamera=newCamera（）;
Phonephone=newPhone（）;
computer.useUsb（camera）;
computer.useUsb（phone）;
}
}
interfaceUsb
{
//声明了两个方法
//开始工作
publicvoidstart（）;
//停止工作
publicvoidstop（）;
}
//照相机,实现Usb接口
//一个类实现接口就要把所有的类全部实现！
classCameraimplementsUsb
{
publicvoidstart（）
{
System.out.println（"我是照相机，我开始工作了！
"）;
}
publicvoidstop（）
{
System.out.println（"我是照相机，我停止工作了！
"）;
}
}
//手机类
classPhoneimplementsUsb
{
publicvoidstart（）
{
System.out.println（"我是手机，我开始工作了！
"）;
}
publicvoidstop（）
{
System.out.println（"我是手机，我停止工作了！
"）;
}
}
//计算机
classComputer
{
//开始使用USB接口
publicvoiduseUsb（Usbusb）//体现多态
{
usb.start（）;
usb.stop（）;
}
}
11.接口不能被实例化
12.接口中的所有方法都不能有主体
13.抽象类里面是可以有实现了的方法的
14.接口中的所有方法都不能有主体，即都不能被实现
15.接口是更加抽象的抽象类！
！
！
！
16.一个类继承抽象类或是使用接口，那么就要实现所有的抽象方法
17.一个类可以实现多个接口
18.接口中可以有变量（但是不能用private，protected修饰）
19.接口中的变量本质上都是静态的，而且是final，不管你加不加static，所以可以直接使用：
接口名.变量名
20.在java开发中，经常把常用的变量定义在接口中作为全局变量使用
访问形式：
接口名.变量名
21.一个接口不能继承其它的类，但是可以继承别的接口
22.接口体现了程序设计的多态和高内聚低耦合的思想
第十四课final作业评讲
1.实现接口和继承父类的区别：
2.java是单继承，一个类只允许继承一个父类，这种单继承的机制可以保证类的纯洁性，比C++的多继承机制简洁
3.实现接口可以看做是对单继承的一种补充
4.继承是层次式的，不太灵活，修改某个类就会打破这种继承的平衡，但是接口就不会，因为只针对实现接口的类才起作用
5.用接口体现多态：
6.前期绑定：
在程序运行之前就进行绑定，由编译器和连接程序实现，又叫静态绑定，如static方法和final方法，包括private方法，它是隐式final的
7.后期绑定：
在运行的时候根据对象的类型进行绑定，由方法调用机制实现，因此又叫动态绑定，或是运行时绑定，除前期绑定外的所有方法都属于后期绑定
8.
//展示接口实现多态的概念
packagecom.s2;
//汽车接口
interfaceCar
{
StringgetName（）;//获得名字
intgetPrice（）;//获得价格
}
//宝马
classBMWimplementsCar
{
publicStringgetName（）
{
return"我日，宝马啊";
}
publicintgetPrice（）
{
return800000;
}
}
classQQimplementsCar
{
publicStringgetName（）
{
return"没意思的，qq";
}
publicintgetPrice（）
{
return20000;
}
}
publicclassCarShop
{
//售车的收入
privateintmoney=0;
//卖出一部车
publicvoidsellCar（Carcar）
{
System.out.println（"车型：
"+car.getName（）+"价格是：
"+car.getPrice（））;
money+=car.getPrice（）;
}
publicintgetMoney（）
{
returnmoney;
}
publicstaticvoidmain（String[]args）
{
CarShopa=newCarShop（）;
//卖出宝马
a.sellCar（newBMW（））;
//卖出qq
a.sellCar（newQQ（））;
System.out.println（"总收入是：
"+a.getMoney（））;
}
}
9.final概念：
final可以修饰变量和方法
当不希望父类的某些方法被子类覆盖的时，可以用final修饰
当不希望类的某个变量的值被修改，可以用final修饰
当不希望类被继承时，可以用final修饰
10.final修饰的变量一般用下划线书写
11.如果一个变量是final的，那么定义时候必须赋初值
12.final修饰的变量又叫常量，一般用XX_XX_XX命名
13.final什么时候用：
处于安全的考虑，类的某个方法不允许修改
类不会被其它的类继承
某些变量值是固定不变的，比如pi
第15讲讲题目
1.switch只能对int、short、byte以及枚举类型进行判断，case后面只能是常量表达是
2.猜拳的java程序设计：
有个人Tom设计他的成员变量，成员方法，和电脑猜拳，电脑每次都产生一个随机数0，1，2，0表示石头，1表示剪刀，2表示布。
请实现：
第16讲数组
1.数组是可以存放多个同一类型的数据
2.用法：
程序员用法：
数组定义：
数据类型数组名[]=new数据类型[大小];
如：
intarr[]=newint[5];
或者是int[]arr=newint[5];
或者是int[]arr=newint[5];
数组引用：
数组名[下标]
没事找事用法：
数组定义：
intarr[];arr=newint[5];
或者是int[]arr;arr=newint[5];
或者是int[]arr;arr=newint[5];
数组引用：
数组名[下标]
古板用法：
inta[]={1,2,3,4,5,6,7,8,9,0};
数组引用：
数组名[下标]
3.知道数组的大小：
arr.length（成员属性）
4.引用在栈里面，对象在堆里面
5.对象数组：
packagecom.test1;
importjava.io.*;
publicclassDemno5_2{
publicstaticvoidmain（String[]args）throwsIOException{
Dogdog[]=newDog[4];
InputStreamReaderisr=newInputStreamReader（System.in）;
Buffe
升级会员 