Java de entrada para recursos avançados como Capítulo 11

anuário

pacote de classe Java

variáveis ​​finais

método final

classe final

classes internas

---

pacote de classe Java

• Use pacote nome do pacote definições, geralmente usando o nome de domínio da Internet na ordem inversa, como o nome do pacote
• Usando os pacotes de importação importação, importação pacote de todas as classes importar * com.lzw;., Mas não especifica todas as classes e sub-pacotes neste pacote. Ou introduzindo o com.lzw.Math classe de importação especificado;
• As mesmas classes no pacote não pode ser colocado na mesma posição, enquanto os caminhos especificado no CLASSPATH
• Use importação de importação estática membros estáticos (JDK5)

variáveis ​​finais

• variáveis ​​finais devem ser definidos na altura da sua indicação de atribuição, para além dos tipos de dados de base modificadas, referência objecto também pode ser modificado, tal como uma matriz, uma vez que o objecto utilizando uma modificação final, é apenas constantes aponta para um objecto, este não pode ser alterado para apontar para uma outra objeto. Às vezes, tanto um campo final estático é o período de armazenamento não pode ser alterado
• definição nomeado constantes finais usar letras maiúsculas no meio com um sublinhado. variáveis ​​definidas imutáveis ​​finais definidos referência imutável, mas o valor de referência pode ser alterada
• O valor da definição final não é constante, por exemplo, criar um valor final em branco da sua missão no construtor, pois as variáveis ​​de membro finais atribuídos valores aleatórios cada vez que você criar um novo objeto, haverá um membro variáveis ​​aleatórias de valor final ( essencialmente cria um novo objecto, o novo objecto tem um novo valor final)
• dados finais pode ser modificado
  • modificações finais variável membro não pode ser alterado
  • última variável modificações membro é definido como um trabalho final, finais em branco está em branco no construtor
  • parâmetro final, o método não pode alterar o valor do parâmetro
  • O método de definição de variáveis ​​locais dentro final, não pode mudar o seu valor

package ex11_AdvancedClass;

import static java.lang.System.out;
import static java.lang.System.setOut;

import java.nio.file.FileAlreadyExistsException;
import java.util.Random;

class Test {
    int i = 0;
}

public class FinalData {
    private static Random rand = new Random(); //实例化一个Random类对象
    private final int VALUE_1 = 9;  //声明一个静态final常量，每个对象都有一份
    private final static int VALUE_2 = 10;  //声明一个final,static常量，归属于类，只有一份
    private final Test test = new Test();  //声明一个final引用
    private Test test2 = new Test();  //声明一个不是final的引用
    private final int[] a = {1, 2, 3, 4};  //声明一个定义为final的数组
    private final int a1 = rand.nextInt(10);
    private final static int a2 = rand.nextInt(10);

    private final int x;  //定义空白final，可在构造方法中初始化

    public FinalData(int y) {
        x = y;  //初始化空白final值
    }


    public static void main(String[] args) {
        FinalData data = new FinalData(1);
//        data.test = Test():  //使用final修饰的引用不可改变指向
        data.test.i = 5;  //不可改变引用，但可以改变引用的值（指向不可变，指向的内容可变）
        data.test2 = new Test();  //没有使用final修饰的引用可以改变指向
//        data.VALUE_1++;  //使用final修饰的变量不可改变
//        data.VALUE_2++;  //使用final修饰的静态变量不可改变,一般使用FinalData.VALUE调用
        data.a[0] = 9;    //不可改变引用，但可以改变引用的值
        out.println(data.a[0]);

        //其中的final x，a1随着新对象的创建都会改变
        //a2为final static，再次创建新对象并不会创建新区域，仍指向初始化时的区域，值也不会改变
        out.println("static a2: " + FinalData.a2);
        FinalData fdata = new FinalData(1);
        out.println("fdata.a1: " + fdata.a1 + " static fdata.a2: " + fdata.a2 + " fdata.x " + fdata.x);
        FinalData fdata2 = new FinalData(2);
        out.println("fdata2.a1: " + fdata2.a1 + " static fdata2.a2: " + fdata.a2 + " fdata2.x " + fdata2.x);
        
    }
}

método final

• O método de definição final não podem ser reescritos, pois que não é definido como uma reescrita
• O método definido pravite não ser reescritos, porque a área não pode ser acedido de fora da classe, não pode substituir
  • Diferença: método pravite definido implicitamente designada como o tipo de último tipo, o método final especificada não pode ser reescrita, mas o objecto pode ser uma subclasse de chamar-se depois a transição. pravite método do tipo especificado subclasses de objectos após a transformação não é chamada para cima, como é a definição de região pravite não pode ser acedido de fora da presente classe, subclasse não pode

classe final

classe final definido não são permitidos para herdar todos os métodos da classe são definidos implicitamente a forma final, mas a variável membro da classe pode ser definida como a forma final ou final

classes internas

• Os membros da Introdução classe interna
  • classes internas são livres para usar as variáveis ​​e métodos exteriores membro da classe, mesmo privado
  • Dentro da classe de objecto deve ser ligada à classe alvo externo, um objecto de classe de objecto dentro da classe externa são interdependentes
  • Você não pode usar um objeto de classe da classe nome externo instanciado dentro antes de o novo operador ao instanciar o objeto dentro, mas criar uma classe de objeto usando o objeto dentro da classe externa
• Interface interna Classe upcast
  • Implementa a interface para mudar a definição do tipo particular interno classe (classe não interna não definida como privada ou protegida), a definição de uma classe de um métodos comuns externos, o método volta ao tipo de interface, interior objeto classe é devolvido no interior da classe de objecto, essa percepção do objeto de classe upcast interfaces internas. Se uma classe herda a classe externa
  • classes não-internas não pode ser declarado como privada ou protegida
• Use esta palavra-chave para obter uma classe interna de referência e fora da classe
  • Use esta chamada o objeto de classe interna referenciada dentro da classe
  • .Esta usando chamada classe externo referência objecto de classe externo
• classe local interno: Método interior definido dentro dos membros da classe, se desejado in vivo utilizar variáveis ​​locais necessitam de ser definido como o tipo final, ou seja, dentro da definição da classe do método no método in vivo pode acessar apenas as variáveis ​​locais do tipo de final, no interior classe, os valores das variáveis ​​locais não podem ser alterados.
• Anônimos classes internas: anónimo criar objetos de uma classe que implementa a interface, após a necessidade de definição de classe interna anônima para adicionar uma identidade ponto e vírgula, criação de logotipo referência de interface expressão de identidade.
• classes internas estáticas: uma classe interna é declarada como estática
  • Se você criar um objeto de uma classes internas estáticas, objetos não precisa de uma classe externa
  • Pode objetos não estáticos não acesso de um objeto fora da classe interna classe estática
  • Se você tiver configurado um método primário em cada arquivo java, haverá um monte de código extra, o programa em si não precisa dominar esses métodos, a fim de resolver este problema, o principal método de escrever uma classe interna estático, o compilador irá gerar um depois chamado <interior exterior classe $ class> classes independentes e <classe externa>, o uso de <classe externa interna classe $> longa pode executar o conteúdo do processo principal, a conclusão do teste, toda a classe arquivos precisam ser esticado enquanto o pacote esta pode ser uma classe separada

 

//成员内部类
package ex11_AdvancedClass;

public class OuterClass {  //外部类
    innerClass in = new innerClass();  //在外部类实例化内部类的对象引用

    public void outf() {
        in.inf();  //在外部类中调用内部类方法
    }

    public innerClass doit() {  //外部类方法
        //y=4;  //外部类不可以直接访问内部类的成员变量
        in.y = 4;  //可以通过对象访问
        return new innerClass();  //返回内部类的引用
    }

    class innerClass {  //内部类
        int y = 0;  //内部类成员变量

        public innerClass() {
        }  //内部类构造方法

        public void inf() {
        }  //内部类成员方法
    }

    public static void main(String[] args) {
        OuterClass out = new OuterClass();
        //内部类的对象实例化必须在外部类或外部类的非静态方法中实现
        //在其他地方实现需要使用外部类。
        //内部类实例一定要绑定到外部类的实例上，内部类对象依赖于外部类对象
        OuterClass.innerClass in3 = out.doit();  //out对象返回内部类的引用赋值给in
        //不能在new之前使用外部类名称实例化内部类对象，应该使用外部类的对象创建内部类的对象
        OuterClass.innerClass in2 = out.new innerClass();  //out对象创建一个新对象赋值给in2
        System.out.println(in3.y);
        System.out.println(out.in);
        System.out.println(out.in.y);  //out对象调用过doit()方法，把它的y值设置成了4
    }
}

//内部类向上转型为接口
package ex11_AdvancedClass;

interface OutInterface {
    public void f();
}

public class InterfaceInner {
    public static void main(String[] args) {
        OuterClass2 out = new OuterClass2();  //创建外部类对象
        OutInterface outinter = out.doit();  //使用外部类对象调用方法，返回内部类对象向上转型的接口
        outinter.f();  //使用接口调用f()方法
    }
}

class OuterClass2 {
    //定义一个内部类实现OuterInterface接口
    private class InnerClass implements OutInterface {
        public InnerClass(String s) {  //内部类的构造方法
            System.out.println(s);
        }

        public void f() {
            System.out.println("访问内部类的f()方法");
        }
    }

    public OutInterface doit() {  //定义一个外部类方法，返回值类型为OuterInterface接口类型
        return new InnerClass("访问内部类构造方法");  //内部类向上转型为接口
    }
}

//局部内部类
package ex11_AdvancedClass;

interface OutInterface2 {

}

class OuterClass3 {
    public OutInterface2 doit(String x) {
        //在doit()方法内定义一个内部类
        class InnerClass2 implements OutInterface2 {
            InnerClass2(String s) {
                s = x;  //内部类中使用局部变量必须是final变量或者实际上的final变量（不可变）
                System.out.println(s);
            }
        }
        return new InnerClass2("doit");
    }
}

public class Test2 {
    public static void main(String[] args) {
        OuterClass3 out3 = new OuterClass3();
        OutInterface2 outint = out3.doit("hi");

    }
}

//匿名内部类，创建一个实现接口的匿名类的对象
class OuterClass4 {
    public OutInterface2 doit() {  //定义doit()方法
        return new OutInterface2() {  //声明匿名内部类
            private int i = 0;
            public int getValue() {  //实现接口
                return i;
            }
        };  // 在匿名内部类定义结束后需要加分号标识，
    }
}