面向对象（Object Oriented Programming OOP）
面向对象程序设计有两个重要的概念：类class和对象object
类是一种抽象的概念，类中包含了数据域对数据的操纵
类包含两部分内容：
数据：在类中称作属性或者叫做成员变量
对数据的操纵：在类中称为方法
面向对象三大基本特征：继承、封装、多态
封装：类包含了数据与方法，将数据与方法放在一个类中就构成了封装
main方法是真个程序的入口点，如果没有main方法，则程序无法执行
方法定义不能嵌套,方法只能定义在类中,
return语句不一定返回值，return后跟分号表示结束成员方法的执行
public void test(int a){
if(a < 10){
return;
}
}
类的命名约定：首字母大写，如果由多个单词构成，要求每个单词的首字符都大写
方法名的约定：首字符小写，从第二个单词开始，每个单词的首字母大写
属性的命名约定，与方法相同
成员变量与局部变量的区别：
局部变量使用前必须声明并赋值
成员变量使用前必须声明但是可以不赋值，成员变量的默认初始值：
byte short int long默认值为0
float,double类型的默认值为0.0
char类型的初始值为 '\u0000'
boolean类型的初始值为false
如果一个类包含了属性和方法，那该类的每一个对象都有自己的属性，但是不管这个类有多少对象，它们都共享同一个方法
在java中，无论参数是原生数据类型还是引用，都是传值，没有传引用一说，
构造方法（constructor）用于完成对象属性的初始化工作
构造方法的名字必须与类名完全一致
构造方法没有返回值，连void也不能出现
如果在定义一个类的时候，没有为类声明构造方法，那么java编译器会自动为类添加一个没有参数且方法体为空的构造方法（默认的构造方法）
如果在定义类的时候，为类声明了构造方法，java编译器就不会为类添加构造方法了
不能显式调用类的构造方法，通常是通过new关键字隐式调用
new关键字的特点，完成了三件事
为对象开辟内存空间
调用类的构造方法
将生成的对象的地址返回
使用new来生成对象的时候，后面的小括号()表示构造方法的参数列表，如果构造方法不接收参数，那么小括号的内容为空，如果构造方法接收参数，那么小括号中的实际参数就要与定义中的形式参数一致
如果一个java源文件中定义了多个类，那么这些类中最多只能 有一个类是public，也可以没有，如果有public，那么main方法必须放到有public中
栈 stack
堆 heap
方法重载（Overload）
表示两个或多个方法名字相同，但方法参数不同（参数个数不同，类型不同），方法的返回值对重载没有任何影响
一个构造方法也可以调用另一个构造方法，但是构造方法不能显式的调用，所以可以用this()来调用构造方法
class Con(){
Con(){
this(3); //this必须要放在第一行，
System.out.println("hello");
}
con(int i){
//
}
}
继承
java是单继承的，意味着一个类只能从另一个类继承（被继承的类叫做父类，也叫基类，继承的类叫做子类）使用extends关键字
先执行父类的构造方法，然后执行子类的构造方法：
public class Child extends Parent{
public Child(){
System.out.println("child");
}
public static void main(String[] args){
Child child = new Child();
}
}
class Parent{
public Parent(){
System.out.println("parent");
}
}
输出：
parent
child
如果父类没有默认的构造方法，则会报错
public class Child extends Parent{
public Child(){
System.out.println("child");
}
public static void main(String[] args){
Child child = new Child();
}
}
class Parent{
public Parent(int i){
System.out.println("parent");
}
}
如果父类没有默认的构造函数，而我们偏要执行怎么办？我们可以用super()来改变默认寻找无参构造函数这种机制
public class Child extends Parent{
public Child(){
super(1) //调用java带参数的构造方法，必须是第一条语句
System.out.println("child");
}
public static void main(String[] args){
Child child = new Child();
}
}
class Parent{
public Parent(){
System.out.println("parent");
}
}
结果为：
parent
child
要生成子类的对象，首先要生成父类的对象
this表示对当前对象的引用，super表示对父类对象的引用
如果子类使用super()显式调用父类的构造方法，那么在执行的时候就会寻找与super()所对应的构造方法而不会再去寻找父类的不带参数的构造方法
关于继承
父类有的，子类也有
父类没有的，子类可以增加
父类有的，子类可以改变
构造方法不能继承
方法和属性可以被继承
子类的构造方法隐式的调用父类的不带参数的构造方法
如果父类没有不带参数的构造方法，那么用super()显式的调用父类的构造方法
方法重写（Override）：子类与父类的方法返回类型一样，方法名称一样，参数一样，这样子类和父类就构成了重写关系
方法重载与重写之间的关系：
重载发生在同一个类内部的两个或多个方法，重写发生在父类与子类之间，一定是伴随着继承发生的
当两个方法形成重写关系时，可以在子类方法中通过super.methodName() 调用父类的方法,不用必须放在第一行，因为此时父类的对象已经构造完成
如果定义一个类的时候，没有指定父类，那么它的父类就是java.lang.Object类
多态（Polymorphism）：是运行期的行为，不是编译期的行为
子类就是父类 好比说张三是人一样，玫瑰是花，但是不能说花是玫瑰，你懂的
父类的引用可以指向子类的对象
*重载不决定多态
eg：
public class PolyTest{
public static void main(String[] args){
Flower rose = new Rose(); //多态
rose.singing();
}
}
class Flower{
public void singing(){
System.out.println("hello");
}
}
class Rose extends Flower{
}
public class Test{
public static void main(String[] args){
Parent p = new Child();
p.speak();
}
}
class Parent{
/*public void speak(){ //注释后会出错
System.out.println("Hello ,I am parent!");
}*/
}
class Child extends Parent{
public void speak(){ //子类的这个方法注释后不会出错
System.out.println("Hello ,I am child!");
}
}
Parent = new Child();当使用多态方式调用方法时，首先检查父类中是否有sing()方法，如果没有则编译错误，如果有，再去调用子类的是speak()方法
在上面的例子中，Parent类型的引用p可以强制转换成Child类型的，也就是说，p指向谁，就可以强制转换成哪种类型，Child c = (Child)p; //right
多态是运行期的行为，而不是编译器的行为
一共有两种类型的强制类型转换
1）向上类型转换（upcast）,将子类型转换成父类型，不需要显式指定
Child c = new Child();
Parent p = c;
2）向下类型转换（downcast）,将父类型转换成子类型，必须要显式指定（必须要使用强制类型转换）
Parent p = new Child();
Child c = (Child)p;
抽象类（abstract class）使用abstract关键字修饰的类叫做抽象类
特点：
不能实例化，不能new出来一个对象
抽象方法（abstract method）：使用abstract关键字修饰的方法，有声明，无实现(public abstract void method(); 分号)
抽象方法需要定义抽象类中
抽象类中可以有具体的方法
在子类继承父类（父类是抽象类）的情况下，那么子类必须要实现父类中定义的所有抽象方法，否则，子类需要声明成abstract