Использования абстрактных классов в Java

Question

В Stackoverflow я получил ссылку на ответ, как показано ниже, но его определение и понятие абстрактных классов обеспечиваются не логическая причиной

Abstract class in Java

В моем понимании, я думаю, что абстрактные классы содержат реализованные методы, многократно используемые для подклассов.

Я проверил AbstractList и AbstractMap, все методы из них переопределены в ArrayList и HashMap, но те же реализованные методы AbstractList или AbstractMap не используются в ArrayList или HashMap.

Есть ли что-нибудь еще для абстрактных классов. Может ли кто-нибудь сообщить мне

Answer 1

Класс abstract - класс, который реализует большую часть функциональных возможностей объекта, но оставляет для вас важнейшую функциональность.

Когда будет предложено (или даже ожидается), что будут реализованы реализации интерфейса, обычно предоставляется вся необходимая помощь для этого. Здесь чрезвычайно полезны классы Abstract.... Они не только реализуют интерфейс, но и предоставляют минимальный набор методов abstract, которые вы должны реализовать для достижения этого.

Рассмотрим реализацию списка, который содержит один единственный String с помощью AbstractList:

class OneHelloList extends AbstractList<String> implements List<String> { 

    @Override 
    public int size() { 
     return 1; 
    } 

    @Override 
    public String get(int index) { 
     return "Hello"; 
    } 

} 

public void test() { 
    for (String s : new OneHelloList()) { 
     System.out.println(s); 
    } 
} 

Смотрите, как это просто для меня, чтобы достичь полной функциональности в List с очень небольшой код базы.

Контраст, что с тем, что я должен сделать, чтобы implement List без AbstractList:

class TwoHellosList implements List<String> { 

    @Override 
    public int size() { 
     return 2; 
    } 

    @Override 
    public boolean isEmpty() { 
     return false; 
    } 

    @Override 
    public boolean contains(Object o) { 
     return o.toString().equals("Hello"); 
    } 

    @Override 
    public Iterator<String> iterator() { 
     return new Iterator<String>() { 
      int count = 0; 

      @Override 
      public boolean hasNext() { 
       return count < 2; 
      } 

      @Override 
      public String next() { 
       count += 1; 
       return "Hello"; 
      } 

     }; 
    } 

    // The rest for you to complete. 

    @Override 
    public Object[] toArray() { 
     throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates. 
    } 

    @Override 
    public <T> T[] toArray(T[] a) { 
     throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates. 
    } 

    @Override 
    public boolean add(String e) { 
     throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates. 
    } 

    @Override 
    public boolean remove(Object o) { 
     throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates. 
    } 

    @Override 
    public boolean containsAll(Collection<?> c) { 
     throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates. 
    } 

    @Override 
    public boolean addAll(Collection<? extends String> c) { 
     throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates. 
    } 

    @Override 
    public boolean addAll(int index, Collection<? extends String> c) { 
     throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates. 
    } 

    @Override 
    public boolean removeAll(Collection<?> c) { 
     throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates. 
    } 

    @Override 
    public boolean retainAll(Collection<?> c) { 
     throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates. 
    } 

    @Override 
    public void clear() { 
     throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates. 
    } 

    @Override 
    public String get(int index) { 
     throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates. 
    } 

    @Override 
    public String set(int index, String element) { 
     throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates. 
    } 

    @Override 
    public void add(int index, String element) { 
     throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates. 
    } 

    @Override 
    public String remove(int index) { 
     throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates. 
    } 

    @Override 
    public int indexOf(Object o) { 
     throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates. 
    } 

    @Override 
    public int lastIndexOf(Object o) { 
     throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates. 
    } 

    @Override 
    public ListIterator<String> listIterator() { 
     throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates. 
    } 

    @Override 
    public ListIterator<String> listIterator(int index) { 
     throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates. 
    } 

    @Override 
    public List<String> subList(int fromIndex, int toIndex) { 
     throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates. 
    } 

} 

Answer 2

абстрактные классы похожи на интерфейсы. Вы не можете создавать их, и они могут содержать сочетание методов, объявленных с реализацией или без нее. Однако с абстрактными классами вы можете объявлять поля, которые не являются статическими и окончательными, а также определять публичные, защищенные и частные конкретные методы. С интерфейсами все поля являются автоматически общедоступными, статическими и конечными, а все методы, которые вы объявляете или определяете (как методы по умолчанию), являются общедоступными. Кроме того, вы можете расширить только один класс, независимо от того, является он абстрактным, тогда как вы можете реализовать любое количество интерфейсов.

Что вы должны использовать, абстрактные классы или интерфейсы?

• Рассмотрите возможность использования абстрактных классов, если любой из этих утверждений относится к вашей ситуации:
  • Вы хотите поделиться кодом из нескольких тесно связанных классов.
  • Вы ожидаете, что классы, которые расширяют ваш абстрактный класс, имеют много общих методов или полей или требуют модификаторов доступа, кроме публичных (таких как защищенные и закрытые).
  • Вы хотите объявить нестатические или не конечные поля. Это позволяет вам определять методы, которые могут получить доступ и изменить состояние объекта, к которому они принадлежат.
• Рассмотрите возможность использования интерфейсов, если любой из этих утверждений относится к вашей ситуации:
  • Вы ожидаете, что несвязанные классы будут реализовывать свой интерфейс. Например, интерфейсы Comparable и Cloneable реализуются многими несвязанными классами.
  • Вы хотите указать поведение конкретного типа данных, но не беспокоитесь о том, кто реализует его поведение.
  • Вы хотите использовать множественное наследование типа.

realtime-examples

abstract-class-real-time-example

Answer 3

В самом деле Абстрактный классы может или не может включать в себя абстрактные методы. Абстрактные классы не могут быть созданы, но они могут быть подклассифицированы.

Почему мы используем абстрактные классы?

Предположим, что мы моделировали поведение людей, создавая иерархию классов, начатую с базового класса Human. Человек способен делать разные вещи нравится говорить и ходить и есть. Давайте рассмотрим поведение говорящего (пример: greeting()). Каждый гуман в зависимости от его национальности имеет другой язык: англичане скажут: «Hello» и люди из Френша скажут: «Bonjour».

Таким образом, мы знаем, что все люди могут делать приветствие, но с другим языком!

Это хороший кандидат для абстрактного метода (принуждение подклассов к созданию пользовательской реализации). Давайте посмотрим на очень примитивном Humain базового класса, который определяет абстрактный метод для создания приветик и ходи:

public abstract class Human 
{ 

    //We know that humain walk the same way so we provide 
    //method implementation at this level 
    public void walk() 
    { 
     System.out.println('I\'m walking !'); 
    } 

    //We don't know at this level what's the language of the humain 
    public abstract void greet(); 

} 

//This class inherit the walk() method and provide it's 
//specific implementation for the greeting() method 
public class EnglishMen extends Human { 

    @Override 
    public abstract void greet() { 
     System.out.println('Hello :) '); 
    } 

} 

//This class inherit the walk() method and provide it's 
//specific implementation for the greeting() method 
public class FrenshMen extends Human { 

    @Override 
    public abstract void greet() { 
     System.out.println('Bonjour :) '); 
    } 

} 

Теперь любая Humaun, который хочет быть создан (как англичанам или FrenshMen) должен implemen t метод greeting - в противном случае невозможно создать экземпляр этого класса.

Примечание: Если абстрактный класс подклассов, подкласс обычно обеспечивает реализации для всех абстрактных методов родительского класса. Однако, если это не так, то подкласс также должен быть объявлен абзацем .

Answer 4

Абстрактные классы также чрезвычайно полезны в тех случаях, когда фактическая реализация известна, но модель (данные) домена неизвестна.Например, для вставки в базу данных, вы можете написать абстрактный класс

public abstract class DBUpdate{ 

protected insert(){ 

...//the actual implementation 
} 
protected update(){ 

...//the actual implementation 
} 
protected delete(){ 

...//the actual implementation 
} 
//the fields of the subclasses can be obtained through reflection or some other method 

Теперь, давайте предположим, что у вас есть таблица MyTable с колоннами а, Ь и с, которые должны быть включены в базу данных

public class MyTable extends DBUpdate{ 

private String a; 
private String b; 
private String c; 

//add getters/setters here 
} 

Теперь для того, чтобы вставить MyTable записи, мы должны только создать экземпляр этого и вызвать метод вставки()

.... 
MyTable myTable = new MyTable(); 
myTable.seta("a"); 
myTable.setb("b"); 
myTable.setc("c"); 

myTable.insert(); 

DBUpdate знает, как вставлять, обновлять и удалять данные, но он все еще нуждается в подклассе (который в основном сообщает DBUpdate, какие данные необходимо обновить)