Day1
写在最前
常量是公共的、静态的、不可改变的，必须初始值（一旦赋值，不可改变）
例如：public static final String str = "我终身不可变";
变量是可变的，值不固定的，可分为成员变量、全局变量。
成员变量的方位就是在方法内部，如下代码：
public void add(int i){
System.out.println(i);//i的值是局部的，范围是{开始}结束。
}
全局变量是定义在类内部，方法外部，例如：
public class Person{
private String name; //默认为null
name = "张三"; //改变name的值
}
对象操作自己里的变量的方式：对象.变量 例如：Rect1.height;
对象调用方法：对象.方法 例如：Rect1.getarea();//不是类名去调用方法
先声明对象后创建对象
用new运算符和类的构造方法为声明的对象分配变量，即创建对象：car = new Chezi；
对象的声明一般是 类的名字 对象的名字：Vechicle car；
方法的声明基本：包括方法名和方法的返回类型
如果局部变量的名字和成员变量的名字相同，则成员变量被隐藏，即这个成员变量在这个方法里暂时失效，但是想使用这些被隐藏的成员变量，便可使用关键字this
先声明对象 再创建对象 例如:
Rect rect1,rect2; //通过类进行声明对象
rect1 = new Rect(); //创建新的对象
强制转换(int)'a'
jdk1.5之后加入了Scanner这个类
Scanner reader = new Scanner(System.in); //这个地方是让让系统获取到键盘的键入
rect.width = reader.nextDo1
uble(); //造成堵塞，只有在遇到了Enter建之后才会继续进行下一步骤
%d：int型 %c：char型
运算符的优先级和结合性
switch(表达式){ //表达式和常量值中的必须为byte,short,int,char，枚举型
case 常量值1：
若干语句
break；
case 常量值2 ：
若干语句
break；
。
。
。
default:
若干语句；
}
do-while循环
do{ 图解：
若干语句；
}while（表达式）
dowhile语句至少执行一次，while可能一次都不执行
break循环：如果在某次循环中执行了break，那么该循环就结束。且break和标号语句可以跳出多层循环。
continue循环：如果执行了continue语句，呢么本次循环结束。不再执行continue后面的语句，转入下次的循环
**************************************************************************************************************************************************************************************************
**************************************************************************************************************************************************************************************************
**************************************************************************************************************************************************************************************************
Day2
参数的传递
java中的参数传递的值得级别不可以高于该参数的级别，比如不可以向int型参数传递一个float型的，但是可以向double型的传一个float型的
void setRadious(double r)
给这个方法传递了一个double型的r
可变参数
可变参数是指在声明方法时不给出参数列表从某项直至最后一项参数的名字和个数，但这些参数的类型是必须相同的。可变参数使用...表示若干个
参数这些参数的类型必然相同，最后一个参数必须是参数列表中的最后一个参数。
public void f(int ... x){
}
对于可变参数，Java也增强了for语句，允许按照如下的方式使用for语句遍历参数代表所代表的参数：
对于循环变量一次取参数代表所代表的每一个参数的值
for (声明循环变量: 参数代表){ for(int param:x){
.................. sum=sum+x;
} }
实例变量和类变量的区别
double height，long； //实例变量
static double bottom； //类变量
类变量不仅可以通过某个对象访问，而且可以通过类名进行访问
实例变量可以通过对象访问，但是无法通过类名访问
实例方法和类方法的区别
加static关键字修饰的就是类方法（静态方法），否则为实例方法
实例方法可操作实例变量也可以操作类变量；实例方法不能通过类名调用，只能由对象调用
类方法不可操作实例变量
方法的重载和多态
区别：
方法的重载：
一个类可以有多个方法具有相同的名字，但这些方法的参数必须不同，即参数个数不同，或类型不同
例如：
class A{
float add(int a,int b) {
ruturn a+b;
}
float add(long a,long b){
return a+b;
}
}
方法重写：子类可以通过重写隐藏已经继承的实例方法（方法重写也被称为方法覆盖）
子类通过方法的重写可隐藏继承的方法，把父类的状态和行为改变自身的状态和行为；重写方法既可以操作继承的成员变量，新定义的其他方法，但是无法操作其他被子类隐藏的成员变量和方法。
如果子类想使用被隐藏的方法或成员变量，必须使用关键字super
且父类方法中的类型和子类中的类型都必然是相同的
方法重写的注意事项：1.重写的方法必须要和父类一模一样（返回值类型，方法名，和参数列表）
2.使用@Override注解来进行标识
3.子类重写的访问权限不能低于父类中的方法访问权限
权限修饰符 : private < 默认(什么都不写) < protected < public
重写的应用：
当子类需要父类的功能，而功能的主体子类还有自己特有的内容时，可以重写父类中的方法， 这样，即沿袭了父类的功能，又定义了子类自己特有的内容。
关键字super
子类一旦隐藏（重写）了继承的成员变量，那么子类的创建对象就不再拥有该变量，归于关键字super所有，同样对于被隐藏的方法也是归于super
super的括号里写的是要调用的父类的构造方法里的参数列表
super的应用：
super.call(name); //这段代码是上面的重写的应用里的，可以看到在这里使用了super去调用了父类中的call方法，并且传递进去了一个name参数
关键字final
final可做修饰类，成员变量，方法中的局部变量
可以使用final将类声明称final类。final类无法继承，final class A {
}
如果让final修饰父类的一个方法，那么该方法不允许子类重写，也就是说不允许子类隐藏可以继承的final方法，只能继承，无法修改
1.修饰类当用final去修饰一个类的时候，表示这个类不能被继承。注意：a. 被final修饰的类，final类中的成员变量可以根据自己的实际需要设计为fianl。b. final类中的成员方法都会被隐式的指定为final方法。
2. 修饰方法
被final修饰的方法不能被重写。
注意：
a. 一个类的private方法会隐式的被指定为final方法。
b. 如果父类中有final修饰的方法，那么子类不能去重写。
3.
修饰成员变量
注意：
a. 必须要赋初始值，而且是只能初始化一次。
4.
修饰成员变量
注意：
a. 必须初始化值。
b. 被fianl修饰的成员变量赋值，有两种方式：1、直接赋值 2、全部在构造方法中赋初值。
c. 如果修饰的成员变量是基本类型，则表示这个变量的值不能改变。
d. 如果修饰的成员变量是一个引用类型，则是说这个引用的地址的值不能修改，但是这个引用所指向的对象里面的内容还是可以改变的。
关键字this
this是Java中的一个关键字，表示某个对象，this只能出现在实例方法中，不能出现在类方法中
this.x=100;
访问权限
private和protected的区别：private声明的变量是无法继承的，protected所申明的是在同一个包内都可以访问的;
不用public private protected的即为友好变量和友好方法
子类与父类
最直接的就是子类想要复用这个类中的方法和变量，用关键字extends来声明一个类的子类
class 子类名 extends 父类名字 {
.........
}
如果一个类没有直接使用extends这个关键字，则被直接认定为Obeject的子类，即为java.lang包中的类
当子类与父类不在同一个包里面的时候，父类的private和友好访问权限的成员变不会被子类继承，子类只继承父类的protected和public访问权限的成员变量和方法；
instanceof运算符 双目运算符
YYK instanceof People ； //instanceof左侧是对象 右侧是类 如果对象是有类产生的 则为true 否则为false
对象的上转型对象
A类是B类的父类，当用子类创建一个对象的时候，并且把这个对象的引用放到父类的对象中时，对象a是对象b的上转型对象(就比如说美国人是人)
A a；
B b=new B();
a=b;
1.上转对象不能操作子类新增的成员变量（丢失的这部分属性）；不能调用子类新增的方法
2.上转对象可以访问子类继承或子类重写的实例方法，其作用等价于子类对象去调用这些方法。
则当子类重写了父类的某个实例方法后，当对象的上转型对象调用这个实例方法时一定调用了子类重写的实例方法。
3.不能将父类创建的对象和子类的对象的上转型对象混淆
4.可以将对象的上转型对象再强制转换到一个子类的对象，这时候，该子类对象又具备了子类所有的属性和功能
5.不可以将父类创建的对象的引用赋值给子类的声明的对象（“不能说人是美国人”）
多态性
就是指父类的某个实例方法被其子类重写，可以产生各自的功能行为，被子类各种调用。
使用多态进行程序设计的核心技术之一就是使用上转型对象，即将abstract类声明对象作为其子类的上转型对象，那么这个上转型对选哪个就可以调用子类重写的方法
所谓的面向抽象编程，是指的是当设计一个类的时候，不让该类面向具体的类，而是面向抽象类，即所设计类中的重要数据是抽象类声明的对象，而不是具体类声明的对象
java实现多态的三种必要条件：继承，重写，向上转型
- 继承：在多态中必须存在有继承关系的子类和父类。
- 重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。
- 向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才既能可以调用父类的方法，又能调用子类的方法。
实例：
abstract类
对于abstract方法，只允许声明，不允许实现，而且不允许使用final和abstract同时修饰同一个方法
abstract int min(int x,int y);
无法实例化，只能继承是他的特点；且无法使用new运算符来创建对象
如果一个abstract类是abstract类的子类，它可以重写父类的abstract方法，也可以继承。
接口
interface 接口名字；
接口体中包含常量的声明（没有变量）和方法定义两部分。接口体中只有抽象的方法，没有普通的方法，而且接口体中所有的常量都是static常量，所有的抽象方法的访问权限一定是public的
例如：
interface Caulator {
public final static int MAX=100;
public abstract void add();
public abstract float sum();
}
接口的使用：一个类可以实现多个接口，类通过关键字implements声明自己实现一个或多个接口，使用implements声明。
class A implements Add,Sub;
A类实现Add和Sub的接口
类重写的接口方法以及接口中的常量可以被类的对象调用，而且常量也可以用类名或接口名直接调用。
接口声明时，如果关键字interface前加public的关键字：public interface A{} //这个接口即可被任何一个类所实现
不加public的话就是友好接口，只能说在同一个包内可以实现
如果父类实现了某个接口，子类也同样实现了
重写接口内的方法 public int f (int x){}
接口也可以被继承，即可通过关键字extends声明一个接口是另一个接口的子接口。由于都是public的，子接口会继承父接口的所有方法和常量
如果一个类声明实现一个接口，但没有重写接口中的所有方法，那么这个类必须是abstract类。
接口的回调
用接口声明的变量可以称为接口变量，接口变量属于引用型变量，接口变量中可以存放实现该接口的类实例的引用。
接口的回调指的是，可以把实现某接口的类创建的对象引用赋给该接口声明的接口变量中，那么该接口变量就可以调用被类实现的接口方法。
实际上，当接口变量调用被实现的接口方法时，就是通知相应的对象调用这个方法； 接口无法调用类中的其他非接口方法；
由接口产生的多态就是指不同的类在实现同一个接口时，可能具有不同的实现方式
abstrac类和接口的比较
1.abstract类和接口都可以有abstract方法
2.接口中只可以有常量，不能有变量；而abstract中既可以有常量也可以有变量
3.abstract类中也可以有非abstract的方法，而接口不可以
4.abstract类除了可以提供重要的需要子类重写的abstract方法外，也提供了子类可以继承的变量和非abstract的方法