zoukankan      html  css  js  c++  java

  • Java抽象类和内部类

    类（class）

    • 类是相似对象中共同属性和方法的集合体
    • 在面向对象中定义类，就是在描述事物，就是在定义属性（变量）和行为（方法）。属性和行为共同成为类中的成员(成员变量和成员方法)。

    封装、继承和多态

    • 面向对象方法中软件设计的主体是类，类是相同属性和方法的封装体，因此类具有封装性
    • 子类可以在继承父类所有属性和方法的基础上，再增加自己特有的属性和方法，因此类具有继承性
    • 在一个类层次中，定义为根类的对象可被赋值为其任何子类的对象，并根据子类对象的不同而调用不同的方法，因此类具有多态性。

    类的这种封装性、继承性和多态性，是面向对象程序设计的三个最重要的特点。

    类声明 

    格式:[<修饰符>] class<类名>[extends<父类名>] [implements<接口名表>]
         {
           类主体
         }     
    其中，class是定义类的关键字，当接口名多于一个时，用逗号分隔开。方括号表示该项是可选项。
      
    class Student implements Cloneable{
	private String name;
	private int age;
	
        @Override
	public Object clone() throws CloneNotSupportedException{
		//此处要把protected改为public 
		Object object = super.clone();
		return object;
	}
}
    修饰符
    类声明的<修饰符>分为访问控制符【该类的访问权限】和类型说明符【该类是否为抽象类或最终类】两部分。
    • 访问控制符public:表示该类被定义为公共类，该类能被任何类访问。由于类都放于某个包中，包中的类互相能访问，而不在一个包中的类互相不能直接访问。如果要在一个包中访问另一个包中的类，就必须用import语句导入所需要的类到该包中。但Java语言规定，被导入的类必须是用public修饰的类。
    • 访问控制符默认（无public时，即是默认类）：表示该类只能被同一个包中的类访问，而不能被其他包中的类访问。Java语言规定，一个Java文件中可以有很多类，但最多只能有一个公共类，其他都必须定义为默认类。
    • 类型说明符abstract：表示该类为抽象类，抽象类不能用来定义对象，抽象类通常设计成一些具有类似成员变量和方法的子类的父类。
    • 类型说明符abstractfinal ：表示该类为最终类，最终类不能用来再派生子类。

    例如:

    • public  class  Teacher就声明了一个公共类Teacher，该类可以通过import语句导入到其他包的类中，并能被其他所有的类访问。
    • class Student就声明了一个默认类Student，该类只能被同一个包中的其他类访问。
    • public abstract class Person就声明了一个公共抽象类Person。访问控制符和类型说明符一起使用时，访问控制符在前，类型说明符在后。

    声明成员变量 

    格式为：[<修饰符>] [static] [final] [transient] <变量类型>  <变量名>;
        其中，<修饰符>有private、public和protected三种。当不加任何修饰符时，定义为默认修饰符。
    • private修饰符表示该成员变量只能被该类本身访问，任何其他类都不能访问该成员变量。
    • protected修饰符表示该成员变量除可以被该类本身和同一个包的类访问外，还可以被它的子类（包括同一个包中的子类和不同包中的子类）访问。
    • public修饰符表示该成员变量可以被所有类访问。
    • 不加任何访问权限限定的成员变量属于默认访问权限。默认访问权限表示该成员变量只能被该类本身和同一个包的类访问。
    • static指明该成员变量是一个类成员变量
    • final指明该成员变量是常量
    • transient指明该成员变量是临时变量。 transient很少使用。
    类成员变量是一个类的所有对象共同拥有的成员变量，上述修饰符实现了类中成员变量在一定范围内的信息隐藏。这既符合程序设计中隐藏内部信息处理细节的原则，也有利于数据的安全性。
     
    声明方法 
        声明成员方法的格式为：
        [<修饰符>] [static] <返回值类型> <方法名>  ([<参数列表>]) 
        {
          <方法体>
        }    其中，<修饰符>和成员变量的修饰符一样，有private、public和protected三种，另外，还有默认。
    • 各个修饰符的含义也和成员变量修饰符的含义相同。
    • static指明该方法是一个类方法。
    • 方法声明中必须给出方法名和方法的返回值类型，如果没有返回值，用关键字void标记。方法名后的一对圆括号是必须的，即使参数列表为空，也要加一对空括号。
        例如：public void SetInfo(String name,int age)
        上述语句声明了方法名为SetInfo的public方法，其返回值为空，参数有2个，分别为name和age，这2个参数的数据类型分别为String 和 int。
     
    方法体 
        方法体是方法的具体实现，是变量定义、赋值语句、if语句、for语句等根据方法体设计要求的综合应用。
    public void setInfo(String name,int age) {
　　if(age >= 18){
　　　　System.out.println("成年人");	
　　　　this.name = name;
       this.age =age;
　　}else if(age < 18 && age >0){
　　　　System.out.println("未成年人"); 
　　　　this.name = name;
       this.age =age;
　　}
}
     
    成员变量和变量
    • 一个最简单的区别方法是：定义在类中的都是成员变量，定义在方法内的都是变量。
    • 另外，还有定义在方法参数中的虚参变量，如SetInfo()中的 name 和 age。
    • 成员变量和变量的类型既可以是基本数据类型（如int、long等），也可以是已定义的类。
    构造方法
    • 用来进行对象的初始化，一般来说，一个类中至少要有一个构造方法。
    • 名字必须与其类名完全相同，并且没有返回值【void也不行】，构造方法一般应定义为public。
    • 如果在编写一个类时没有编写构造器，系统就会提供一个默认构造器（默认构造器是指没有参数的构造器）。系统提供的这个默认构造器会将所有的实例域设置为默认值。
    • 当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。
    • 当在类中自定义了构造函数后，默认的构造函数就没有了。
    • 如果构造器的第一个语句形如this(…)，那么这个构造器将调用同一个类的另一个构造器。
    public Student(){
    this();
}

    构造函数的作用：可以用于给对象进行初始化，实现过程是：在创建对象时，将调用相应类中的构造方法为对象的成员变量进行初始化赋值。

    所有的Java对象都是在堆中构造的，构造器总是伴随着new操作符一起使用。


    构造函数和一般函数的区别

    • 在写法上有不同
    • 在运行上也有不同：构造函数是在对象一建立就运行，给对象初始化；而一般方法是对象调用才执行，给是对象添加对象具备的功能。
    • 一个对象建立，构造函数只运行一次； 而一般方法可以被该对象调用多次。

    什么时候定义构造函数呢？
    　　当分析事物时，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数中。
    一个类中默认会有一个空参数的构造函数， 这个默认的构造函数的权限和所属类一致：

    • 如果类被public修饰，那么默认的构造函数也带public修饰符。
    • 如果类没有被public修饰，那么默认的构造函数，也没有public修饰。

    默认构造构造函数的权限是随着的类的变化而变化的。

    构造代码块

    • 构造代码快中定义的是不同对象共性的初始化内容。
    • 对象一建立就运行，而且优先于构造函数执行。
    • 作用：给对象进行初始化。
    • 和构造函数的区别：构造代码块是给所有对象进行统一初始化；而构造函数是给对应的对象初始化。

    抽象类

    　　就是在分析事物时，通过抽象函数来描述事物中不明确的内容。

    抽象类是一个父类，是不断向上抽取而来的， 在抽取过程中，只抽取了方法声明，但没有抽取方法实现。

    抽象类的特点：
    1. 抽象方法一定在抽象类中。【因为抽象函数所在类，也必须被抽象标识。】
    2. 抽象方法和抽象类都必须被abstract关键字修饰。
    3. 抽象类不可以用new创建对象。因为调用抽象方法没意义。
    4. 抽象类中的抽象方法要被使用，必须由子类复写其所有的抽象方法后，建立子类对象调用。

    抽象类和一般类没有太大的不同，抽象类比一般类多了抽象函数，就是在类中可以定义抽象方法；抽象类不可以实例化。

    特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。

    abstract 关键字，和哪些关键字不能共存：

    1. final：被final修饰的类不能有子类。而被abstract修饰的类一定是一个父类，所以final 和 abstract 不能同时修饰一个类。
    2. private: 抽象类中的私有的抽象方法，不被子类所知，就无法被复写。而抽象方法出现的就是需要被复写。
    3. static：如果static可以修饰抽象方法，那么连对象都省了，直接类名调用就可以了，可是抽象方法运行没意义。

    抽象类中是否有构造函数？

    有，抽象类是一个父类，要给子类提供实例的初始化。

    接口

    可以认为是一个特殊的抽象类。当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。

    • interface 用于定义接口
    • 是不可以创建对象的，因为有抽象方法
    • 需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化。否则子类是一个抽象类。
    • 接口可以被类多实现，也是对多继承不支持的转换形式。【java对多继承进行了改良】
    • 一个类可以对接口进行多实现，也弥补了多继承带来的安全隐患。
    • 一个类可以继承一个类的同时，实现多个接口。
    • 接口与接口之间是继承关系，而且可以多继承。

    接口中常见定义：常量，抽象方法。

    接口中的成员都有固定修饰符

    • 常量：public static final
    • 方法：public abstract

    记住：接口中的成员都是public的。

    应用特点：

    • 接口是对外暴露的规则
    • 接口是功能的扩展
    • 接口的出现降低了耦合性。【usb。pci，主板。插座。

    抽象类和接口异同

    相同：

    • 都可以在内部定义抽象方法
    • 通常都在顶层。
    • 都不可以实例化，都需要子类来实现

    不同点：

    • 抽象类中可以定义抽象方法和非抽象方法；而接口中只能定义抽象方法。
    • 抽象类只能单继承；接口的出现可以多实现。

    内部类

    当描述事物时，事物的内部还有事物，该事物用内部类来描述。
    一个类被嵌套定义于另一个类中，称为内部类(Inner Classes)或内隐类。包含内部类的类称为外部类。

    • 内部类可以直接访问外部类中的成员，包括私有。之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式 外部类名.this
    • 外部类要访问内部类，必须建立内部类对象。

    访问格式：

    • 当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中直接建立内部类对象:

    　　　　格式：外部类名.内部类名  变量名 = 外部类对象.内部类对象【Outer.Inner in = new Outer().new Inner();】

    • 当内部类在成员位置上，就可以被成员修饰符所修饰。

    　　　　比如private：将内部类在外部类中进行封装。

    　　　　static:内部类就具备static的特性。

    • 当内部类被static修饰后，只能直接访问外部类中的static成员，出现了访问局限。


    在外部其他类中，如何直接访问static内部类的非静态成员呢？
            new Outer.Inner().function();
    在外部其他类中，如何直接访问static内部类的静态成员呢？
            uter.Inner.function();

     注意：当内部类中定义了静态成员，该内部类必须是static的。
              当外部类中的静态方法访问内部类时，内部类也必须是static的。

    静态内部类

    和普通的类一样，内部类也可以有静态的。不过和非静态内部类相比，区别就在于静态内部类没有了指向外部的引用。

    在任何非静态内部类中，都不能有静态数据，静态方法或者又一个静态内部类（内部类的嵌套可以不止一层）。不过静态内部类中却可以拥有这一切。这也算是两者的第二个区别吧。  

    class Outer
{
    private static  int x = 3;
    
    static class Inner//静态内部类
    {
        static void function()
        {
            System.out.println("innner :"+x);
        }
    }

    static class Inner2
    {
        void show()
        {
            System.out.println("inner2 show");
        }
    }

    public static void method()
    {
        //Inner.function();
        new Inner2().show();
    }

}


class  InnerClassDemo
{
    public static void main(String[] args) 
    {
        Outer.method();
        Outer.Inner.function();
        new Outer.Inner().function();
        //直接访问内部类中的成员。
        Outer.Inner in = new Outer().new Inner();
        in.function();
    }
}

      局部内部类

    class Outer
{
    int x = 3;
    void method(final int a)
    {
        final int y = 4;
        class Inner
        {
            void function()
            {
                System.out.println(y);
            }
        }
        new Inner().function();
    }
}

class  InnerClassDemo
{
    public static void main(String[] args) 
    {
        Outer out = new Outer();
        out.method(7);
        out.method(8);
    }
}

     内部类定义在局部时：

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

    匿名内部类

    • 匿名内部类其实就是内部类的简写格式。
    • 其实匿名内部类就是一个匿名子类对象，而且这个对象有点胖。【可以理解为带内容的对象】
    • 匿名内部类中定义的方法最好不要超过3个。

    定义匿名内部类的前提：
        内部类必须是继承一个类或者实现接口。
    匿名内部类的格式：  new 父类或者接口(){定义子类的内容}。

    在java的事件处理的匿名适配器中，匿名内部类被大量的使用:

    frame.addWindowListener(new WindowAdapter(){
	public void windowClosing(WindowEvent e){
	   System.exit(0);//关闭窗口
	}
}); 

     1 interface Inter
 2 {
 3     void method();
 4 }
 5 
 6 class Test 
 7 {
 8     /*补足代码。通过匿名内部类。
 9     static class Inner implements Inter
10     {
11         public void method()
12         {
13             System.out.println("method run");
14         }
15     }
16     */
17 
18     static Inter function()
19     {
20         return new Inter()
21         {
22             public void method()
23             {
24                 System.out.println("method run");
25             }
26         };
27     }
28 }
29 
30 class InnerClassTest 
31 {
32     public static void main(String[] args) 
33     {
34 
35         //Test.function():Test类中有一个静态的方法function。
36         //.method():function这个方法运算后的结果是一个对象。而且是一个Inter类型的对象。
37         //因为只有是Inter类型的对象，才可以调用method方法。
38 
39         Test.function().method();
40     
41         //Inter in = Test.function();
42        // in.method();
43 
44         show(new Inter()
45         {
46             public void method()
47             {
48                 System.out.println("method show run");
49             }
50         });
51     }
52 
53     public static void show(Inter in)
54     {
55         in.method();
56     }
57 }
58 
59 class InnerTest
60 {
61 
62     public static void main(String[] args)
63     {
64         new Object()
65         {
66             public void function()
67             {
68                 
69             }
70             
71         }.function();
72     }
73 }
    匿名内部类练习

    匿名内部类由于没有名字，所以它没有构造函数（但是如果这个匿名内部类继承了一个只含有带参数构造函数的父类，创建它的时候必须带上这些参数，并在实现的过程中使用super关键字调用相应的内容）。

    初始化它的成员变量，有2种方法：

    • 如果是在一个方法的匿名内部类，可以利用这个方法传进你想要的参数，不过记住，这些参数必须被声明为final。
    • 将匿名内部类改造成有名字的局部内部类，这样它就可以拥有构造函数了。
  • 相关阅读:
    insertAfter()
    Unity3D之协程(Coroutines & Yield )
    C#中 As 和强制转换的总结
    Mesh系列文章
    在Unity3D 4中关联Visual Studio 2012来编写C#
    Unity3D安装多版本
    Time.deltaTime 增量时间
    Unity3D中Update和Lateupdate的区别
    Making raycast ignore multiple layers
    Unity3d中SendMessage 用法简单笔记
  • 原文地址：https://www.cnblogs.com/iadanac/p/3826975.html
Copyright © 2011-2022 走看看