面向对象构造方法、抽象类、内部类

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

面向对象构造方法、抽象类、内部类

一、面向对象构造方法

       构造器 又称为构造方法 ，constructor
       构造器用于构造该类的实例。作用：用来初始化对象！
代码：
    [修饰符]  类名 （形式参数列表）{
         //语句
     }
是一种特殊的方法：
    （1）通过new关键字调用！！
    （2）构造器虽然有返回值，但是不能定义返回类型（返回值的类型肯定是本类），不能再构造器里调用 return。
    （3）如果我们没有定义构造器，则系统会自动定义一个无参数的构造函数，如果已经定义则编译器不会添加，覆盖了系统默认的构造方法。
    （4）构造器的方法名必须和类名一致。
    （5） 构造该类的对象，经常用来初始化对象的属性。

      1.构造方法必须与类名保持一致，
      2.无返回类型
      3.通过new来调用
      4.无参构造函数问题：
         a)如果我们没有定义构造器，则系统会自动定义一个无参数的构造函数
         b)如果已经定义则编译器不会添加
5.构造方法的第一句总是super，即调用直接父类的构造方法
        a)有继承关系的构造方法调用的顺序

       对象一建立就会调用与之对应的构造函数，new几次 就会调用几次。

 构造函数和一般方法在运行上的不同：
       构造函数是在对象一建立就运行，给对象初始化。而一般方法是对象调用才执行，是给对象添加对象具备的功能

一个对象建立，构造函数只运行一次，而一般方法可以被该对象调用多次。构造函数与set。get方法应同时存在，构造函数是给对象初始化，set、get方法是对外提供的公共方法。

       什么时候 定义构造函数？
       分析事物时，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数中。

构造代码块：
{
   语句
}

作用，给对象进行初始化，对象一建立就运行，而且优先于构造函数执行。
与构造函数的区别：

       构造代码块是给所有对象进行统一初始化，定义的是不同对象共性的初始化内筒。构造函数是给对应的对象初始化。

 

二、抽象类

抽象类：abstract。
       当多个类中出现相同功能，但是功能主体不同，这时候可以进行向上抽取，只抽取功能定义，而不抽取功能主体。分析事物不确定时，就抽象
特点
     1.抽象方法只能定义在抽象类中。
     2.抽象方法和抽象类必须被abstract修饰
     3.抽象类不可以用new 创建对象，因为创建对象没有意义
     4.抽象类中的抽象方法要被使用，必须由子类复写抽象方法后，建立子类对象调用，
     如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。如果不想子类是抽象类必须，复写父类抽象类中的全部抽象方法。

     抽象类和一般类没有太大的区别，当事物出现不确定的功能，需要明确指出，但是无法定义主体，通过抽象方法来表示。

     抽象类比一般类多了个抽象方法，抽象类不可以实例化，抽象类中还可以定义非抽象方法，目的是不让该类建立对象。

      抽象类可以包含 普通方法 成员变量 构造方法

例子：

abstract class enmployee{
 
 private String name;
 private int id;
 private double money;
 
 public enmployee(String name, int id, double money) {
  super();
  this.name = name;
  this.id = id;
  this.money = money;
 }
 
 public abstract void work();
}

class yuangong extends enmployee{
 
 
 public yuangong(String name, int id, double money) {
  super(name, id, money);
  
 }

 public void work(){
    //员工工作
 }
 
}

class jingli extends enmployee{
 
 double jiangjin;
 public jingli(String name, int id, double money,double jiangjin) {
  super(name, id, money);
  this.jiangjin=jiangjin;
  
 }

 public void work(){
    //经理工作
 }
 
}
模板方法模式：

      在定义功能时，功能的一部分是确定的，但有一部分是不确定的，而确定的部分
      在使用不确定的部分。就将不确定的部分暴露出去。由该来的子类去实现。将确定的部分final修饰 ，禁止修改。

案例：
/*
 * 获取一段程序的运行时间
 *
 */

abstract class GetTime
{
 public final void gettime()
 {
  long start = System.currentTimeMillis();
  
   runcode();
  
  long end = System.currentTimeMillis();
  System.out.println(end-start);
 
 }
 
 public abstract void runcode();
}

class Subtime extends GetTime{
 public void runcode(){
  for(int x=0;x<1000;x++){
   System.out.println(x);
  }
 }
}

 

三、内部类

内部类

      讲一个雷定义在另一个类的里面，对立面那个类就叫做内部类，或者嵌套类。
      特点，内部类可以直接访问外部类中的成员。包括私有成员。而外部类要访问内部类中的成员必须要建立内部类对象。

代码
class outer

   class inner
     
     void function(){}

   }

}
inner内部类。

访问规则：

         1.内部类可以直接访问外部类中的成员，包括私有。是因为内部类中持有了一个外部类的引用。格式：外部类名.this
         2.外部类要访问内部类，必须要建立内部类的对象。
         3.内部类作为外部类的成员 可以被私有化
如何直接访问内部类中的成员 function()
outer.inner  in=new outer().inner();
   in.function();

访问格式：
      1.当内部类定义在外部类的位置上的时候，而且非私有，可以在外部其他类中，可以直接建立内部类对象
      格式 外部类名.内部类名  变量名=外部类对象.内部类对象
       outer.inner  in=new outer().inner();

      2.当内部类在成员的位置上，就可以被成员修饰符所修饰。
         比如：private  static，
       当内部类被static修饰后，只能直接访问外部类中的static成员，出现了访问局限
      在外部其他类中，如何直接访问static内部类的非静态成员？
      new Outer.Inner().sunction();
      在外部其他类中，如何直接访问staic内部类的静态成员？
       outer.inner.function();
注意：当内部类中定义了静态成员，该内部类必须是static 的。
     当外部类中的静态方法访问内部类是，该内部类必须是静态的

内部类定义原则：

      当描述事物中，事物的内部还有事物，该事物用内部类来描述。
      因为内部事务在使用外部事物中的内容。

局部内部类
class outer{

   int x=3;
    void  method()
   {
          int y=4;
          class inner{
     
            void function(){}

           }
    }

}

内部类定义在局部的时候：
      1.不可以被成员修饰符修饰
      2.可以直接访问外部类中的成员，因为还持有外部类中的引用
      但是不可以访问它所在的局部中的变量，只能访问被final修饰的局部变量。

方法中的内部类能不能访问方法中的局部变量，为什么？

/**
       *说明下此程序在内存中的执行过程，就可以了解 为什么方法中的内部类不能访问方法中的局部变量。
       *首先JVM找到主函数的入口， 在栈中就开辟了一个main方法的空间 同时 创建了一个 变量o,同时在堆内存中
       *new Outer()分配了一块内存空间，然后将变量O的引用就指向了该内存空间。Outer o=new Outer();
       *这就话就执行完毕，在调用function的方法时，就会将方法区中的funtion()方法进入栈中，同时将x=4
       *加载进栈内存中。如果不将x设置为final ，执行完, o.function();就会将function方法弹栈，此时局部x也就不存在，
       *内部了也是一个类，在创建一个改局部类的对象之后，只有没有其他变量引用它，它才会变成垃圾，并且在不定时消失所以可能发生的情况是 ：在局部变量消失之后，内部类的对象还存活。也就是说在执行 内部类add()方法的时候x已经
       *不存在了。所以，方法中的内部类不能访问方法中的局部变量。
       *解决办法 就是将x 前加final 变成该内部类inner对象中的一个数据成员。这样，即使栈中局部变量x已消失，
       *但由于它是final,其值永不变，因而局部内部类对象在变量x死亡后，照样可以访问final型局部变量。

 */

class Outer{
 
 void function()
 {
  final int x=4;//方法的局部变量 
  //内部类
     class Inner{
      //内部类的方法
      void add()
      {
       System.out.print(x+4); //调用外部类方法中的局部变量
      }
      
     }
     new Inner().add();//创建个内部类的对象
     
 }
 
}
public class Test2 {

 public static void main(String[] args) {
 
  Outer o=new Outer();//创建外部类对象并将 o的引用指向该变量的地址
    o.function();//
  }
}