java.lang.UnsupportedClassVersionError: неверный номер версии в файле класса [дубликат]

Мои 2 цента ... Я так понимаю. (Не стесняйтесь исправить меня, если я ошибаюсь)

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

Поскольку в JavaScript не имеет значения, передается ли оно по значению или по ссылке или что-то еще. Важна мутация против назначения параметров, переданных в функцию.

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

var object1 = {};
var object2 = {};

То, что мы сделали, это «назначение» ... Мы назначили 2 отдельных пустых объекта для переменных «object1» и «object2».

Теперь скажем, что нам нравится object1 лучше ... Итак, мы «назначаем» новую переменную.

var favoriteObject = object1;

Далее, по какой-то причине мы решили, что нам нравится объект 2 лучше. Итак, мы просто немного переустановили.

favoriteObject = object2;

Ничего не случилось с object1 или object2. Мы вообще ничего не изменили. Все, что мы сделали, было переназначением того, что наш любимый объект. Важно знать, что объекты object2 и favoriteObject назначаются одному и тому же объекту. Мы можем изменить этот объект с помощью любой из этих переменных.

object2.name = 'Fred';
console.log(favoriteObject.name) // logs Fred
favoriteObject.name = 'Joe';
console.log(object2.name); // logs Joe 

OK, теперь давайте посмотрим на примитивы, такие как строки, например

var string1 = 'Hello world';
var string2 = 'Goodbye world';

Опять же, мы выбираем любимую.

var favoriteString = string1;

Обе наши переменные favoriteString и string1 присваиваются «Hello world». Теперь, что, если мы хотим изменить наш любимыйString ??? Что произойдет ???

favoriteString = 'Hello everyone';
console.log(favoriteString); // Logs 'Hello everyone'
console.log(string1); // Logs 'Hello world'

Э-э ... Что случилось. Мы не можем изменить string1, изменив функцию favoriteString ... Почему? потому что строки неизменяемы, и мы не мутировали их. Все, что мы сделали, это «RE ASSIGN» favoriteString для новой строки. Это существенно отключило его от string1. В предыдущем примере, когда мы переименовали наш объект, мы ничего не назначали. (Ну, на самом деле ... мы это сделали, мы присвоили свойство name новой строке.) Вместо этого мы просто мутировали объект, который поддерживает связи между двумя переменными и базовыми объектами.

Теперь, на функции и параметры передачи .... Когда вы вызываете функцию и передаете параметр, то, что вы по существу делаете, это «назначение» новой переменной, и она работает точно так же, как если бы вы просто назначили использование равного ( =).

Возьмем эти примеры.

var myString = 'hello';

// Assign to a new variable (just like when you pass to a function)
var param1 = myString; 
param1 = 'world'; // Re assignment

console.log(myString); // logs 'hello'
console.log(param1);   // logs 'world'

Теперь то же самое, но с функцией

function myFunc(param1) {
    param1 = 'world';

    console.log(param1);   // logs 'world'
}

var myString = 'hello';
// Calls myFunc and assigns param1 to myString just like param1 = myString
myFunc(myString); 

console.log(myString); // logs 'hello'

OK, теперь давайте несколько примеров с использованием объектов вместо этого ... во-первых, без функции.

var myObject = {
    firstName: 'Joe',
    lastName: 'Smith'
};

// Assign to a new variable (just like when you pass to a function)
var otherObj = myObject;

// Let's mutate our object
otherObj.firstName = 'Sue'; // I guess Joe decided to be a girl

console.log(myObject.firstName); // Logs 'Sue'
console.log(otherObj.firstName); // Logs 'Sue'

// Now, let's reassign
otherObj = {
    firstName: 'Jack',
    lastName: 'Frost'
};

// Now, otherObj and myObject are assigned to 2 very different objects
// And mutating one object no longer mutates the other
console.log(myObject.firstName); // Logs 'Sue'
console.log(otherObj.firstName); // Logs 'Jack';

Теперь то же самое, но с вызовом функции

function myFunc(otherObj) {

    // Let's mutate our object
    otherObj.firstName = 'Sue';
    console.log(otherObj.firstName); // Logs 'Sue'

    // Now let's re-assign
    otherObj = {
        firstName: 'Jack',
        lastName: 'Frost'
    };
    console.log(otherObj.firstName); // Logs 'Jack'

    // Again, otherObj and myObject are assigned to 2 very different objects
    // And mutating one object no longer mutates the other
}

var myObject = {
    firstName: 'Joe',
    lastName: 'Smith'
};

// Calls myFunc and assigns otherObj to myObject just like otherObj = myObject
myFunc(myObject);

console.log(myObject.firstName); // Logs 'Sue', just like before

OK, если вы прочитайте весь этот пост, возможно, теперь у вас есть лучшее понимание того, как вызовы функций работают в javascript. Не имеет значения, передается ли что-то по ссылке или по значению ... Что важно, так это назначение vs mutation.

Каждый раз, когда вы передаете переменную функции, вы «назначаете» любое имя переменной параметра, как если бы вы использовали знак равенства (=).

Всегда помните, что знак равенства (=) означает назначение. Всегда помните, что передача параметра функции также означает назначение. Они одинаковы, и 2 переменные связаны точно так же.

Единственный раз, когда изменение переменной влияет на другую переменную, - это когда основной объект мутирован.

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

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

function myFunc(myString) {
    // myString is private and does not affect the outer variable
    myString = 'hello';
}

var myString = 'test';
myString = myString; // Does nothing, myString is still 'test';

myFunc(myString);
console.log(myString); // logs 'test'