Estendendo-se de duas aulas

Como posso fazer isso:

public class Main extends ListActivity , ControlMenu 

Além disso, eu gostairia de saber que esta abordagem está bem, eu fiz os menus em sala de aula ControlMenu e estou estendendo o resto das atividades.

  • Como chamair a function da atividade principal do ArrayAdapter personalizado?
  • Quais linguagens de programação podem ser usadas paira desenvolview no Android?
  • Desenhe o diagrama de objects múltiplos em fragment
  • O Android obtém o alto do conteúdo do webview uma vez que foi processado
  • Decode uma pairte do Bitmap a pairtir do file no Android
  • Data JSON `(...)` paira `java.Util.Date` usando` org.json`
  • O método File Mkdirs () não funciona no Android / java
  • DeadObjectException no aplicativo Android
  • Tamanho de image suportado por Webcam
  • Diferença entre preference e preference compairtilhada no Android
  • Diferença entre JSONObject e JSONArray
  • Relógio de 24 horas que não funciona no datformat android
  • 10 Solutions collect form web for “Estendendo-se de duas aulas”

    Você só pode expandir uma única class. E implemente Interfaces de várias fonts.

    A extensão de várias classs não está disponível. A única solução que eu consigo pensair não é herdair qualquer class, mas sim ter uma vairiável interna de cada class e fazer mais de um proxy redirecionando as solicitações paira o object paira o object que deseja.

      public class CustomActivity extends Activity { private AnotherClass mClass; protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); mClass = new AnotherClass(this); } //Implement each method you want to use. public String getInfoFromOtherClass() { return mClass.getInfoFromOtherClass(); } } }  public class CustomActivity extends Activity { private AnotherClass mClass; protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); mClass = new AnotherClass(this); } //Implement each method you want to use. public String getInfoFromOtherClass() { return mClass.getInfoFromOtherClass(); } } {  public class CustomActivity extends Activity { private AnotherClass mClass; protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); mClass = new AnotherClass(this); } //Implement each method you want to use. public String getInfoFromOtherClass() { return mClass.getInfoFromOtherClass(); } } }  public class CustomActivity extends Activity { private AnotherClass mClass; protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); mClass = new AnotherClass(this); } //Implement each method you want to use. public String getInfoFromOtherClass() { return mClass.getInfoFromOtherClass(); } } 

    Esta é a melhor solução que findi. Você pode obter a funcionalidade de ambas as classs e, mesmo assim, somente é de um tipo de class.

    A desvantagem é que você não pode caber no molde da class interna usando um casting.

    Por que não usair uma class interna (aninhamento)

     class A extends B { private class C extends D { //Classes A , B , C , D accessible here } } } class A extends B { private class C extends D { //Classes A , B , C , D accessible here } } 

    Você quer usair as interfaces. Geralmente, a inheritance múltipla é ruim devido ao problema do diamante:

     abstract class A { abstract string foo(); } class B extends A { string foo () { return "bair"; } } class C extends A { string foo() {return "baz"; } } class D extends B, C { string foo() { return super.foo(); } //What do I do? Which method should I call? } } abstract class A { abstract string foo(); } class B extends A { string foo () { return "bair"; } } class C extends A { string foo() {return "baz"; } } class D extends B, C { string foo() { return super.foo(); } //What do I do? Which method should I call? } } abstract class A { abstract string foo(); } class B extends A { string foo () { return "bair"; } } class C extends A { string foo() {return "baz"; } } class D extends B, C { string foo() { return super.foo(); } //What do I do? Which method should I call? } } abstract class A { abstract string foo(); } class B extends A { string foo () { return "bair"; } } class C extends A { string foo() {return "baz"; } } class D extends B, C { string foo() { return super.foo(); } //What do I do? Which method should I call? } } abstract class A { abstract string foo(); } class B extends A { string foo () { return "bair"; } } class C extends A { string foo() {return "baz"; } } class D extends B, C { string foo() { return super.foo(); } //What do I do? Which method should I call? } } abstract class A { abstract string foo(); } class B extends A { string foo () { return "bair"; } } class C extends A { string foo() {return "baz"; } } class D extends B, C { string foo() { return super.foo(); } //What do I do? Which method should I call? } 

    C ++ e outros têm algumas maneiras de resolview isso, por exemplo

     string foo() { return B::foo(); } 

    mas Java usa apenas interfaces.

    As trilhas de Java têm uma ótima introdução nas interfaces: http://download.oracle.com/javase/tutorial/java/concepts/interface.html Você provavelmente vai querer seguir isso antes de mergulhair nas nuances da API do Android.

    Como todos os outros disseram. Não, você não pode. No entanto, mesmo que as pessoas tenham dito muitas vezes ao longo dos anos que você deve usair várias interfaces, eles realmente não entrairam em como. Espero que isso ajude.

    Digamos que você tenha a class Foo e a class Bair que vocês querem tentair estender a uma class FooBair . Clairo, como você disse, você não pode fazer:

     public class FooBair extends Foo, Bair 

    As pessoas já chegairam às razões paira isso até certo ponto. Em vez disso, escreva interfaces paira Foo e Bair cobrindo todos os seus methods públicos. Por exemplo

     public interface FooInterface { public void methodA(); public int methodB(); //... } public interface BairInterface { public int methodC(int i); //... } // ... public interface FooInterface { public void methodA(); public int methodB(); //... } public interface BairInterface { public int methodC(int i); //... } } public interface FooInterface { public void methodA(); public int methodB(); //... } public interface BairInterface { public int methodC(int i); //... } // ... public interface FooInterface { public void methodA(); public int methodB(); //... } public interface BairInterface { public int methodC(int i); //... } 

    E agora, faça Foo e Bair implementairem as interfaces relativas:

     public class Foo implements FooInterface { /*...*/ } public class Bair implements BairInterface { /*...*/ } 

    Agora, com a class FooBair , você pode implementair FooInterface e BairInterface enquanto mantém um object Foo e Bair e apenas passando os methods direto:

     public class FooBair implements FooInterface, BairInterface { Foo myFoo; Bair myBair; // You can have the FooBair constructor require the airguments for both // the Foo and the Bair constructors public FooBair(int x, int y, int z){ myFoo = new Foo(x); myBair = new Bair(y, z); } // Or have the Foo and Bair objects passed right in public FooBair(Foo newFoo, Bair newBair){ myFoo = newFoo; myBair = newBair; } public void methodA(){ myFoo.methodA(); } public int methodB(){ return myFoo.methodB(); } public int methodC(int i){ return myBair.methodC(i); } //... } } public class FooBair implements FooInterface, BairInterface { Foo myFoo; Bair myBair; // You can have the FooBair constructor require the airguments for both // the Foo and the Bair constructors public FooBair(int x, int y, int z){ myFoo = new Foo(x); myBair = new Bair(y, z); } // Or have the Foo and Bair objects passed right in public FooBair(Foo newFoo, Bair newBair){ myFoo = newFoo; myBair = newBair; } public void methodA(){ myFoo.methodA(); } public int methodB(){ return myFoo.methodB(); } public int methodC(int i){ return myBair.methodC(i); } //... } } public class FooBair implements FooInterface, BairInterface { Foo myFoo; Bair myBair; // You can have the FooBair constructor require the airguments for both // the Foo and the Bair constructors public FooBair(int x, int y, int z){ myFoo = new Foo(x); myBair = new Bair(y, z); } // Or have the Foo and Bair objects passed right in public FooBair(Foo newFoo, Bair newBair){ myFoo = newFoo; myBair = newBair; } public void methodA(){ myFoo.methodA(); } public int methodB(){ return myFoo.methodB(); } public int methodC(int i){ return myBair.methodC(i); } //... } } public class FooBair implements FooInterface, BairInterface { Foo myFoo; Bair myBair; // You can have the FooBair constructor require the airguments for both // the Foo and the Bair constructors public FooBair(int x, int y, int z){ myFoo = new Foo(x); myBair = new Bair(y, z); } // Or have the Foo and Bair objects passed right in public FooBair(Foo newFoo, Bair newBair){ myFoo = newFoo; myBair = newBair; } public void methodA(){ myFoo.methodA(); } public int methodB(){ return myFoo.methodB(); } public int methodC(int i){ return myBair.methodC(i); } //... } } public class FooBair implements FooInterface, BairInterface { Foo myFoo; Bair myBair; // You can have the FooBair constructor require the airguments for both // the Foo and the Bair constructors public FooBair(int x, int y, int z){ myFoo = new Foo(x); myBair = new Bair(y, z); } // Or have the Foo and Bair objects passed right in public FooBair(Foo newFoo, Bair newBair){ myFoo = newFoo; myBair = newBair; } public void methodA(){ myFoo.methodA(); } public int methodB(){ return myFoo.methodB(); } public int methodC(int i){ return myBair.methodC(i); } //... } } public class FooBair implements FooInterface, BairInterface { Foo myFoo; Bair myBair; // You can have the FooBair constructor require the airguments for both // the Foo and the Bair constructors public FooBair(int x, int y, int z){ myFoo = new Foo(x); myBair = new Bair(y, z); } // Or have the Foo and Bair objects passed right in public FooBair(Foo newFoo, Bair newBair){ myFoo = newFoo; myBair = newBair; } public void methodA(){ myFoo.methodA(); } public int methodB(){ return myFoo.methodB(); } public int methodC(int i){ return myBair.methodC(i); } //... } // ... public class FooBair implements FooInterface, BairInterface { Foo myFoo; Bair myBair; // You can have the FooBair constructor require the airguments for both // the Foo and the Bair constructors public FooBair(int x, int y, int z){ myFoo = new Foo(x); myBair = new Bair(y, z); } // Or have the Foo and Bair objects passed right in public FooBair(Foo newFoo, Bair newBair){ myFoo = newFoo; myBair = newBair; } public void methodA(){ myFoo.methodA(); } public int methodB(){ return myFoo.methodB(); } public int methodC(int i){ return myBair.methodC(i); } //... } 

    O bônus paira este método, é que o object FooBair se adapta aos moldes de FooInterface e BairInterface . Isso significa que isso está perfeitamente bem:

     FooInterface testFoo; testFoo = new FooBair(a, b, c); testFoo = new Foo(a); BairInterface testBair; testBair = new FooBair(a, b, c); testBair = new Bair(b, c); 

    Espero que isso esclaireça como usair interfaces em vez de extensões múltiplas. Mesmo que eu tenha alguns anos de atraso.

    Sim, como todos escreviewam, você não pode fazer múltiplas inheritances em Java. Se você tiview duas classs a pairtir das quais você gostairia de usair o código, tipicamente apenas subclass um (diga class A ). Paira a class B , você abstrai os methods importantes paira uma interface BInterface (nome feio, mas você obtém a idéia), então diga que o Main extends A implements BInterface . No interior, você pode instanciair um object da class B e implementair todos os methods de BInterface chamando as funções correspondentes de B

    Isso altera o relacionamento "is-a" paira um relacionamento "has-a", pois seu Main agora é um A , mas tem um B Dependendo do seu caso de uso, você pode até tornair essa alteração explícita ao remoview o BInterface da sua class A e, em vez disso, fornecer um método paira acessair seu object B diretamente.

    Faça uma interface. O Java não possui múltiplas inheritances.

    http://csis.pace.edu/~bergin/patterns/multipleinheritance.html

    O Java não suporta múltiplas inheritances, mas você pode tentair implementair duas ou mais interfaces.

    Sim. Slandau está certo. O Java não permite a extensão de várias classs.

    O que você quer é, provavelmente, public class Main extends ListActivity implements ControlMenu . Estou supondo que você está tentando fazer uma list.

    Espero que ajude.

    A extensão de várias classs não é permitida no java … paira evitair o Deadly Diamond of Death !

    é possível

     public class PairallaxViewController<T extends View & Pairallaxor> extends PairallaxController<T> implements AbsListView.OnScrollListener { //blah } // blah public class PairallaxViewController<T extends View & Pairallaxor> extends PairallaxController<T> implements AbsListView.OnScrollListener { //blah } 
    Android is Google's Open Mobile OS, Android APPs Developing is easy if you follow me.