Java开发知识之Java类的高级特性,内部类.以及包使用.跟常量关键字

　　　　　　　　　　Java开发知识之Java类的高级特性,内部类.以及包使用.跟常量关键字

一丶Java中包的机制

　　首先包其实就是个文件夹.作用就是管理类. Java中每次定义一个类的时候.通过Java编译之后.都会生成一个扩展名为.class的文件.但是当这个程序规模逐渐庞大的时候.就很容易发生类名名称冲突的现象. 那么JDK API中. 提供了成千上万的具有各种功能的类.有效的管理就是通过类包来管理.

　　　　1.类名冲突

　　　　　　首先我们Java中可能定义一个A类.但是因为业务需要.还需要一个A类.名称一样,可能功能不一样.那么名字就会冲突.而Java编译器不允许存在同名的类文件.解决方法

就是放在不同的文件夹中(包中)

　　　　2.完整的类路径

　　　　　　在以前我们使用Math类.eclipse会自动引入一个包.关键字就是 import 包. 我们当时也不注意.反正能编写程序即可. 其实Math类.完整的路径是 Java.lang.math;

java.lang 是包的名称,可以理解为是文件夹. 后面的math是类名. 我们使用 import java.lang.Math 代表的意思就是 使用这个文件夹下指定的Math类.

我们如果不使用关键字 import引入包. 那么就要使用完整的类名 例如: java.lang.Math ma = new java.lang.Math();

注意:

　　　　1.同一个包中的类互相访问的时候,可以不指定报名.

　　　　2.同一个包中的类可以不用放在一个磁盘.什么意思. java.lang 是报名. 我们可以在D盘创建一个 java.lang  E盘我们也创建一个java.lang 此时我们只需要CLASSPATH指向这两个包就行.包他认为就是一个.都属于java.lang包. 这跟文件夹不太一样.

　　3.创建包.

我们可以使用Eclipse创建一个包. 新建->包. (new -> packet)

填写文件夹. 以及包名称即可.

创建完毕之后就有一个包了.在我们的项目中.

package 关键字

package 包名.

我们在类中指定包名的时候.需要将package表达是放置在程序的第一行. 他必须是文件中第一行.并且是非注释代码. 如果指定了包名称.那么代表这个类的完整路径就是

包名.类名称. 例如 com.aaa是我们的包. 在下面定义了一个类. Dog()  那么Dog类的完整路径就是  com.aaa.Dog();

例如:

　　

　　4.导入包

我们上边虽然定义了包.但是使用的时候我们必须指定完全的类名去创建对象.例如如下:

我们不能每次new对象的时候都要加上包的名称.所以我们可以使用关键字.导入包.这样使用的时候直接给定类名即可.

import关键字.

语法:

　　import 包名.通配符.

例如: import com.xxx.Math  也可以 import com.xxx.*;  表示导入这个包中所有的类.

注意:如果你有两个相同类.你要使用那个类.就要加上完整的类名去使用. 这个便于区分. java中的类包.类似于C++的命名空间.都是解决冲突问题.

　　5.Import的高级用法

Import不光可以导入类包.也可以导入静态变量.这个是 J2SE 5.0以上才支持的.

关键字:import static 包名+静态成员变量 代码如下.

二丶Final关键字的作用

　　Final关键字是常量定义关键字. 他可以修饰类 方法. 以及变量跟引用.

变量:

　　　　1.修饰变量

　　1.修饰变量. 变量不可以修改.成了一个常量. 例如 final double PI = 3.14; 此时PI我们只可以访问而不能修改了.在修饰变量的时候应该直接进行初始化.

　　 C++ 则是在类外面加上类域进行初始化 const int 类名::变量 = 初始化的值;

　　在Java类中如果只定义了final成员变量.那么初始化可以在构造函数中进行初始化.

　　

　　空白final成员变量初始化

　　.2.final 修饰对象

　　　　final修饰对象.则对象只能指定唯一的一个对象.且不能修改.

　　如果修饰数组.则数组里面的值可以修改.但是数组对象不能指向别的数组了.

如下.:

　　

　　 3.final与static的使用

　　　　final 修饰的变量.初始化的时候可以使用随机数进行初始化.这样常量的值就是可以改变的.但是如果加上Static关键字.那么意思就是其内存区域是恒定不变的.所以值不会被改变了.

代码如下:

　　

public class Cat {

    private static Random r = new Random();

    public final int a = r.nextInt(10);　　　　　　//常量a
    public final static int b = r.nextInt(10);   //静态区域的常量b
    public Cat() {

    }
    public void eat() {
        System.out.println("猫在吃饭");
    };
}

使用

　　

    public static void main(String[] args) {
        Cat c = new Cat();
        out.print("a = "  + c.a);
        out.println("  b  = "  + c.b);

        Cat b = new Cat();

        out.print("a = "  + b.a);
        out.print("  b  = "  + b.b);
    }

输出结果

可以看出.我们对象中final修饰的a也就是变量a随机数可以进行改变的.但是b因为是static所以不能被改变了.

在Java中 定义全局变量一般都是用 public static final 修饰. 这样修饰的只能在定义的时候并且初始化.可以这样使用.

方法:

　　

　　　1.父类方法private + final修饰

以前我们知道.当父类中的方法 使用private修饰的时候.则子类继承父类的时候.则不能覆盖(重写)

而将方法使用final修饰的话.可以防止子类修改该类的定义与实现方式. 所以父类中使用private修饰的时候.

方法自然地加上了默认修饰符 final. 因为final修饰的方法效率远高于非final的方法.

注意下方代码:

父类:

　　

 public   class  Anmail {

    final private void eat1() {
        System.out.println("父类吃1");
    }
    final public void eat2() {
        System.out.println("父类吃2");
    }
}

子类:

　　

public class Dog extends Anmail implements IAnmail{

    public final void eat1() {
        System.out.println("子类吃1");
    }

    public final void eat2() {
        System.out.println("子类吃2");
    }

    @Override
    public void Play() {
        // TODO 自动生成的方法存根

    }

}

我们可以看到.我们子类竟然可以 "覆盖父类方法"  并且权限已经改为public 请注意.这个并不是覆盖.而是子类的一个新的方法.

跟父类的方法不一样.也没有进行重写.

final类

　　final修饰的类则不能被继承了.

语法:

　　final class 类名{}

三丶类的高级特性.内部类.

　　在java中.类中可以使用内部类.意思就是在一个类中还可以定义一个类.

1.成员内部类

　　　成员内部类就是定义一个成员.这个成员就是一个内部类.

例如:

　　

public class A{
   private class B{
       .....内部类代码.
   }
}

其中 A是外部类. B是内部类.

B内部类可以随意使用外部类的成员变量以及成员方法. 不管这些类是否被修饰为private.

在外部类可以new 内部类.使用内部类.

例如:

public class A{
    class B{
       ....
     }
    B b = new B(); 使用内部类
}

内部类的使用:

　　内部类的实例化跟外部类一样.只不过你是内部类我们跟Java类包一样. 加上外部类名即可. 但是在new的时候有区别.

new的时候要在外部类中提供一个方法.这个方法专门是返回内部类的实例化对象.

public class Cat {

    public class Cat1{
        public int m_hande;
        public void eat() {
            System.out.println("内部类吃东西");
        }
    }
　　Cat1 retInstance(){   //专门提供一个方法.进行返回成员内部类的实例化对象.
    return new Cat1();
}
}

使用:

　　

public static void main(String[] args) {
        Cat c = new Cat();             //创建外部类对象
        Cat.Cat1 b = c.retInstance();  //外部类的方法返回内部类实例

        b.eat();
    }

或者使用以下方法.

public static void main(String[] args) {
        Cat c = new Cat();
        Cat.Cat1 b = c.new Cat1();//使用new

        b.eat();
    }

这里注意的就是一定要创建出外部类对象才可以使用内部类.

1.外部类方法返回内部类实例.

2.外部类中直接当成员使用.使用new的方法.new一个. 因为Cat1我们可以看成是一个成员变量.只不过是一个特殊的成员变量.

成员内部类的高级用法

　　成员内部类可以向上转型为父类. 成员内部类可以实现一个接口.对外隐藏其实现方法.

例如如下;
定义接口:

　　

public interface IAnmail {

    public abstract void Play(); //定义一个抽象方法
}

父类跟成员内部类

public class Cat {

    public class Cat1 implements IAnmail {

        @Override
        public void Play() {
            // TODO 自动生成的方法存根
            System.out.println("内部类玩耍");
        }  //实现IAnmail方法

    }
    public Cat1 retInstance(){   //专门提供一个方法.进行返回成员内部类的实例化对象.
        return new Cat1();
    }
}

可以看到.内部类Cat 实现了接口IAnmail. 并且外部类返回了内部类的实例化对象.

使用:

public static void main(String[] args) {
        Cat c = new Cat();
        IAnmail b  = c.retInstance();//注意此行代码
        b.Play();

    }

注意第二行代码:

.返回的是内部类实例化对象.使用接口接受.意思就是说向上转型为了父对象.父对象直接使用play方法. 这样可以隐藏内部类的实现细节. 其实本质区别没有变.还是类跟类的关系.
只不过是内部类而已.
这样做的好处是什么:  好处就是一般的类.不能多次实现接口中的方法. 而我们的内部类可以.我们可以写上几个内部类.去实现接口.并且多次实现其方法. 因为向上转型.会触发多态.
所以一个类中可以有不同的事件产生.这个一般用于窗口设计中.Android中好像也是这样.还没接触安卓.不过按照书上所写.应该可以同时监听不同的事件.

　　this关键字用于内部类跟外部类

我们以前说过.this可以访问构造.也可以区分成员变量与局部变量的命名冲突. 但是此时我们的内部类中有成员的变量.跟外部类中的成员变量相同怎么办.

所以我们必须进行区别.

用一下代码进行区别.

public class Cat {
    int x = 0; //外部类的X
    public class Cat1   {
        int x = 1; //内部类的x
        public void eat(int x) {//方法中的形参x
            x ++ ; //操作的是方法中的形参x
            this.x ++; //操作的是内部类的x
            Cat.this.x++;//前边加上外部类名则是操作的外部类的成员变量x

        }
        public class cat2{
            int x;
            public void eat(int x) {
                x++;
                this.x++;
                Cat1.this.x ++;
                Cat.Cat1.this.x++;
            }
        }

    }
    public Cat1 retInstance(){   //专门提供一个方法.进行返回成员内部类的实例化对象.
        return new Cat1();
    }
}

首先总结来说.

this用于当前类.那么则是区分的本类的成员变量与形参.

如果this前边加上父类名. 则是操作的父类的成员变量.

下面我们写了内部类的内部类. 使用this的时候就是 都是加外部类名. 只不过类名不一样而已. 依次类推.

2.方法内部类 /局部内部类.

　　方法内部类就是说.可以定一个方法.这个方法中可以定义一个类去使用.

因为他是属于一个方法的.是一个方法中的类.所以外部类不可以访问局部内部类. 但是内部类可以访问当前代码块的常量以及外部类的所有成员.

代码如下:

　　

public class Cat {
    int x = 0; //外部类的X

    public IAnmail retInstance(){   //专门提供一个方法.进行返回成员内部类的实例化对象.

        class Cat1 implements IAnmail{

            public void Play() {
            // TODO 自动生成的方法存根
                System.out.println("内部进行玩耍");
            }

        }
        return new Cat1(); //返回实例化对象.但是需要用父类进行接收.因为外部没有此类对象
    }
}

使用:

　　

public static void main(String[] args) {
        Cat c = new Cat();
        IAnmail b  = c.retInstance();
        b.Play();

    }

局部内部类很简单.就是方法中定义一个类.而返回的时候可以返回这个类的实例对象.使用父类接受.可以向上转型.

3.匿名内部类.

　　上面所说的局部内部类.返回的时候是自己new了一个对象进行返回.且外面进行接受了. 我们还可以使用return的时候.字节返回.

就不用类定义了.

代码如下:

　　

public class Cat {
    int x = 0; //外部类的X

    public IAnmail retInstance(){

        return new IAnmail() {

            @Override
            public void Play() {
                // TODO 自动生成的方法存根
                System.out.println("匿名内部类");
            }

        };
    }
}

匿名内部类就是跟return语句进行结合了. 还是在方法内部.

以前我们返回的是 new Cat1(); 现在我们知道返回值是一个接口.我们可以直接返回一个接口类.

其实这个类的作用就是返回一个实现接口的对象而已.

语 法: new A () {

....

}

A可以是一个接口. 父类. 向上转型类都可以.

4.静态内部类.

　　在内部类前边添加修饰符static.那么就是静态内部类. 静态内部类中可以声明static成员.但是不是静态内部类不可以声明静态成员.

特点: 不可以使用外部类的非静态成员. 所以静态内部类开发中很少见.

可以理解为静态内部类加了很多现实.

1.如果创建静态内部类的对象.不需要其他外部类的对象.

2.不能从静态内部类的对象中访问非静态外部类的对象.

5.内部类的继承

　　如果一个类.想要继承一个内部类.

比如有一个A类.一个B类. B类中有内部类C类.

我们的A类想要继承B中的C类.

那么A类就要提供一个带参构造. 参数是类 B.

且构造参数中需要加上a.super():才可以.

代码如下.

 public   class  AnmailB {

     public class AnmailC{

     }
}

使用一个类继承AnmailC

public class Cat  extends AnmailB.AnmailC{
    public Cat( AnmailB b) {
        b.super();
    }

}

四丶总结

　　　　1).Java中的类包

　　　　　　package 包名  用来定义一个包

　　　　　　import  包名.类名 导入一个包中的某个类. 可以直接使用这个类new对象了.而不用加上完整包路径

　　　　2).java中的final变量

　　　　　　final 修饰变量 变量变量变成常量.且不能修改

　　　　　　final 修饰引用. 引用只能指向一个对象.不能更改指向. 但是引用里面的成员变量的值可以修改.

　　　　　　final 修饰数组. 数组里面的值可以改变.地址不能改变了.意思就是不能更改指向了.

　　　　　　final 跟 static一起使用 final 修饰常量.可以被随机数修改值.也就是初始化的时候. 但是加上static则内存是一块不能改变的. 也就是说值被赋值之后.内存里面的值不会在进行改变了.

　　　　　　final 修饰方法. 则方法不能被继承跟重写. private权限.默认加了final关键字.

　　　　3).java中的内部类.

　　　　1.成员内部类.

　　　　　　成员内部类就是一个成员.  使用的时候外部类提供方法.用来返回内部类的实例化对象.

　　　　　　　A.B  a = A.retInstance(); 或者 A.B a = A.new B();

　　　　　　成员内部类可以实现接口. 返回的时候可以使用父类接受. 向上转型.隐藏实现细节.

　　　　　　接口 A = A.new B();  内部类可以实现多个接口中方法.用来监听不同的事件.

　　　　2.局部内部类,方法内部类.

　　　　　　定义一个方法.方法中定义一个类.返回的时候可以返回这个类的实例化对象. 返回值可以是 实现的接口.或者父类.向上转型.

　　　　3.匿名内部类.　

　　　　　　匿名内部类直接返回一个实现接口的对象即可.

　　　　　　例如  return new 接口(){  xxx代码};

　　　　4.静态内部类.

　　　　　　静态内部类就是给类加了限制.不能访问外部类的非静态成员. 内部类中只能定义静态成员.

　　　　4).this关键字用于内部类

　　　　　　this关键字用于类内部可以区分类的成员变量跟形参区别.

　　　　　　如果想使用外部类.则要加上外部类的类名才可以  外部类名.this.成员变量;  这样使用的就是外部类的成员