黑马程序员 + 在学习中遇到的一些问题2

------- android培训、java培训、期待与您交流！ ----------

7、关于内部类的总结：

内部类的访问规则：(内部类与外部类的互访)

1，内部类可以直接访问外部类中的成员，包括私有。

这是因为内部类中持有一个外部类的引用，格式：外部类名.this

2，外部类要访问内部类，必须建立内部类对象。

访问格式：

1，当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中直接建立内部类对象。（面试，了解）

格式：

外部类名.内部类名  变量名 = 外部类对象.内部类对象;

Outer.Inner in = new Outer().new Inner();

在外部其他类中，如何直接访问static内部类的非静态成员呢？ static的类名调用

new Outer.Inner().function();     

在外部其他类中，如何直接访问static内部类的静态成员呢？

Outer.Inner.function();

2，当内部类在成员位置上，就可以被成员修饰符所修饰。比如：

private：将内部类在外部类中进行封装。

static：内部类只能直接访问外部类中的static成员，出现了访问局限。

注意：

当内部类中定义了静态成员，该内部类必须是static的。

当外部类中的静态方法访问内部类时，内部类也必须是static的。

内部类定义在局部时：

1，不可以被成员修饰符private和static修饰，只有成员内部类可以。

2，可以直接访问外部类中的成员，因为还持有外部类中的引用。但是不可以访问它所在的局部中的变量，只能访问被final修饰的局部变量。

9、关于匿名内部类的总结：

1，匿名内部类其实就是内部类的简写格式。

2，定义匿名内部类的前提：内部类必须是继承一个类或者实现接口。

3，匿名内部类的格式：  new 父类或者接口(){定义子类的内容}

4，其实匿名内部类就是一个匿名子类对象，可以理解为带内容的对象。

5，匿名内部类中定义的方法最好不要超过3个。

匿名内部类的应用：

interface Inter
{
	void method();
}

class Test 
{
	//匿名内部类。
	static Inter function()
	{
		return new Inter()
		{
			public void method()
			{
				System.out.println("method run");
			}
		};
	}
}

class InnerClassTest 
{
	public static void main(String[] args) 
	{
		Test.function().method();
/*
分析：
		上面的语句可以解析为：
		Inter in = Test.function();
		in.method();

		Test.function():Test类中有一个静态的方法function。
		.method():function这个方法运算后的结果是一个对象，而且是一个Inter类型的对象。
		因为只有是Inter类型的对象，才可以调用method方法。
*/
}

10、Throwable体系中Error和Exception的区别？

异常体系：Throwable

                |--Error

                |--Exception

                        |--RuntimeException

Error：称为错误，由JVM生成并抛出，包括动态链接失败、虚拟机错误等，程序不会对其进行处理。

Exception：所有异常类的父类，其子类对应了各种各应可能出现的异常事件，一般需要用户显式的声明或捕获。

异常有两种：

编译时被检测异常：该异常在编译时，如果没有处理(没有抛也没有try)，编译失败。该异常被标识，代表可以被处理。

运行时异常(编译时不检测) RuntimeException：在编译时，不需要处理，编译器不检查。该异常的发生，建议不处理，让程序停止。需要对代码进行修正。

11、throw和throws的区别：

throw定义在函数内，用于抛出异常对象。

throws定义在函数上，用于抛出异常类，可以抛出多个用逗号隔开。

关于异常的三个概念：

一、声明异常：用在方法声明后的小括号与大括号之间，用关键词throws ，就是在声明这个方法里可能会出现异常，调用者必须做出处理才可以通过编译。

二、抛出异常： 用在方法声明后的小括号与大括号之间，用关键词throws ，就是对方法内出现的异常自己不处理，而是递给调用者。

三、抛异常：用在方法内，用关键字throw，就是程序员自己手动抛一个异常，可以是自定义的也可以是系统定义的。

其实声明异常和抛出异常是一回事，只不过是不同时期的不同叫法：声明异常是用在写代码时，抛出异常用在运行的时候。因为在写代码的时候，程序都没开始运行，怎么能抛异常呢，因此给throws又起了一个名称叫声明异常。

12、关于线程的总结：

创建线程的两种方式：

第一种方式：继承Thread类。

第二种方式：实现Runable接口。

实现方式(Runnable接口)和继承方式(Thread类)有什么区别呢？

实现方式好处：避免了单继承的局限性。在定义线程时，建议使用实现方式。

两种方式的区别：

继承Thread：线程代码存放在Thread子类的run方法中。

实现Runnable：线程代码存放在实现了接口的子类的run方法中。

为什么要覆盖run方法呢？

因为run方法的作用是存储线程要运行的代码。

start和run方法的区别：

start方法：用于开启线程并执行该线程的run方法。

run方法：仅仅是对象调用方法。而线程创建了，并没有运行。

为什么要将Runnable接口的子类对象传递给Thread的构造函数？

因为自定义的run方法所属的对象是Runnable接口的子类对象，所以要让线程去执行指定对象的run方法，就必须明确该run方法所属的对象。

13、关于线程同步的总结：

同步的前提：

1，必须要有两个或者两个以上的线程。

2，必须是多个线程使用同一个锁。

未满足这两个条件，不能称之为同步。

如何找问题：

1，明确哪些代码是多线程运行代码。

2，明确共享数据。

3，明确多线程运行代码中哪些语句是操作共享数据的。

如何找锁：

同步函数（在函数上加上synchronized修饰符）用的锁是this，因为函数需要被对象调用。有些时候obj也可以作为锁使用。

同步函数被静态static修饰后，使用的锁是该方法所在类的字节码文件对象，类名.class。

JDK1.5 中提供了多线程升级的解决方案：

1，将synchronized 替换成了Lock接口。将隐式锁，升级成了显示锁。

2，将Object中的wait，notify，notifyAll方法都替换成了Condition的await，signal，signalAll。注意导入包：import java.util.concurrent.locks.*;

和以前不同的是：一个同步代码块具备一个锁，该锁具备自己的独立wait和notify方法。现在是将wait，notify等方法封装进一个特有的对象Condition，而一个Lock锁上可以有多个Condition对象。

14、为什么在针对某一段字符串进行操作的时候都是包含头不包含尾呢？

一般来说，这是java中的一种规定，都默认是包含头，不包含尾，以后在开发的时候，最好也要这样做。

15、为什么IO异常一定要处理？

安全是一方面，这个安全主要是指程序的鲁棒性，即不会因为一个异常而导致整个系统崩溃；还有就是为了查错，在可能出现异常的地方去捕获异常，并生成日志以便改进程序。

IO异常并非运行时异常(RuntimeException或其子类)，所以必须处理。抛出异常，只是交给方法被调用处去处理，最终还是要处理，区别只是自己处理或者交给jvm处理。

16、抽象类的应用：模版方法设计模式

在定义功能时，一部分是确定的，但是有一部分不确定，而确定的部分在使用不确定的部分，那么这时就将不确定的部分暴露出去，由该类的子类去完成。

例如：

abstract class GetTime
{
	public final void getTime()
	{
		long start = System.currentTimeMillis();
		runcode();  //不确定的部分
		long end = System.currentTimeMillis();
		System.out.println("毫秒："+(end-start));
	}
	
	public abstract void runcode();
}

class SubTime extends GetTime
{

	public void runcode()
	{
		for(int x=0; x<4000; x++)
		{
			System.out.print(x);
		}
	}
}

class  TemplateDemo
{
	public static void main(String[] args) 
	{
		SubTime gt = new SubTime();
		gt.getTime();
	}
}