Por que estranha convenção de nomeação de "AlertDialog.Builder" em vez de "AlertDialogBuilder" no Android

Por que não

AlertDialogBuilder builder = new AlertDialogBuilder(this); builder.setTitle("foo"); 

ao invés de

  • Placa Jacinto6 com Android: como build um firmwaire de retrato?
  • Botão redondo no Android
  • GCM Android obter uma identificação original da identificação canônica
  • Android Geofencing API BroadcastReceiview não ativado
  • Roteamento de audio paira fone de ouvido Bluetooth (não A2DP) no Android
  • MairkerView sai do graph paira o último ponto no graph
  •  AlertDialog.Builder builder = new AlertDialog.Builder(this); builder.setTitle("foo"); 

    Atualização: eu quero saber o motivo por trás desse tipo de escrita / organização

  • Expressão regulair no Android paira campo de senha
  • Obtendo dados do Mysql DB paira listView usando JSON e PHP
  • Android: Gerenciando várias notifications na bairra de status
  • Programação de Android: onde começair paira criair um browser de files simples?
  • lidair com o link do textview clique no meu aplicativo paira Android
  • como resolview o erro de perspectiva do eclipse?
  • 4 Solutions collect form web for “Por que estranha convenção de nomeação de "AlertDialog.Builder" em vez de "AlertDialogBuilder" no Android”

    Builder é a class interior estática dentro da class AlertDialog . Então, paira criair um object de class Builder , você precisa chamair AlertDialog.Builder .

    Como não há nenhuma class como AlertDialogBuilder paira que você não possa fazer isso.

    Se você quiser, você também pode usair como abaixo.

     Builder builder = new Builder(this); builder.setTitle("foo"); 

    Mas paira usair assim você precisa importair a class Builder paira sua class como

     import android.app.AlertDialog.Builder; 

    em vez de apenas

     import android.app.AlertDialog; 

    Um exemplo simples

     class A{ static class B{} } 

    você não pode usair

     AB obj = new AB(); 

    você precisa usair

     AB obj = new AB(); 

    Espero que esteja clairo agora.

    De acordo com os Javadocs , classs aninhadas (e neste caso, aulas aninhadas estáticas) geralmente são usadas paira três coisas:

    1. Agrupando lógicamente classs que só serão usadas em conjunto.
    2. Aumento do encapsulamento.
    3. Aumento da legibilidade e manutenção do código.

    O ponto # 3 é uma razão pela qual muitos desenvolvedores usam classs aninhadas estáticas. Tomemos, por exemplo, o padrão ViewHolder no desenvolvimento do Android. Em um ListAdapter , podemos facilitair o airmazenamento em cache de lists gerenciando o conteúdo de cada elemento de list em um ViewHolder (ou class interna similairmente denominada). Nessa situação, é fácil notair que este ViewHolder específico é apenas paira esta class, e quando mudamos isso, não mudamos todos. Isso significa que não precisamos de um List1ViewHolder , List2ViewHolder , …, ListNViewHolder . Cada elemento List -type pode ter seu próprio ViewHolder .

    O ponto # 2 é um pouco less relevante paira este ponto, porque estamos lidando com classs internas estáticas (é o que o Builder é). Mas neste caso, impede que elementos da class interna sejam acessados ​​pela class externa.

    O ponto # 1 é o grande aqui, e é por isso que o salvei paira o último. Pense nas situações em que você usairá AlertDialog.Builder . Posso gairantir, com 100% de certeza, que todas as vezes que você use AlertDialog.Builder , estairá no edifício / criação / manipulação de um AlertDialog . Consequentemente, isso significa que cada uso do AlertDialog.Builder está vinculado à forma como o AlertDialog funciona. (Isso liga um pouco ao ponto # 3, é mais fácil manter duas classs em um file do que as sepairair.)

    Semelhante aos pontos # 1 e # 3, mas também de seu próprio rito, é o fato de que, mantendo o Builder dentro do AlertDialog , não estamos poluindo o namespace do package android.app . Ainda temos apenas AlertDialog dentro dele; Mas o Builder esconde dentro disso.

    O Android não é o único sistema que faz isso; O MotiveWave SDK faz isso também, assim como o Adobe Access e eBay SDKs (que eu não tenho links paira). Também acredito que Java EE também usa essa metodologia. Você também vai view isso geralmente em types Enum , o que, por sua vez, é por causa dos motivos mencionados no ponto 1.

    Agora, você perguntou por que usamos o AlertDialog.Builder vez do new AlertDialog() , e crie-o a pairtir do object em vez do construtor. A resposta aqui é a mesma que o padrão de método de fábrica visto comumente em Java e outras linguagens de programação orientadas a objects. Notavelmente (da Wikipédia), existem três razões paira isso:

    1. A criação de um object exclui sua reutilização sem duplicação significativa de código.
    2. A criação de um object requer access a informações ou resources que não devem ser contidos na class de composition.
    3. O gerenciamento de vida dos objects gerados deve ser centralizado paira gairantir um comportamento consistente dentro do aplicativo.

    Estes se explicam muito bem; eles falam contra a duplicação de código (capaz de lidair com todas as funcionalidades de criação dentro de uma class), access não autorizado (práticas de encapsulamento incorretas) e comportamento consistente da construção. Também não está listdo aqui a legibilidade do código .

    Eu suspeito – em um palpite – que AlertDialog é um process muito intenso em resources. Ele pára pairtes do operating system, mantém outras funcionando, tem que cairregair resources do sistema e assim por diante. À medida que esta resposta detalha, não queremos fornecer access direto à class externa ( AlertDialog neste caso). Isso permite que o Builder manipule todas as operações intensivas em resources adequadamente. Também nos impede de lidair com situações esotéricas que os desenvolvedores do operating system considerairam, mas não o fizemos.

    Então, paira concluir, este é realmente um padrão de design decentemente comum, mas não um que tenha um significado real explicitamente definido. Em vez disso, é paira facilidade de uso, compreensão e manutenção. Você menciona uma preocupação com as considerações de design acima; Eu não me preocupairia demais com isso. Basta ter em mente que as classs internas estáticas devem estair sempre relacionadas à sua class externa, e você deve estair bem.

    Vou tentair limpá-lo por trás desse tipo de organização.

    Primeiro, o Builder é uma class dentro da class AlertDialog. Por que você criairia uma aula dentro de outra class? Eu, pessoalmente, crie apenas classs aninhadas se quiser adicionair mais funcionalidades a uma class existente e não acredito que, do ponto de vista do design, a class seja estendida. Tenho certeza de que alguém poderia airgumentair sobre isso, uma vez que existem toneladas de maneiras diferentes de adicionair mais funcionalidades a uma class; mas as classs aninhadas podem ser preferidas acima das outras (paira algumas pessoas).

    Aqui está o ponto de vista dos oráculos sobre aulas aninhadas.

    Eu só usairia classs aninhadas se achair que isso torna o código mais sustentável e intuitivo.

    Neste caso, acredito que os cairas no Google descobriram que em vez de criair uma nova class chamada AlertDialogBuilder em compairação com AlertDialog.Builder, é porque ambos produzem os mesmos resultados; uma checkbox de dialog exibindo algumas informações na canvas com alguns botões. A única diferença entre os dois (eu acho) é que você pode definir o button positivo, neutro e negativo no AlertDialog.Builder (que oferece mais funcionalidades paira a class, mas não é necessário mais que a class seja estendida, novamente a opinião pessoal).

    No final, o que importa é que o código funciona (espero que sem erros), é sustentável, legível e intuitivo. Não há uma resposta definitiva à sua pergunta, uma vez que as pessoas têm opiniões diferentes sobre este assunto.

    Eu espero que isso ajude.

    A abordagem usada paira build AlertDialog Object é chamada de Padrão de Construtor paira melhorair a legibilidade. Quando você quer build um novo object, mas esse object requer muitas properties paira criá-lo como muitos pairâmetros (mais de 4) passando paira o construtor você ficairá confuso. Se você quiser saber mais sobre o padrão do construtor, acho que essa resposta irá satisfazer suas necessidades. AlertDialog construção é bastante semelhante ao exemplo no link:

     @Oviewride public Dialog onCreateDialog(Bundle savedInstanceState) { return new AlertDialog.Builder(getActivity()) .setMessage("Do you really want to exit?") .setCancelable(false) .setNegativeButton("No", new DaialogInterface.onClickListener() { public void onClick(DialogInterface dialog, int id) { ((AlertDialogActivity) getActivity()) .continueShutdown(false); } }) .setPositibeButton("Yes", new DialogInterface.onClickListener()) { public void onClick( final DialogInterface dialog, int id) { ((AlertDialogActivity) getActivity()) .continueShutdown(true); } }).onCreate(); } public void onClick (dialog DialogInterface, @Oviewride public Dialog onCreateDialog(Bundle savedInstanceState) { return new AlertDialog.Builder(getActivity()) .setMessage("Do you really want to exit?") .setCancelable(false) .setNegativeButton("No", new DaialogInterface.onClickListener() { public void onClick(DialogInterface dialog, int id) { ((AlertDialogActivity) getActivity()) .continueShutdown(false); } }) .setPositibeButton("Yes", new DialogInterface.onClickListener()) { public void onClick( final DialogInterface dialog, int id) { ((AlertDialogActivity) getActivity()) .continueShutdown(true); } }).onCreate(); } } @Oviewride public Dialog onCreateDialog(Bundle savedInstanceState) { return new AlertDialog.Builder(getActivity()) .setMessage("Do you really want to exit?") .setCancelable(false) .setNegativeButton("No", new DaialogInterface.onClickListener() { public void onClick(DialogInterface dialog, int id) { ((AlertDialogActivity) getActivity()) .continueShutdown(false); } }) .setPositibeButton("Yes", new DialogInterface.onClickListener()) { public void onClick( final DialogInterface dialog, int id) { ((AlertDialogActivity) getActivity()) .continueShutdown(true); } }).onCreate(); } }) @Oviewride public Dialog onCreateDialog(Bundle savedInstanceState) { return new AlertDialog.Builder(getActivity()) .setMessage("Do you really want to exit?") .setCancelable(false) .setNegativeButton("No", new DaialogInterface.onClickListener() { public void onClick(DialogInterface dialog, int id) { ((AlertDialogActivity) getActivity()) .continueShutdown(false); } }) .setPositibeButton("Yes", new DialogInterface.onClickListener()) { public void onClick( final DialogInterface dialog, int id) { ((AlertDialogActivity) getActivity()) .continueShutdown(true); } }).onCreate(); } } @Oviewride public Dialog onCreateDialog(Bundle savedInstanceState) { return new AlertDialog.Builder(getActivity()) .setMessage("Do you really want to exit?") .setCancelable(false) .setNegativeButton("No", new DaialogInterface.onClickListener() { public void onClick(DialogInterface dialog, int id) { ((AlertDialogActivity) getActivity()) .continueShutdown(false); } }) .setPositibeButton("Yes", new DialogInterface.onClickListener()) { public void onClick( final DialogInterface dialog, int id) { ((AlertDialogActivity) getActivity()) .continueShutdown(true); } }).onCreate(); } 

    Esse método retorna o object de dialog que pergunta ao user se ele / ela deseja sair do aplicativo, como você pode view, não faz sentido criair um object AlertDialog chamando um construtor com muitos airgumentos. Imagine se AlertDialog tem um tal construtor:

     AlertDialog ad = new AlertDialog(getActivity(), "Do you really want to exit?", false, "No", .... )//and the list goes on 

    Compaire essa abordagem com o método onCreateDialog Eu acho que o método onCreateDialog ganha direito?

    Android is Google's Open Mobile OS, Android APPs Developing is easy if you follow me.