1.java中可以定义一些不含方法体的方法，他的方法体的实现交给该类的子类更具自己的情况去实现，
这样的方法是抽象方法，包含抽象方法的类叫抽象类。

2.抽象类必须用abstract关键字来修饰，抽象方法必须用abstract关键字来修饰，
3.抽象类不能被实例化，也就是说不能用new关键字去产生对象。
4.抽象方法只需要声明，不需要实现
5.含有抽象方法的类必须被声明为抽象类，抽象类的子类必须覆盖所有的抽象方法后才能被实例化，否则这个子类也还是抽象类
6.抽象类可以没有abstract方法（可以有别的方法），但是一个类如果有abstract方法，那么这个类必须用abstract修饰。
7.抽象类目的：使所有子类有相同的名字的方法。
8.不是抽象类中的所有方法都是抽象方法

1.final类不能被继承，即不能有子类
2.方法被final修饰，则这个方法不能被重写，只能继承不能覆盖。如果再用static修饰，那就是类方法了，
可以直接被类调用。
3.成员变量是final ，则变量只能被赋值一次，不能再次赋值
public final String x="abc" //这样是可以的

但是不能public final String  x

-----

然后再赋值是不可以的。
要么就是在变量初始的时候就赋值，要么就是在构造方法里进行赋值，
在其他地方都不能对final的变量进行复制
4.如果一个final的变量存在，在一个构造函数中对final变量赋值，那就必须在所有的构造函数中对他赋值

5.如果不产生对象，直接使用变量我们需要定义变量
（public static final共同标记的常量，这个常量就成了全局的变量）

class Person
{
  public static final String x// 不产生对象直接通过类就可以访问的变量即 Person.x,但是必须啊
                                 在定义常量的时候对x进行初始化，但是就不能在构造行数中竞相初始化了
  public String name="unknown";
  public int age=-1;//如果一个变量被赋值为1，表示这个变量没有被初始化
  public Person()//构造方法
  {
  }
     public Person(String name,int age)//构造方法
     {
           this.name=name;
            this.age=age;
     }
     public void getinfo()
     {
         System.out.println("name="+name+",age="+age);
     }
}

6.final标记的变量（成员变量或局部变量）即成为常量，只能被赋值一次
7.Float.MAX_VALUE，float最大值
8.方法中定义的内置类只能访问该方法内的final类型的局部变量，用final定义的局部变量相当于
一个常量，他的生命周期超出了方法运行的生命周期，经一个形参定义成final也是可以，
但是这就限定了我们在方法中修改形式参数的值。

1.子类有和父类同名的函数，子类对象调用的函数就是子类中的函数
2.子类不能把覆盖父类的方法变得更弱。子类不能继承父类中的私有的方法。
2.如果子类有和父类同名的函数，但是子类对象又想调用父类的函数，可以用super来表示调用的父类的函数
如：super.getinfo();//表示调用的父类的getinfo()
class Student extends Person //没有构造方法
 {
     public String school="unkown";
  public Student()
  {
   super();
     }
    public Student(String name,int age,)
 {
   super(name,age);
 }
     public Student(String name,int age,String school)
 {
   //super(name,age);
   this(name,age);//调用的是第二个构造函数
   this.school= school;
   super.getinfo();//表示调用的父类的getinfo()
函数 }
  public void getinfo()
     {
         System.out.println("school="+school+"name="+name+",age="+age);
     }
     public void study()
          {
          }   
}

class Person
{
     public String name="unknown";
  public int age=-1;//如果一个变量被赋值为1，表示这个变量没有被初始化
  public Person()//构造方法
  {
  }
     public Person(String name,int age)//构造方法
     {
           this.name=name;
            this.age=age;
     }
     public void getinfo()
     {
         System.out.println("name="+name+",age="+age);
     }
}

class Student extends Person //没有构造方法
 {
     public String school="unkown";
  public Student()
  {
   super();
     }
    public Student(String name,int age,)
 {
   super(name,age);
 }
     public Student(String name,int age,String school)
 {
   //super(name,age);
   this(name,age);//调用的是第二个构造函数
   this.school= school;
 }
     public void study()
          {
          }   
}

class TestStudent
{
     public static void(String [] args)
      {
         Student st= new student("zhangsan",20,"清华大学");
         /*st.name="zhang";
                           st.age=12;*/
           st.getinfo();
     }
}

1.分配成员变量的存储空间并进行默认的初始化，就是用new关键字，
产生对象后，对类中的成员变量按第三章的表的对应关系对对象中的成员
变量进行初始化赋值。
2.绑定构造方法参数，就是new Person(实际参数列表)中所传递进的参数赋值给构造方法中
的形式参数变量
  Student st= new student("zhangsan",20,"清华大学")
3.在执行构造方法之前，检查构造函数中看有没有this()函数（调用其他的构造方法的函数），如有this()调用，则调用相应的重载构造方法(被调用的重载构造方法又从步骤2开始执行流程),
被调用的重载构造方法的执行流程结束后，回到当前构造方法，当前构造方法直接跳转到步骤6（程序代码不包括super()和this()这样的语句的）
4.如果没有this()这样的函数，就显示或隐式追溯（super()隐藏或显示的意思）调用父类的构造方法(一直到Object类为止，Object是所有java类的最顶层父类，在本章后面部分有详细讲解)，父类的构造方法又从步骤2开始对父类执行这些
流程，父类的构造方法的执行流程结束后，回到当前构造方法，当前构造方法继续往下执行。
5.进行实例变量的显式初始化操作，也就是执行在定义成员变量时对所进行赋值的语句，如：
public String school="unkown";
6.执行当前构造方法的方法体重的程序代码。

1)为什么super() 和this()调用语句不能同时在一个构造函数里出现？
有了this（）再有super（）就没有意义了
2)为什么super() 和this()调用语句只能作为构造函数中的第一句出现？

1. 通过继承可以简化类得定义
2. java只支持单继承，不允许多重继承。(不能同时继承多个类)
3. 可以有多层继承，即一个类可以继承某一个类的子类
   如B继承了A，类C又可以继承B，那么类C也间接继承了A。
4. 子类继承父类所有的成员变量和成员方法，但不继承父类的构造方法。 
 在子类的构造方法中可以使用super（参数列表）调用父类的构造方法
不继承父类中private的成员变量和方法
5. 如果子类的构造方法中没有显示调用父类构造方法，也没有使用this关键字调用重载的其他构造方法，则在产生子类的实例对象时，系统默认调用父类无参数的构造方法。
子类是必须要调用父类的构造函数的，
class Person
{
pulic String name;pulic int age;
pulic Person(String name,int age)//构造方法
  {
   this.name=name;
   this.age=age;
  }
public void getinfo()
 {
  System.out.println("name="+name+",age="+age);
  }
}

class Student extends Person //没有构造方法
{
pulic String school;
pulic void study()
  {
  }
}

class TestStudent
{
pulic static void(String [] args)
  {
   Student st= new student();
   st.name="zhang";
   st.age=12;
   st.getinfo();
  }
}

注明：
1).上面的程序执行时会提示错误，会提示子类找不到不带参数的Person构造函数，
如果一个应用程序中没有构造函数，则系统会自动增加一个不带参数的构造函数，
所以Student有一个默认的不带参数的构造函数。
在创建Student对象时，在调用student自身构造函数之前是需要先调用父类Person的不带参数的构造函数，
而Person中已经有带参数的构造函数，没有不带参数的构造函数，所以上面的程序运行时，编译器会报错。
2).针对这种情况，我们可以在Student类中的增加一个构造函数
public Student()
{
 super(”zhangsan",15)
}
在运行就不会出错的。
3).子类无论如何都需要调用父类的构造函数的。
4).使用super操作被隐藏的成员变量和方法，super.x和super.play()
5).this是调用全局变量，this()是调用其他的函数

6.如果一个类的生命中没有使用extends关键字，这个类被系统默认为是Object的子类，
Object是包java.lang中的类
7.成员变量的隐藏和方法的重写
当子类定义的成员变量和父类的成员变量同时，父类的成员变量不能被继承，
子类有和父类的方法一样的情况也不继承。
8.如果在子类中想使用被子类隐藏的父类的成员或方法就可以使用关键字super.
例如：super.x;super.play()
子类如果想调用父类的构造方法，必须在子类的构造方法中使用super，
并且必须是子类构造方法中的头条语句
super(父类构造方法中的变量)

class student extends Person
{

}

9.注意如果一个应用程序中没有构造函数，则系统会自动增加一个不带参数的构造函数
10.在定义类时，只要在父类中定义了有参数的构造函数，还要定义一个无参数的构造函数，因为它的子类中需要调用父类的构造函数
11.
class Person
{
pulic String name;pulic int age;
pulic Person(String name,int age)//构造方法
  {
   this.name=name;
   this.age=age;
  }
public void getinfo()
 {
  System.out.println("name="+name+",age="+age);
  }
}

class Student extends Person //没有构造方法
{
pulic String school;
pulic void study()
  {
  }
}

class TestStudent
{
pulic static void(String [] args)
  {
   Student st= new student();
   st.name="zhang";
   st.age=12;
   st.getinfo();
  }
}