njlr

int main() {
  
  A* x = new A();
  B* y = new B();
  A* z = y;
 
  std::cout << "x->what() = " << x->what() << std::endl;
  std::cout << "y->what() = " << y->what() << std::endl;
  std::cout << "z->what() = " << z->what() << std::endl;
 

njlr

x.what() = A
y.what() = B
z.what() = A

njlr

int main() {
  
  A x;
  B y;
  A z = y;
 
  std::cout << "x.what() = " << x.what() << std::endl;
  std::cout << "y.what() = " << y.what() << std::endl;
  std::cout << "z.what() = " << z.what() << std::endl;
 

njlr

struct A {
  virtual std::string what() {
    return "A";
  }
};

struct B : public A {
  std::string what() override {
    return "B";
  }

njlr

Person const person = { "John", "Smith" };

person.firstName = "Bob"; // Will not compile!

njlr

struct Person {
  std::string firstName; // No need for const here! 
  std::string lastName;
};

njlr

final Person person = new Person("John", "Smith");

person.firstName = "Bob"; // Will not compile!

njlr

public final class Person {
  
  public final String firstName;
  public final String lastName;
 
  public Person(String firstName, String lastName) {
    this.firstName = firstName;
    this.lastName = lastName;
  }
}

njlr

final List<String> xs = new ArrayList<>();

// We can modify xs internally
xs.add("a");
xs.add("b");
xs.add("c");

// ... but we cannot change where it points to!
xs = new ArrayList<>(); // Will not compile

njlr

int f() {
  Foo foo;
  return foo.bar(); // foo automatically destroyed
}