Объект refrence and type casting in java

Question

class A{ 
    int foo=10; 
} 
class B extends A{ 
    int foo=10; 
} 
class Test{ 
    public static void main(String [] args){ 
     A a=new B(); 
     System.out.println(a.foo); 
     //System.out.println(a.getClass()); 
    } 
} 

В этом случае выводится 10. Если я не ошибаюсь, это связано с тем, что переменная a имеет тип A, а назначение переменной - статическое связывание, а статическое связывание выполняется во время компиляции, просматривая тип переменной. Так как здесь a имеет тип A, то вызывается int foo. Однако, когда я называю

System.out.println(a.getClass()); 

, то это дает класс B, то есть a имеет тип B. Я смущен этим. Пожалуйста, объясните мне a, какой тип и как напечатан int foo. Но, посмотрев на этот код

class A{} 

class B extends A{} 

class Test{ 
    public static void main(String [] args){ 
     B b=new B(); 
     A a=b; 
     B b1=(B)a; // compiles and run fine (a is of type B) 
    } 
} 

Как это возможно? Что тут происходит? Первый b имеет тип B, затем во второй строке a становится типа A, так как A a=.. написано, но a.getClass() указывает, что он имеет тип B. Как? Если a имеет тип B, то почему он вызывает int foo в первом примере? Пожалуйста, объясните оба примера.

Кроме того, действительно ли ссылки на изменение кастинга или какие-либо другие вещи?

Answer 1

Важно, что Java имеет только примитивные и ссылочные типы переменных. Это означает, что когда вы пишете

A a = 

a это просто ссылка на объект (или нуль) не является объектом.

Когда вы

A a = new B(); 

нет литая здесь, ни одна работа не будет сделано, ни один объект не был нанесен вред или изменен.

Когда вы вызываете метод экземпляра в классе, он вызывает метод для класса объекта.

Object o = new B(); 
assert o.getClass() == B.class; 

длиннее пример

B b = new B(); 
A a = b; 
assert a == b; // always true as they point to the same object. 
assert b.getClass() == B.class; 
// so it makes sense that since a == b 
assert a.getClass() == B.class; 

ссылка изменения отливки типа или делать какие-либо другие вещи?

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

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

B b = новый B(); A x = b; B b1 = (B) x; // компилируется и выполняется нормально (х типа б) в этой строке, когда х имеет тип

правильно, и вы не смогли бы (B)x исключением случаев, когда x была ссылка на B переменных x является A, что означает, что он должен указывать на объект A или подкласс класса A, например B вы можете написать

B b = new B(); 
A x = b; 
assert x == b; // they still point to the same object. 
B b1 = (B) x; 
assert b1 == b; // same object 
assert x == b1; // same object. 

Нет новых объектов не создаются, ни объект изменился.

Answer 2

Довольно просто, почему он печатает foo из A, поскольку a определяется как A. Поскольку для переменных нет переопределения, вы просто присоединяетесь к переменным, которые доступны для типа, объявленного переменной, который в этом случае равен A.

public static void main(String[] args) { 
    A a = new A(); 
    System.out.println(a.foo); // prints the foo of A, since a is of the type A 
    A b = new B(); 
    System.out.println(b.foo); // prints the foo of A, since b is of the type A 
    B c = new B(); 
    System.out.println(c.foo); // prints the foo of B, since c is of the type B 
} 

В конце концов, это называется затенением того, что вы там делаете. У вашего класса B есть переменная с тем же именем, что и A. Так как они не Overridable вы можете скрыть foo от A, если переменная имеет тип B, где вы обращаетесь foo из B

Answer 3

Ваш вопрос связан с Javas полиморфного поведения и динамический (поздно) против статического (раннего) связывания. Доступ ко всем переменным-членам в Java осуществляется после статической привязки. Это означает, что в этом случае у вас нет полиморфизма. Методы экземпляра динамически связаны. Метод экземпляра, используемый для вызова, будет определяться классом объекта, а не ссылочным типом. Например:

public class Main { 

    static class A{ 
     String foo="A"; 

     public String getFoo() { 
      return foo; 
     } 
    } 
    static class B extends A{ 
     String foo="B"; 

     @Override 
     public String getFoo() { 
      return foo; 
     } 
    } 

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

     A a=new B(); 
     System.out.println(a.foo); // prints A 
     System.out.println(a.getFoo()); // prints B 
     System.out.println(a.getClass()); // prints Main$B 
    } 
} 

Late binding

Early Binding

Polymorphism