Java基础--面向对象

1，简介与构造

相对面向过程，面向对象应用起来更简单，取得一个对象后，调用它内在的各种功能就能指挥此对象完成想要的功能。面向对象基于面向过程，前者的功能实现依赖于后者。
三个特征： 封装、继承、多态。
类和对象的关系：对象是实体，类是对它的描述。
匿名对象：即无名字的对象。可以调用一次对象的方法，以简化代码。不可多个成员的调用，此为其限制。可以作为实际参数传递。相较于创建对象的方法的区别是，它在main函数的栈空间没有堆内存对象的地址存储。

构造函数，与类名相同。不定义返回值类型，不返回。对象一建立就调用构造函数来初始化对象。
构造函数随对象的建立只运行一次，一般方法可以多次调用。

构造代码块：

{
    ......
}

构造代码块给所以的对象统一初始化。它优先于构造函数执行。针对对象的共性内容编写。

this关键字。 this代表调用对象所指的对象。
this有一方法，只在构造函数中使用this（。。。）；即构造函数重载时，调用已有构造函数的方法。简化代码。
static关键字：修饰成员，存在于栈中，可以直接被类名调用。节省空间。优 先于对象存在。类变量随着类的加载存在于方法区，实例变量随对象建立存在于堆。
静态方法只能访问静态变量。不可以定义this，super关键字。

main不是关键字，但是是一个特殊的可以被jvm识别的单词。
静态的使用：
静态变量， 对象中存在共享数据，定义为静态变量。
静态方法， 功能内部没有访问非静态数据，定义为静态方法。
工具类的创建， 将类内部的函数都设置为静态，然后main函数调用方法的时候不需要new class，类的构造函数需要设置为private，这样其他类就不能new对象了。

2，文档的制作， 类要是public才有权限制作。允许对外暴露。

/**
xxxxxxxx
@author xxxxx 作者
@version  xxxxx 版本
@param xxxx 参数名的解释
@return xxxx
*/

javadoc -d +存储位置 -author -version +xxx.java
在生成的所有文档中查看index.html
其中，默认构造函数随着类的权限变化，如果不想，自己添加构造函数。



静态代码块， 在类中，没有名字，随着类的加载只执行一次。用于类的初始化。

static
{
xxxx
}

对象初始化的内存加载顺序， new class

.class文件加载的内存后，static代码块对类进行初始化->堆中开辟空间->默认初始化->对属性显示初始化->对对象构造代码块初始化->对应的构造函数初始化->内存地址存入栈内存。

3，单例设计模式；解决一个类在内存中对象的唯一性。

三步实现：1.构造函数私有化。2.创建一个本类对象。3.提供方法获取对象（静态）。
懒汉式 与 饿汉式

class Single //饿汉式，一进内存即创建对象，较常用。
{
    private static Single s = new Single();
    private Single(){}
    public static Single getInstance()
    { 
        return s;
    }
}
class Single//懒汉式，调用getInstance时才创建对象，延时加载。需要同步锁解决安全隐患
{
    private static Single s = nullprivate Single(){}
     public static Single getInstance()
    {
        if (s == null)
            s=new Single();;
            return s;
    }
}

子类的权限要大于等于父类的权限，如果没写，默认是public与private直接。
重载：只看参数的不同。
重写/覆盖：要一模一样。

子类函数的构造注意点

class  Fu
{
 Fu(int x)
 {}
}

class Zi extends Fu
{
 Zi()
 {
  super(2);//对于父类构造函数有参数的，此处要显示指定父类的参数。
 }
}

类的修饰符有两个，public 、final 但是private不能修饰，只能修饰成员的。但是，内部类可以用private修饰。

抽象类， 里面的方法是抽象的类，这样的类不能创建对象，因为他没有具体的方法。其子类必须实例化它所有的抽象方法才能new对象。
抽象类相较于继承，前者能强制子类进行实例化方法。抽象类却没有抽象方法的作用在于不让该类创建对象。关键字放的位置要在返回类型的前面，也就是放在开头。


一个简单的计算运行时间的小程序；模板方法设计模式示例

abstract class  GetTime
{
    final public void getTime()
    {
        long start, end;
        start = System.currentTimeMillis();

        runcode();

        end = System.currentTimeMillis();

        System.out.println("Hello World!"+(end-start));
    }
    abstract public void runcode();
}

class SubTime extends GetTime
{
    public void runcode()
    {
        //xxxxx;
    }
}

class TempleteDemo
{
    public static void main(String[] args) 
    {
        SubTime st=new SubTime();
        st.getTime();
    }
}

4，接口，interface

写法： 常量，public static final int NUM=1;
        方法，public abstract void show（）；

//内部类的疑点解释
class Outer
{
 int x = 3;
 void method(final int a)
 {
  final int y = 4;
  class Inner
  {
   void function()
   {
    System.out.println(a);//此处的变量a只能访问被final修饰的。
   }
  }
  new Inner().function();
 }
}

class InnerClassDemo
{
 public static void main(String[] args)
 {
  Outer out = new Outer();
  out.method(7);
  out.method(8);//这两次调用可以编译通过，因为每调用一次都是讲method进栈，
  //执行完成后退出，再进下一个method，如果改成a++就不行了，
  //因为一个method还没执行完。
 }
}

5，匿名内部类： 前提，内部类必须继承一个类或者实现一个接口

这个类既然没有名字，那么使用其父类的名字new对象，然后{}实现继承的方括号外用.xx(); 调用方法。

匿名内部类中定义的方法最好一到两个。
如果有两个方法都要使用，那么会用到多态的概念。父类引用调用子类对象。涉及到的方法必须是父类中存在的方法。