『壹』 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的.