Чи є оператор return просто для задоволення синтаксису поганою практикою?

Розглянемо такий код:

public Object getClone(Cloneable a) throws TotallyFooException {

    if (a == null) {
        throw new TotallyFooException();
    }
    else {
        try {
            return a.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
    //cant be reached, in for syntax
    return null;
}

Це return null;необхідно, оскільки виняток може бути спійманий, однак у такому випадку, оскільки ми вже перевірили, чи є воно нульовим (і припустимо, що ми знаємо, що клас, який ми викликаємо, підтримує клонування), тому ми знаємо, що оператор try ніколи не провалиться.

Чи погана практика вводити додатковий оператор return в кінці лише для того, щоб задовольнити синтаксис і уникнути помилок компіляції (з коментарем, який пояснює, що це не буде досягнуто), чи є кращий спосіб кодувати щось подібне, щоб додаткові оператор повернення непотрібний?

Більш зрозумілий спосіб без зайвого оператора повернення такий. Я теж не впіймав би CloneNotSupportedException, але нехай це надходить до абонента.

if (a != null) {
    try {
        return a.clone();
    } catch (CloneNotSupportedException e) {
        e.printStackTrace();
    }
}
throw new TotallyFooException();

Майже завжди можна возитись із замовленням, щоб у підсумку отримати більш прямий синтаксис, ніж той, який ви спочатку мали.

Це точно можна досягти. Зверніть увагу, що ви друкуєте стек трасування лише у цьому catchпункті.

У тому випадку, коли a != nullі буде виняток, return null буде досягнуто. Ви можете видалити це твердження і замінити його на throw new TotallyFooException();.

Загалом ^* , якщо nullє дійсним результатом методу (тобто користувач очікує його, а це щось означає), тоді повернення його як сигналу для "дані не знайдені" або виняток стався - це не гарна ідея. В іншому випадку я не бачу жодної проблеми, чому б вам не повернутися null.

Візьмемо для прикладу Scanner#ioExceptionметод:

Повертає IOExceptionостаннє викинуте базовим читачем цього сканера. Цей метод повертає нуль, якщо такого винятку не існує .

У цьому випадку повернене значення nullмає чітке значення, коли я використовую метод, я можу бути впевнений, що отримав його nullлише тому, що такого винятку не було, а не тому, що метод намагався щось зробити, і він не вдався.

^* Зверніть увагу, що іноді ви хочете повернутися, nullнавіть коли значення неоднозначне. Наприклад HashMap#get:

Повернене значення null не обов'язково означає, що карта не містить відображення ключа; також можливо, що карта явно відображає ключ у нуль . containsKeyОперація може бути використана , щоб відрізнити ці два випадки.

У цьому випадку nullможе вказувати, що значення null було знайдено і повернуто, або що хеш-карта не містить запитаного ключа.

Чи погана практика вкладати в кінець додатковий оператор return, щоб задовольнити синтаксис і уникнути помилок компіляції (з коментарем, який пояснює, що це не буде зроблено)

Я думаю, що return nullце погана практика для кінця недосяжної гілки. Краще кинути RuntimeException( AssertionErrorце також було б прийнятно), оскільки для того, щоб дістатися до цього рядка щось пішло дуже не так, і програма знаходиться в невідомому стані. Більше подібного є (як вище), оскільки розробник щось пропустив (Об’єкти можуть бути ненульовими та не клонованими).

Швидше за все, я б не використовував, InternalErrorякщо я не дуже впевнений, що код недосяжний (наприклад, після a System.exit()), оскільки, швидше за все, я роблю помилку, ніж віртуальна машина.

Я б використовував спеціальний виняток (наприклад TotallyFooException), якщо потрапляння до цієї "недосяжної лінії" означає те саме, що де завгодно, коли ви кидаєте цей виняток.

Ви зрозуміли, CloneNotSupportedExceptionщо означає, що ваш код може це впоратись. Але після того, як ви його зловите, ви буквально не уявляєте, що робити, коли дійдете до кінця функції, а це означає, що ви не змогли з цим впоратися. Тож ви маєте рацію, що в цьому випадку це запах коду, і, на мій погляд, це означає, що ви не повинні були вловлювати CloneNotSupportedException.

Я вважаю за краще використовувати, Objects.requireNonNull()щоб перевірити, чи не є параметр a нульовим. Отже, коли ви читаєте код, стає зрозуміло, що параметр не повинен бути нульовим.

А щоб уникнути перевірених винятків, я б перекинув CloneNotSupportedExceptionяк a RuntimeException.

Для обох ви можете додати приємний текст з наміром, чому цього не повинно статися чи бути так.

public Object getClone(Object a) {

    Objects.requireNonNull(a);

    try {
        return a.clone();
    } catch (CloneNotSupportedException e) {
        throw new IllegalArgumentException(e);
    }

}

У такій ситуації я б написав

public Object getClone(SomeInterface a) throws TotallyFooException {
    // Precondition: "a" should be null or should have a someMethod method that
    // does not throw a SomeException.
    if (a == null) {
        throw new TotallyFooException() ; }
    else {
        try {
            return a.someMethod(); }
        catch (SomeException e) {
            throw new IllegalArgumentException(e) ; } }
}

Цікаво, що ви стверджуєте, що "заява" спробувати ніколи не провалиться ", але ви все-таки взяли на себе зусилля, написавши заяву, e.printStackTrace();яка, як ви стверджуєте, ніколи не буде виконана. Чому?

Можливо, ваша переконаність не така тверда. Це добре (на мій погляд), оскільки ваша переконаність базується не на коді, який ви написали, а на сподіванні, що ваш клієнт не порушить передумови. Краще програмувати публічні методи в обороні.

До речі, ваш код для мене не компілюється. Ви не можете телефонувати, a.clone()навіть якщо тип aє Cloneable. Принаймні так говорить компілятор Eclipse. Вираз a.clone()дає помилку

Метод clone () невизначений для типу Cloneable

Я б зробив для вашого конкретного випадку

public Object getClone(PubliclyCloneable a) throws TotallyFooException {
    if (a == null) {
        throw new TotallyFooException(); }
    else {
        return a.clone(); }
}

Де PubliclyCloneableвизначається

interface PubliclyCloneable {
    public Object clone() ;
}

Або, якщо вам абсолютно потрібен тип параметра Cloneable, принаймні компілюється наступне.

public static Object getClone(Cloneable a) throws TotallyFooException {
//  Precondition: "a" should be null or point to an object that can be cloned without
// throwing any checked exception.
    if (a == null) {
        throw new TotallyFooException(); }
    else {
        try {
            return a.getClass().getMethod("clone").invoke(a) ; }
        catch( IllegalAccessException e ) {
            throw new AssertionError(null, e) ; }
        catch( InvocationTargetException e ) {
            Throwable t = e.getTargetException() ;
            if( t instanceof Error ) {
                // Unchecked exceptions are bubbled
                throw (Error) t ; }
            else if( t instanceof RuntimeException ) {
                // Unchecked exceptions are bubbled
                throw (RuntimeException) t ; }
            else {
                // Checked exceptions indicate a precondition violation.
                throw new IllegalArgumentException(t) ; } }
        catch( NoSuchMethodException e ) {
            throw new AssertionError(null, e) ; } }
}

Наведені вище приклади є дійсними і дуже Java. Однак, ось як я міг би відповісти на запитання ОП про те, як обробляти це повернення:

public Object getClone(Cloneable a) throws CloneNotSupportedException {
    return a.clone();
}

Немає користі від перевірки, aчи є воно нульовим. Це буде до NPE. Друк трасування стека також не корисний. Трасування стека однакове незалежно від того, де з ним обробляється.

Немає жодної користі від змішування коду за допомогою непотрібних нульових тестів та безцільної обробки винятків. Видаляючи непотріб, проблема повернення є спірною.

(Зверніть увагу, що OP включав помилку в обробці винятків; саме тому потрібно було повернення. OP не помилився б із запропонованим методом.)

Чи є оператор return просто для задоволення синтаксису поганою практикою?

Як зазначали інші, у вашому випадку це насправді не застосовується.

Однак, щоб відповісти на запитання, програми типу Lint напевно цього не зрозуміли! Я бачив, як двоє різних боролися з цим у заяві про перемикання.

    switch (var)
   {
     case A:
       break;
     default:
       return;
       break;    // Unreachable code.  Coding standard violation?
   }

Один скаржився, що відсутність перерви є порушенням стандартного кодування. Інший скаржився, що його наявність - один, бо це недоступний код.

Я помітив це, тому що два різні програмісти продовжували повторно перевіряти код, додавши перерву, потім видаливши, додавши, видаливши, залежно від того, який аналізатор коду вони запускали того дня.

Якщо ви потрапили в цю ситуацію, виберіть одну і прокоментуйте аномалію, яка є гарною формою, яку ви показали собі. Це найкращий і найважливіший винос.

Це не "просто задовольнити синтаксис". Семантичною вимогою мови є те, що кожен шлях коду призводить до повернення або викиду. Цей код не відповідає. Якщо виняток виявлено, потрібне наступне повернення.

Ніякої `` поганої практики '' щодо цього, або щодо задоволення компілятора загалом.

У будь-якому випадку, будь то синтаксис чи семантика, у вас немає вибору щодо цього.

Я б переписав це, щоб повернення було в кінці. Псевдокод:

if a == null throw ...
// else not needed, if this is reached, a is not null
Object b
try {
  b = a.clone
}
catch ...

return b

Про це ще ніхто не згадував, тому йдеться:

public static final Object ERROR_OBJECT = ...

//...

public Object getClone(Cloneable a) throws TotallyFooException {
Object ret;

if (a == null) 
    throw new TotallyFooException();

//no need for else here
try {
    ret = a.clone();
} catch (CloneNotSupportedException e) {
    e.printStackTrace();
    //something went wrong! ERROR_OBJECT could also be null
    ret = ERROR_OBJECT; 
}

return ret;

}

Мені не подобається returnвсередині tryблоків саме з цієї причини.

Повернення null; необхідний, оскільки може бути вилучено виняток, однак у такому випадку, оскільки ми вже перевірили, чи є воно нульовим (і припустимо, що ми знаємо клас, який ми викликаємо, підтримує клонування), тому ми знаємо, що оператор try ніколи не провалиться.

Якщо ви знаєте подробиці про введені дані таким чином, що ви знаєте, що tryтвердження ніколи не може провалитися, який сенс його мати? Уникайте, tryякщо ви точно знаєте, що речі завжди будуть успішними (хоча рідко ви можете бути абсолютно впевненими протягом усього життя своєї кодової бази).

У будь-якому випадку, компілятор, на жаль, не є читачем думок. Він бачить функцію та її вхідні дані, і з огляду на інформацію, якою вона володіє, йому потрібна ця returnзаява внизу, як у вас є.

Чи погана практика вкладати додатковий оператор return в кінці лише для задоволення синтаксису та уникнення помилок компіляції (з коментарем, який пояснює, що це не буде досягнуто), чи є кращий спосіб кодувати щось подібне, щоб додаткові оператор повернення непотрібний?

Навпаки, я б порадив, що вдалою практикою є уникати будь-яких попереджень компілятора, наприклад, навіть якщо це коштує іншого рядка коду. Не переживайте занадто багато про кількість ліній тут. Встановіть надійність функції шляхом тестування, а потім рухайтесь далі. Просто роблячи вигляд, що ви можете пропустити returnтвердження, уявіть, що через рік повернетесь до цього коду, а потім спробуйте вирішити, чи returnне призведе це твердження внизу більше плутанини, ніж якийсь коментар із деталізацією деталей, чому його було опущено через припущення, що ви можете зробити про вхідні параметри. Швидше за все, із returnзаявою буде легше впоратися.

Сказано, особливо про цю частину:

try {
    return a.clone();
} catch (CloneNotSupportedException e) {
   e.printStackTrace();
}
...
//cant be reached, in for syntax
return null;

Думаю, тут є щось дивне із мисленням щодо обробки винятків. Зазвичай ви хочете проковтнути винятки на сайті, де у вас є щось значуще, що ви можете зробити у відповідь.

Ви можете сприймати try/catchмеханізм транзакцій. tryроблячи ці зміни, якщо вони не вдаються, і ми переходимо до catchблоку, робимо це (все, що є в catchблоці) у відповідь як частину процесу відкоту та відновлення.

У цьому випадку просто надрукувати стек-трас, а потім змусити його повернути null - це не зовсім спосіб мислення транзакції / відновлення. Код передає відповідальність за обробку помилок усьому коду, що викликає, getCloneщоб вручну перевірити наявність помилок. Можливо, ви віддаєте перевагу зловити CloneNotSupportedExceptionта перекласти його в іншу, більш значущу форму винятку і кинути це, але ви не хочете просто проковтнути виняток і повернути нуль у цьому випадку, оскільки це не схоже на сайт для відновлення транзакцій.

У кінцевому підсумку ви випустите обов'язки перед абонентами, щоб перевірити вручну та впоратися з несправністю таким чином, коли створення виключення дозволить уникнути цього.

Це як якщо ви завантажуєте файл, це транзакція високого рівня. Можливо, у вас try/catchтам є. Під час tryingзавантаження файлу ви можете клонувати об'єкти. Якщо в цій операції високого рівня (завантаження файлу) де-небудь є збій, зазвичай потрібно повернути винятки до цього try/catchблоку транзакцій найвищого рівня, щоб ви могли елегантно відновитись після помилки під час завантаження файлу (чи це через помилку в клонуванні або щось інше). Тому ми, як правило, не хочемо просто проковтнути виняток у такому деталізованому місці, як це, а потім повернути нуль, наприклад, оскільки це переможе велику частину значення та мети винятків. Натомість ми хочемо поширювати винятки аж до веб-сайту, де ми можемо суттєво з цим боротися.

Ваш приклад не ідеально ілюструє ваше запитання, як зазначено в останньому абзаці:

Чи погана практика вкладати додатковий оператор return в кінці лише для задоволення синтаксису та уникнення помилок компіляції (з коментарем, який пояснює, що це не буде досягнуто), чи є кращий спосіб кодувати щось подібне, щоб додаткові оператор повернення непотрібний?

Кращим прикладом може бути реалізація самого клону:

 public class A implements Cloneable {
      public Object clone() {
           try {
               return super.clone() ;
           } catch (CloneNotSupportedException e) {
               throw new InternalError(e) ; // vm bug.
           }
      }
 }

Тут речення catch ніколи не слід вводити. Проте синтаксис або вимагає кинути щось, або повернути значення. Оскільки повернення чогось не має сенсу, символ an InternalErrorвикористовується для позначення важкого стану ВМ.