类：
类就是对某一事物的描述（举例：蔬菜，水果，动物）
对象：
对象就是实际存在的事物的个体，（举例：蔬菜中某一种，人类（分男人和女人））
标准类：
【类的修饰字】 class 类名称 【extends 父类名称】【implements 接口名称列表】{
变量定义及初始化； 成员变量；
方法定义及初始化； 成员方法；
}
记住：继承只能继承一个类，可以实现多个接口，
static：静态方法，又称为类方法，static声明的变量值，所有对象使用的值都是一致的
调用静态成员变量，类名。静态成员
对象的定义：
对象的创建即对类的属性和行为的实现（类的实例化）
声明一个类的变量，就是声明了该类的一个实例，即对象，创建对象包括声明对象，实例化对象，即为对象分配存储空间两步
类名 对象名 = new 类名（）； 例如：A aa = new A(); A（）叫做构造函数
--------------------------------------------
方法参数传递
public int s(int x ,int y){
return ? (返回值类型)
}
引用类型传递：
public A s(A a ){
return a ;
}
-----------------------------------------------------
面向对象的三大特点：封装，继承，多态
封装： 主要实现了隐藏细节，对用户提供访问接口，无需关心方法的具体实现。
继承： 继承能很好的实现了代码复用，提高饿了编程效率
类具有继承性，子类对父类的继承关系，体现了现实世界中特殊和一般的关系。
通过继承可以更有效的组织程序结构，明确类之间的关系。并充分利用已有的类来完成更复杂，深入的开发
class <子类> extends <唯一的父类名>
{
<类定义体>
}
类之间只能单继承，不能多继承，下面这幅图：
子类可以继承父类所有的后成员变量和成员方法，但不能继承父类的构造方法。在子类的构造方法中可使用语句super（参数列表）调用父类的构造方法。
class Student extends Person
{
public Students (String name ,int age ,String school){
super(name ,age); //调用父类的构造方法
this.school = school;
}
}
-------------
构造方法：
1，与类相同
2，没有返回值类型，不能用return
3，一般用public修饰
所有的类中都有一个默认的无参构造方法
重写构造方法后，默认的无参构造方法失效
构造函数主要用来做默认初始化
子类继承父类后
不能继承父类的构造方法，在new子类构造方法时候，默认去执行无参的构造方法
如果父类是重写为有参数的构造方法的话，子类必须重写构造方法
子类可以扩展自己成员
--------------------------------
重写和重载：
----------------------------------------------------------------------------------
内部类：
package day05;
/**
* 演示内部类1：内部类在方法外面
* 内部类有两种，一种在方法外面，。
* 一种在方法内部
* 内部类可以访问外部类的成员，包括私有成员，成员包括成员变量和成员方法
* 但是外部类不能访问内部类的成员
* 内部类生成的.class 文件 neibu$nimei.class
* 如果内部类没有static,里面成员不能用static修饰
* @author yw.wang
*
*/
public class neibu {
private int a = 1;
private void haha(){
System.out.println("fuckyou!!!");
}
public static void main(String args[]){
neibu n = new neibu();
//内部类的创建。并且如果引用变量，采用就近原则
//外部类.内部类 内部对象名 = 外部类对象.new 内部类（）;
neibu.nimei n1 = n.new nimei();
n1.usehaha();
neibulei2 n2 = new neibulei2();
n2.show2();
}
class nimei{
//public static int a = 10;
public void show(){
System.out.println("我是一个show方法");
System.out.println(a);
}
public void usehaha(){
haha();
}
}
static class neibulei2{
public void show2(){
System.out.println("我是第二个内部类，加了静态，相当于普通类");
}
}
}
内部类在方法内部：
package day05;
public class Test03 {
public void a() {
class xinlei {
public void b() {
System.out.println("哈哈");
}
}
xinlei x = new xinlei();
x.b();
System.out.println("呵呵");
}
public static void main(String[] args) {
Test03 dd = new Test03();
dd.a();
}
}
抽象类：
package day05;
/**
* 演示抽象类
* 1.用abstract修饰的类
* 2.只有方法定义，没有方法实现,抽象方法只能出现在抽象类中
* 3.抽象类包含抽象方法，但是也可以有普通方法，普通变量
* 4.创建对象，不能直接new，只能new子类的的实现，
* 子类如果想继承抽象类，必须重写所有的抽象方法，子类就不是抽象类了
* 5.如果不重写，那么子类也是抽象类，也不可以直接new
* @author yw.wang
*
*/
public abstract class AbstractTest01 {
public int a = 123;
abstract void haha();
public void hehe(){
System.out.println("fuckyou!!!");
}
public static void main(String[] args) {
def2 d2 = new def2();
d2.haha();
}
}
class def2 extends AbstractTest01{
void haha() {
//重写了抽象类父类的haha方法，现在不是一个抽象类，haha方法也不是抽象方法，所以可以直接new
System.out.println("我重写了父类的抽象方法！！");
}
}
接口：
package day05;
/**
* 接口演示：
* 接口只能包抽象方法和常量
* 在接口中方法如果没写abstract修饰，那么该方法被默认是抽象方法
* 只能new接口的实现类，也必须重写接口的抽象方法
* @author yw.wang
*
*/
public class InterfaceTest01 implements Interface,a,b,c {
@Override
//实现接口的抽象方法
public void function() {
System.out.println("实现了接口的抽象方法");
}
public static void main(String[] args) {
InterfaceTest01 in = new InterfaceTest01();
in.function();
}
}
interface Interface {
public int a =10;
public abstract void function();
}
interface a{}
interface b{}
interface c{}
接口和抽象类的区别：
1，java中所有的类的父类java.lang.Object,但是接口没有共同的根
接口可以当做抽象类使用，区别如下：
1，接口中的每个方法，没有实现部分，都是抽象方法，；抽象类中可以有具体的方法
2，接口中的数据必须是常量；抽象类可以有各种类型的数据
3，由于定义在接口中所有方法都是抽象方法，接口中可以省略abstract修饰符；
但是抽象类中的抽象方法必须用abstract修饰