Nie mogę utworzyć obiektu klasy wewnętrznej.

Cześć,

Zdefiniowałem klasę Car z klasą wew. Engine:

package logic;

public class Car
{

	private String brand;
	private Engine engine;

	public Car(String brand, Engine engine)
	{
		this.brand = brand;
		this.engine = engine;
	}

	public String getBrand()
	{
		return brand;
	}

	public void setBrand(String brand)
	{
		this.brand = brand;
	}

	public Engine getEngine()
	{
		return engine;
	}

	public void setEngine(Engine engine)
	{
		this.engine = engine;
	}

	public class Engine
	{

		private String fuelType;
		private double capaity;
		private int cylinderNumber;

		public Engine(String fuelType, double capaity, int cylinderNumber)
		{
			this.fuelType = fuelType;
			this.capaity = capaity;
			this.cylinderNumber = cylinderNumber;
		}

		public String getFuelType()
		{
			return fuelType;
		}

		public void setFuelType(String fuelType)
		{
			this.fuelType = fuelType;
		}

		public double getCapaity()
		{
			return capaity;
		}

		public void setCapaity(double capaity)
		{
			this.capaity = capaity;
		}

		public int getCylinderNumber()
		{
			return cylinderNumber;
		}

		public void setCylinderNumber(int cylinderNumber)
		{
			this.cylinderNumber = cylinderNumber;
		}

		void startEngine()
		{
			System.out.println("Starting engine.");

		}

	}
}

W metodzie main() nie mogę utworzyć obiektu klasy Engine:

package application;

import logic.Car;

public class App
{

	public static void main(String[] args)
	{

		Car car = new Car("BMW", new Engine("diesel", 2.0, 4));

	}

}

Błąd: "Engine cannot be resolved to a type"
Jak mam sie dostać w takim razie do klasy wewnętrznej?
Jej obiekty moga być tworzone tylko w klasie, która ją zawiera?

Pozdro

Car.Engine.

Hej,

Nic nie oagrniam, dalej źle:

public static void main(String[] args)
	{

		Car.Engine engine = new Car.Engine("diesel", 2.0, 4);

		Car car = new Car("BMW", engine);

	}

https://stackoverflow.com/questions/4070716/instantiating-inner-class?rq=1

Zrobiłem, to co w tym linku, ale to nic nie daje.

Klasa niestatyczna wewnętrzna ma zawsze wskaźnik na klasę otaczającą, więc klasa otaczająca musi istnieć podczas tworzenia niestatycznej klasy zewnętrznej i musi być jakoś podana do konstruktora.

Tutorial o klasach zagnieżdżonych jest tutaj: https://docs.oracle.com/javase/tutorial/java/javaOO/nested.html
Jak poczytasz to będziesz wiedział o co chodzi w przykładzie poniżej:

class Parent {
    // niestatyczna klasa wewnętrzna ma wskaźnik i bezpośredni dostęp do pól
    // klasy otaczającej więc możemy to wykorzystać
    class Child {
        Class<?> parentClass() {
            return Parent.this.getClass();
        }

        void printHelloWorld() {
            // przysłoniliśmy metodę z klasy otaczajacej więc musimy użyć
            // konstrukcji Parent.this.metoda() by się do niej dostać
            Parent.this.printHelloWorld();
        }

        void print1() {
            // jeśli jednak nie ma przysłaniania to nie musimy kombinować
            print2();
        }
    }

    private void printHelloWorld() {
        System.out.println("Hello World!");
    }

    private void print2() {
        System.out.println("printer");
    }

    static class StaticChild {
// poniższe nie skompiluje się, bo statyczna klasa nie ma wskaźnika
// do klasy otaczającej
//        Class<?> parentClass() {
//            return Parent.this.getClass();
//        }
    }

    // ta metoda nie może być statyczna, bo statyczna klasa nie ma wskaźnika
    // do klasy otaczającej
    Child makeChild() {
        return new Child();
    }

    // ale jeśli podamy parenta wprost to możemy mieć statyczną metodę
    static Child makeChild(Parent parent) {
        return parent.new Child();
    }

    static StaticChild makeStaticChild() {
        return new StaticChild();
    }
}

public class Main {
    public static void main(String[] args) {
        Parent.StaticChild staticChild = Parent.makeStaticChild();
        Parent parent = new Parent();
        parent.makeChild();
        Parent.makeStaticChild();
        Parent.makeChild(parent);
        parent.new Child();
// poniższe się nie skompiluje z powodów takich jak wcześniej
//        new Parent.Child();
        Parent.Child child = parent.makeChild();
        child.printHelloWorld();
        child.print1();
        System.out.println(child.parentClass());
    }
}

Uwaga 1: w niestatycznej klasie wewnętrznej referencja do klasy otaczającej zawsze istnieje i może być przyczyną wycieków pamięci. Wewnętrzne klasy powinny być niestatyczne tylko jeśli jest do tego konkretny powód. Domyślnie lepiej dorzucać static.

Uwaga 2: static w deklaracjach klas nie jest tym samym co static w deklaracjach zmiennych czy metod. To chyba zresztą oczywiste :]

Dzięki, zajmę się tym, ale najpierw z rok odpocznę, bo już nie mam sił.