Необработанный тип исключения. Тишина без типичного типа [дубликат]

записать в CSS

.form-group.required .control-label:after {content:"*";color:red;}

и HTML

<div class="form-group required">

    <label class="control-label">Name:</label>

    <input type="text">

</div>
525
задан Taryn 22 March 2017 в 17:13
поделиться

14 ответов

Здесь я рассматриваю несколько случаев, через которые вы можете очистить концепцию

1. ArrayList<String> arr = new ArrayList<String>();
2. ArrayList<String> arr = new ArrayList();
3. ArrayList arr = new ArrayList<String>();

Случай 1

ArrayList<String> arr является ссылочной переменной ArrayList с типом String, которые ссылаются на объект ArralyList типа String. Это означает, что он может содержать только объект типа String.

Строго для String не для Raw Type, поэтому он никогда не будет предупреждать.

    arr.add("hello");// alone statement will compile successfully and no warning.

    arr.add(23);  //prone to compile time error.
     //error: no suitable method found for add(int)

Случай 2

В этом случае ArrayList<String> arr является строгим типом, но ваш объект new ArrayList(); является сырым типом.

    arr.add("hello"); //alone this compile but raise the warning.
    arr.add(23);  //again prone to compile time error.
    //error: no suitable method found for add(int)

здесь arr является строгим типом. Таким образом, он будет поднимать ошибку времени компиляции при добавлении integer.

Предупреждение: - Объект типа Raw ссылается на тип Strict Referenced Variable ArrayList.

Случай 3

В этом случае ArrayList arr является сырым типом, но ваш Object new ArrayList<String>(); является строгим типом.

    arr.add("hello");  
    arr.add(23);  //compiles fine but raise the warning.

Он добавит в него любой тип объекта, потому что arr является сырым типом.

Внимание: - A Strict Тип Объект ссылается на a raw тип, на который ссылается переменная.

9
ответ дан Aluan Haddad 15 August 2018 в 16:22
поделиться

«Явный» тип в Java - это класс, который является неэквивалентным и имеет дело с «сырыми» объектами, а не с типичными типами типовых параметров.

Например, до того, как были доступны дженерики Java , вы должны использовать класс коллекции следующим образом:

LinkedList list = new LinkedList();
list.add(new MyObject());
MyObject myObject = (MyObject)list.get(0);

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

Используя generics, вы удаляете «неизвестный» коэффициент, потому что вы должны явно указать, какой тип объектов может идти в списке:

LinkedList<MyObject> list = new LinkedList<MyObject>();
list.add(new MyObject());
MyObject myObject = list.get(0);

Обратите внимание, что с помощью дженериков вам не нужно бросать объект, исходящий из вызова get, сбор предварительно задан для работы с MyObject. Этот факт является основным движущим фактором для генериков. Он меняет источник ошибок времени выполнения во что-то, что можно проверить во время компиляции.

12
ответ дан Andy White 15 August 2018 в 16:22
поделиться
  • 1
    Более конкретно, тип raw - это то, что вы получаете, когда просто опускаете параметры типа для универсального типа. Сырые типы действительно были только функцией обратной совместимости и могут быть подвергнуты удалению. Вы можете использовать подобное поведение? подстановочные параметры. – John Flatness 5 May 2010 в 04:10
  • 2
    @zerocrates: похоже, но разные! Использование ? по-прежнему обеспечивает безопасность типов. Я объяснил это в своем ответе. – polygenelubricants 5 May 2010 в 06:08

Что такое необработанный тип и почему я часто слышу, что они не должны использоваться в новом коде?

«Необработанный тип» - это использование общего класс без указания аргумента (ов) типа для его параметризованного типа (ов), например используя List вместо List<String>. Когда дженерики были введены в Java, несколько классов были обновлены для использования дженериков. Использование этого класса в качестве «необработанного типа» (без указания аргумента типа) позволило сохранить прежний код.

«Необработанные типы» используются для обратной совместимости. Их использование в новом коде не рекомендуется, потому что использование универсального класса с аргументом типа допускает более сильную типизацию, что, в свою очередь, может улучшить понятность кода и привести к появлению потенциальных проблем раньше.

Что такое альтернатива, если мы не можем использовать необработанные типы и как это лучше?

. Предпочтительной альтернативой является использование общих классов, как предполагалось, - с подходящим аргументом типа (например, List<String>). Это позволяет программисту более конкретно указывать типы, придавая будущим сопровождающим больше смысла предполагаемое использование переменной или структуры данных и позволяет компилятору обеспечивать лучшую безопасность типов. Эти преимущества вместе могут улучшить качество кода и помочь предотвратить появление некоторых ошибок кодирования.

Например, для метода, в котором программист хочет, чтобы переменная List, называемая «имена», содержит только строки:

List<String> names = new ArrayList<String>();
names.add("John");          // OK
names.add(new Integer(1));  // compile error
10
ответ дан Bert F 15 August 2018 в 16:22
поделиться
  • 1
    Ах, поэтому соблазн скопировать polygenelubricants 's raw type & quot; ссылки из stackoverflow.com/questions/2770111/… в мой собственный ответ, но я полагаю, что оставлю их для использования в его собственном ответе. – Bert F 5 May 2010 в 05:38
  • 2
    да, я по сути копировал и вставлял этот сегмент везде, где люди использовали raw-типы в stackoverflow, и, наконец, решил только один вопрос, на который нужно ссылаться. Я надеюсь, что это хороший вклад для сообщества. – polygenelubricants 5 May 2010 в 06:02
  • 3
    @polygenelubricants я заметил - мы затронули некоторые из тех же вопросов :-) – Bert F 5 May 2010 в 06:17
  • 4
    этот ответ намного лучше, чем принятый - краткий и простой – ha9u63ar 2 August 2016 в 11:47
  • 5
    @ ha9u63ar: Действительно. В целом краткие и простые ответы, по крайней мере, столь же хороши, как и длинные и принятые. – displayName 7 August 2017 в 15:02
 private static List<String> list = new ArrayList<String>();

Вы должны указать параметр типа.

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

List определен для поддержки generics: public class List<E>. Это позволяет выполнять много типов безопасных операций, проверенных временем компиляции.

16
ответ дан Bozho 15 August 2018 в 16:22
поделиться
  • 1
    Теперь вместо выражения diamond inference заменено на Java 7 - private static List<String> list = new ArrayList<>(); – Ian Campbell 10 October 2014 в 15:03

Вот еще один случай, когда сырые типы вас укусят:

public class StrangeClass<T> {
  @SuppressWarnings("unchecked")
  public <X> X getSomethingElse() {
    return (X)"Testing something else!";
  }

  public static void main(String[] args) {
    final StrangeClass<Object> withGeneric    = new StrangeClass<>();
    final StrangeClass         withoutGeneric = new StrangeClass();
    final String               value1,
                               value2;

    // Works
    value1 = withGeneric.getSomethingElse();

    // Produces compile error:
    // incompatible types: java.lang.Object cannot be converted to java.lang.String
    value2 = withoutGeneric.getSomethingElse();
  }
}

Как уже упоминалось в принятом ответе, вы теряете всю поддержку дженериков в коде необработанного типа. Каждый параметр типа преобразуется в его стирание (которое в приведенном выше примере просто Object).

4
ответ дан GuyPaddock 15 August 2018 в 16:22
поделиться

Что такое типы raw в Java и почему я часто слышу, что они не должны использоваться в новом коде?

Необработанные типы - это древняя история Java язык. В начале были Collections, и они больше не держали Objects и ничего меньше. Каждая операция на Collections требовала отличных от Object желаемого типа.

List aList = new ArrayList();
String s = "Hello World!";
aList.add(s);
String c = (String)aList.get(0);

Хотя это продолжалось большую часть времени, произошли ошибки

List aNumberList = new ArrayList();
String one = "1";//Number one
aNumberList.add(one);
Integer iOne = (Integer)aNumberList.get(0);//Insert ClassCastException here

Старый нетривиальные коллекции не могли обеспечить безопасность типов, поэтому программисту приходилось запоминать то, что он хранил в коллекции. Генераторы, изобретенные, чтобы обойти это ограничение, разработчик объявит сохраненный тип один раз, и компилятор сделает это вместо этого.

List<String> aNumberList = new ArrayList<String>();
aNumberList.add("one");
Integer iOne = aNumberList.get(0);//Compile time error
String sOne = aNumberList.get(0);//works fine

Для сравнения:

// Old style collections now known as raw types
List aList = new ArrayList(); //Could contain anything
// New style collections with Generics
List<String> aList = new ArrayList<String>(); //Contains only Strings

Более сложный Интерфейс Compareable:

//raw, not type save can compare with Other classes
class MyCompareAble implements CompareAble
{
   int id;
   public int compareTo(Object other)
   {return this.id - ((MyCompareAble)other).id;}
}
//Generic
class MyCompareAble implements CompareAble<MyCompareAble>
{
   int id;
   public int compareTo(MyCompareAble other)
   {return this.id - other.id;}
}

Обратите внимание, что невозможно реализовать интерфейс CompareAble с compareTo(MyCompareAble) с необработанными типами. Почему вы не должны их использовать:

  • Любое Object, хранящееся в Collection, должно быть выполнено до его использования
  • Использование обобщений позволяет проверять время компиляции
  • Использование исходных типов - это то же самое, что и сохранение каждого значения как Object

Что делает компилятор: Дженерики обратно совместимы, они используют одни и те же классы java, типы делают.

List<String> someStrings = new ArrayList<String>();
someStrings.add("one");
String one = someStrings.get(0);

Будет скомпилирован как:

List someStrings = new ArrayList();
someStrings.add("one"); 
String one = (String)someStrings.get(0);

Это тот же код, который вы бы написали, если вы использовали исходные типы напрямую. Думаю, я не уверен, что происходит с интерфейсом CompareAble, я предполагаю, что он создает две функции compareTo, одна из которых принимает MyCompareAble, а другая принимает Object и передает ее первой после ее литья.

Каковы альтернативы сырым типам: используйте generics

48
ответ дан jiaweizhang 15 August 2018 в 16:22
поделиться

Компилятор хочет, чтобы вы это записывали:

private static List<String> list = new ArrayList<String>();

, потому что в противном случае вы могли бы добавить любой тип, который вам нравится, в list, делая создание как new ArrayList<String>() бессмысленным. Java generics - это только функция времени компиляции, поэтому объект, созданный с помощью new ArrayList<String>(), с радостью примет Integer или JFrame элементы, если они назначены ссылке «raw type» List - сам объект ничего не знает о какие типы он должен содержать, только компилятор делает.

10
ответ дан Michael Borgwardt 15 August 2018 в 16:22
поделиться

учебная страница .

Необработанный тип - это имя общего класса или интерфейса без каких-либо аргументов типа. Например, с учетом общего класса Box:

public class Box<T> {
    public void set(T t) { /* ... */ }
    // ...
}

Чтобы создать параметризованный тип поля, вы указываете фактический аргумент типа для параметра формального типа T:

Box<Integer> intBox = new Box<>();

Если аргумент фактического типа опущен, вы создаете необработанный тип Box:

Box rawBox = new Box();
4
ответ дан Mykhaylo Adamovych 15 August 2018 в 16:22
поделиться

Говорят, что ваш list является List объектов, не указанных. Это значит, что Java не знает, какие объекты находятся внутри списка. Затем, когда вы хотите итерировать список, вы должны использовать каждый элемент, чтобы иметь доступ к свойствам этого элемента (в данном случае, String).

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

private static List<String> list = new ArrayList<String>();
4
ответ дан pakore 15 August 2018 в 16:22
поделиться

Я нашел эту страницу после выполнения некоторых упражнений с образцами и с тем же самым загадкой.

============== Я перешел от этого кода в качестве примера ===============

public static void main(String[] args) throws IOException {

    Map wordMap = new HashMap();
    if (args.length > 0) {
        for (int i = 0; i < args.length; i++) {
            countWord(wordMap, args[i]);
        }
    } else {
        getWordFrequency(System.in, wordMap);
    }
    for (Iterator i = wordMap.entrySet().iterator(); i.hasNext();) {
        Map.Entry entry = (Map.Entry) i.next();
        System.out.println(entry.getKey() + " :\t" + entry.getValue());
    }

====================== Этот код ========================

public static void main(String[] args) throws IOException {
    // replace with TreeMap to get them sorted by name
    Map<String, Integer> wordMap = new HashMap<String, Integer>();
    if (args.length > 0) {
        for (int i = 0; i < args.length; i++) {
            countWord(wordMap, args[i]);
        }
    } else {
        getWordFrequency(System.in, wordMap);
    }
    for (Iterator<Entry<String, Integer>> i = wordMap.entrySet().iterator(); i.hasNext();) {
        Entry<String, Integer> entry =   i.next();
        System.out.println(entry.getKey() + " :\t" + entry.getValue());
    }

}

================ ================================================== =============

Это может быть безопаснее, но потребовалось 4 часа, чтобы одурачить философию ...

1
ответ дан Pang 15 August 2018 в 16:22
поделиться

Необработанный тип - это имя общего класса или интерфейса без аргументов типа. Например, с учетом общего класса Box:

public class Box<T> {
    public void set(T t) { /* ... */ }
    // ...
}

Чтобы создать параметризованный тип Box<T>, вы указываете фактический аргумент типа для параметра формального типа T:

Box<Integer> intBox = new Box<>();

Если аргумент фактического типа опущен, вы создаете необработанный тип Box<T>:

Box rawBox = new Box();

. Поэтому Box является необработанным типом родового типа Box<T>. Однако не общий тип или тип интерфейса не является сырым типом.

Необработанные типы отображаются в устаревшем коде, потому что многие классы API (например, классы Collections) не были типичными до JDK 5.0. При использовании сырых типов вы, по существу, получаете поведение перед генериками - Box дает вам Object s. Для обратной совместимости допускается присвоение параметризованного типа его необработанному типу:

Box<String> stringBox = new Box<>();
Box rawBox = stringBox;               // OK

Но если вы назначаете сырой тип параметризованному типу, вы получите предупреждение:

Box rawBox = new Box();           // rawBox is a raw type of Box<T>
Box<Integer> intBox = rawBox;     // warning: unchecked conversion

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

Box<String> stringBox = new Box<>();
Box rawBox = stringBox;
rawBox.set(8);  // warning: unchecked invocation to set(T)

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

В разделе «Тип стирания» содержится дополнительная информация о том, как компилятор Java использует необработанные типы.

Непроверенные сообщения об ошибках

As упомянутый ранее, при смешивании устаревшего кода с общим кодом вы можете столкнуться с предупреждающими сообщениями, подобными следующим:

Примечание: Example.java использует непроверенные или небезопасные операции.

Примечание : Перекомпиляция с -Xlint: не проверяется для деталей.

Это может произойти при использовании более старого API, который работает с необработанными типами, как показано в следующем примере:

public class WarningDemo {
    public static void main(String[] args){
        Box<Integer> bi;
        bi = createBox();
    }

    static Box createBox(){
        return new Box();
    }
}

Термин «непроверенный» означает, что компилятор не имеет достаточной информации о типе для выполнения всех проверок типа, необходимых для обеспечения безопасности типа. Предупреждение «unchecked» по умолчанию отключено, хотя компилятор дает подсказку. Чтобы просмотреть все «непроверенные» предупреждения, перекомпилируйте с помощью -Xlint: unchecked.

Повторная компиляция предыдущего примера с -Xlint: unchecked показывает следующую дополнительную информацию:

WarningDemo.java:4: warning: [unchecked] unchecked conversion
found   : Box
required: Box<java.lang.Integer>
        bi = createBox();
                      ^
1 warning

Чтобы полностью отключить unchecked warnings, используйте флаг -Xlint: -unchecked. Аннотации @SuppressWarnings("unchecked") подавляют непроверенные предупреждения. Если вы не знакомы с синтаксисом @SuppressWarnings, см. Аннотации.

Исходный источник: Учебники по Java

21
ответ дан Paul Bellora 15 August 2018 в 16:22
поделиться
625
ответ дан Solomon Ucko 15 August 2018 в 16:22
поделиться

Исходные типы прекрасны, когда они выражают то, что вы хотите выразить.

Например, функция десериализации может возвращать List, но она не знает тип элемента списка. Таким образом, List является подходящим типом возврата.

0
ответ дан Stefan Reich 15 August 2018 в 16:22
поделиться
  • 1
    Вы можете использовать ? как параметр типа – Dániel Kis 27 December 2017 в 20:29
  • 2
    Да, но это больше похоже на тип, и я против ввода большего количества. :) – Stefan Reich 31 December 2017 в 19:37

Тип raw - это отсутствие параметра типа при использовании родового типа.

Необработанный тип не должен использоваться, потому что это может привести к ошибкам во время выполнения, например, вставить double в то, что должно было быть Set из int s.

Set set = new HashSet();
set.add(3.45); //ok

При извлечении материала из Set вы надеваете Не знаю, что выйдет. Предположим, что вы ожидаете, что это все int s, вы отбрасываете его на Integer; исключение во время выполнения, когда приходит double 3.45.

С параметром типа , добавленным к вашему Set, вы сразу же получите ошибку компиляции. Эта превентивная ошибка позволяет устранить проблему, прежде чем что-то взорвется во время работы (таким образом, сэкономив время и усилия).

Set<Integer> set = new HashSet<Integer>();
set.add(3.45); //NOT ok.
8
ответ дан The Nail 15 August 2018 в 16:22
поделиться
Другие вопросы по тегам:

Похожие вопросы: