『壹』 java編程中沒有任何類型 abc 的外層實例可訪問問題
這是因為第二種寫法中Truck作為abc的內部類，無法直接創建
main方法應該這樣
public static void main(String[] args) {
abc a = new abc();
Truck tc=a.new Truck();
tc.setCa(10);
tc.showCa();
}
『貳』 Java外層實例
你這樣跑是沒有問題的，不過輸出結果總是為bonne jour! 0。
我想這個事例是為了讓你了解java線程
把
do{
System.out.println("bonne jour! "+i);
if(i==2&&t.isAlive()){
System.out.println("main waiting for Hello!");
t.join();
}
}while(i<=5);
這一段改為
do{
System.out.println("bonne jour! "+i);
if(i==2&&t.isAlive()){
System.out.println("main waiting for Hello!");
t.join();
}
i++;
}while(i<=5);
輸出結果為
bonne jour! 0
bonne jour! 1
bonne jour! 2
main waiting for Hello!
Hello0
Hello1
Hello2
Hello3
Hello4
Hello5
bonne jour! 3
bonne jour! 4
bonne jour! 5
當循環中i=2的時候調用t.join()進入Hello，直到運行完Hello才會繼續主線程，你可以在想調試的地方加入 System.out.println(Thread.currentThread().getName());查看當前線程名，希望對你有幫助！
『叄』 Java里什麼叫內部類什麼叫外部類
對普通類（沒有內部類的類）來說，內部類和外部類都與他無關；對有內部類的類來說，它們就是其內部類的外部類，外部類是個相對的說法，其實就是有內部類的類。
所以，要回答這個問題，只需要講解內部類是什麼：
Java中的內部類共分為四種：
靜態內部類static inner class (also called nested class)
成員內部類member inner class
局部內部類local inner class
匿名內部類anonymous inner class
靜態內部類Static Inner Class
最簡單的內部類形式。
類定義時加上static關鍵字。
不能和外部類有相同的名字。
被編譯成一個完全獨立的.class文件，名稱為OuterClass$InnerClass.class的形式。
只可以訪問外部類的靜態成員和靜態方法，包括了私有的靜態成員和方法。
生成靜態內部類對象的方式為：
OuterClass.InnerClass inner = new OuterClass.InnerClass();
示例代碼：
package com.learnjava.innerclass;
class StaticInner
{
private static int a = 4;
// 靜態內部類
public static class Inner
{
public void test()
{
// 靜態內部類可以訪問外部類的靜態成員
// 並且它只能訪問靜態的
System.out.println(a);
}
}
}
public class StaticInnerClassTest
{
public static void main(String[] args)
{
StaticInner.Inner inner = new StaticInner.Inner();
inner.test();
}
}
成員內部類Member Inner Class
成員內部類也是定義在另一個類中，但是定義時不用static修飾。
成員內部類和靜態內部類可以類比為非靜態的成員變數和靜態的成員變數。
成員內部類就像一個實例變數。
它可以訪問它的外部類的所有成員變數和方法，不管是靜態的還是非靜態的都可以。
在外部類裡面創建成員內部類的實例：
this.new Innerclass();
在外部類之外創建內部類的實例：
(new Outerclass()).new Innerclass();
在內部類里訪問外部類的成員：
Outerclass.this.member
示例代碼：
package com.learnjava.innerclass;
class MemberInner
{
private int d = 1;
private int a = 2;
// 定義一個成員內部類
public class Inner2
{
private int a = 8;
public void doSomething()
{
// 直接訪問外部類對象
System.out.println(d);
System.out.println(a);// 直接訪問a，則訪問的是內部類里的a
// 如何訪問到外部類里的a呢？
System.out.println(MemberInner.this.a);
}
}
}
public class MemberInnerClassTest
{
public static void main(String[] args)
{
// 創建成員內部類的對象
// 需要先創建外部類的實例
MemberInner.Inner2 inner = new MemberInner().new Inner2();
inner.doSomething();
}
}
局部內部類Local Inner Class
局部內部類定義在方法中，比方法的范圍還小。是內部類中最少用到的一種類型。
像局部變數一樣，不能被public, protected, private和static修飾。
只能訪問方法中定義的final類型的局部變數。
局部內部類在方法中定義，所以只能在方法中使用，即只能在方法當中生成局部內部類的實例並且調用其方法。
示例代碼：
package com.learnjava.innerclass;
class LocalInner
{
int a = 1;
public void doSomething()
{
int b = 2;
final int c = 3;
// 定義一個局部內部類
class Inner3
{
public void test()
{
System.out.println("Hello World");
System.out.println(a);
// 不可以訪問非final的局部變數
// error: Cannot refer to a non-final variable b inside an inner
// class defined in a different method
// System.out.println(b);
// 可以訪問final變數
System.out.println(c);
}
}
// 創建局部內部類的實例並調用方法
new Inner3().test();
}
}
public class LocalInnerClassTest
{
public static void main(String[] args)
{
// 創建外部類對象
LocalInner inner = new LocalInner();
// 調用外部類的方法
inner.doSomething();
}
}
匿名內部類Anonymous Inner Class
匿名內部類就是沒有名字的局部內部類，不使用關鍵字class, extends, implements, 沒有構造方法。
匿名內部類隱式地繼承了一個父類或者實現了一個介面。
匿名內部類使用得比較多，通常是作為一個方法參數。
生成的.class文件中，匿名類會生成OuterClass$1.class文件，數字根據是第幾個匿名類而類推。
示例代碼：
package com.learnjava.innerclass;
import java.util.Date;
public class AnonymouseInnerClass
{
@SuppressWarnings("deprecation")
public String getDate(Date date)
{
return date.toLocaleString();
}
public static void main(String[] args)
{
AnonymouseInnerClass test = new AnonymouseInnerClass();
// 列印日期：
String str = test.getDate(new Date());
System.out.println(str);
System.out.println("----------------");
// 使用匿名內部類
String str2 = test.getDate(new Date()
{
});// 使用了花括弧，但是不填入內容，執行結果和上面的完全一致
// 生成了一個繼承了Date類的子類的對象
System.out.println(str2);
System.out.println("----------------");
// 使用匿名內部類，並且重寫父類中的方法
String str3 = test.getDate(new Date()
{
// 重寫父類中的方法
@Override
@Deprecated
public String toLocaleString()
{
return "Hello: " + super.toLocaleString();
}
});
System.out.println(str3);
}
}
『肆』 java裡面的內部類和外部類是什麼_
外部類：
最普通的，我們平時見到的那種類，就是在一個後綴為.java的文件中，直接定義的類
內部類：
內部類，顧名思義，就是包含在外部類中的類，就叫做內部類。內部類有兩種，一種是靜態內部類，一種是非靜態內部類。
靜態內部類和非靜態內部類之間的區別主要如下：
1、內部原理的區別：
靜態內部類是屬於外部類的類成員，是一種靜態的成員，是屬於類的，就有點類似於private static Singleton instance = null；非靜態內部類，是屬於外部類的實例對象的一個實例成員,靜態類則是屬於所有外部共有的，也就是說，每個非靜態內部類，不是屬於外部類的，是屬於外部類的每一個實例的，創建非靜態內部類的實例以後，非靜態內部類實例，是必須跟一個外部類的實例進行關聯和有寄存關系的。
2、創建方式的區別：
創建靜態內部類的實例的時候，只要直接使用「外部類.內部類()」的方式，就可以，比如School.Teacher()；創建非靜態內部類的實例的時候，必須要先創建一個外部類的實例，然後通過外部類的實例，再來創建內部類的實例，new School().Teacher()
通常來說，我們一般都會為了方便，會選擇使用靜態內部類。
『伍』 java的基本類型都有哪些呢
1）整型： 使用int表示（32位，4位元組）。
2）位元組型： 使用byte表示（從-128到127之間的256個整數，單位元組）。
3）短整型： 使用short表示（16位，2位元組）。
4）長整型： 使用long表示（64位，8位元組）。
5）單精度浮點型：使用float表示。所謂浮點型，指的是小數，也叫實數，例如：1.2。
6）雙精度浮點型：使用double表示。雙精度浮點型表示的數據范圍比單精度數據類型大很多。
7）字元型： 使用char表示。所謂字元，就是單個的字元表示，例如字母a，或者中文張，外面用單引號包圍，比如 char a = 'B'; char b = '王';
8）布爾類型： 使用boolean表示，布爾類型只有兩種可能，分別為true或false。
『陸』 JAVA運行出現問題 什麼嵌套類型無法隱藏外層類型，大神們我該怎麼辦…求救…急急急
定義在其他類內部的類不可以是public，只有頂層類可以是public。
『柒』 java 外層類型是什麼概念
我用的英文版，可能你指的是enclosing type,可以打鉤勾上的那個？那個的意思是你新建的類可以是一個內部類，而包括了這個內部類的（外部）類就由enclosing type指定
『捌』 java嵌套類型無法隱藏外層類型怎麼解決
你這個介面如果是定義在別的類內部, 不能用public,只有頂層類才能是public的.