目录
扩展：大话设计模式(带目录完整版) or 深入浅出设计模式(中文版).pdf
abstract class 和interface 有什么区别?
接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)?
鸭嘴兽属于脊椎动物中的哺乳动物，太阳花属于植物中的种子植物，而鸭嘴兽和太阳花都属于生物。完成如下要求（共50分，每小题10分）：
Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)
Static Nested Class 和 Inner Class的不同
编一个类A，在类中定义局部类B，B中有一个常量name，有一个方法show()打印常量name。进行测试
设计公司类（Lenovo）,有一个接口类Works,里面有接口work()，下面有2个部门（开发部和销售部）,使用内部类分别实现开发部和销售部的工作。
计算器具有work方法，功能是运算，时钟同样具有work方法，功能是计时，有一个手机类Cellphone，同时需要拥有运算和计时功能，通过内部类实现多继承效果。
有一个铃声接口类Bell，有一个接口sound，有一个手机类Cellphone，具有闹钟功能alarmclock，参数是Bell类型，测试手机类的闹钟功能，通过匿名内部类作为参数，打印：懒猪起床了。
abstract 的method 是否可同时是static，是否可同时是native，是否可同时是synchronized？
是否可以从一个static方法内部发出对非static方法的调用？
谈谈final, finally, finalize的区别(后面异常中讲finally)
前言总结思维导图
Java基础知识图解
1 关键字：static
类变量 vs 实例变量内存解析
静态变量的内存解析
类方法(class method)
练习
编写一个类实现银行账户的概念，包含的属性有“帐号”、“密 码”、“存款余额”、“利率”、“最小余额”，定义封装这些 属性的方法。账号要自动生成。 编写主类，使用银行账户类，输入、输出3个储户的上述信息。 考虑：哪些属性可以设计成static属性。
单例模式
单例(Singleton)设计模式-应用场景
2 理解main方法的语法
面试题
3 类的成员之四： 代码块
4 关键字：final
面试题
5 抽象类与抽象方法
练 习
设计模式：模板方法 (TemplateMethod)
//TemplateMethodTest.java
//抽象类的应用：模板方法的设计模式
public class TemplateMethodTest {
public static void main(String[] args) {
BankTemplateMethod btm = new DrawMoney();
btm.process();
BankTemplateMethod btm2 = new ManageMoney();
btm2.process();
}
}
abstract class BankTemplateMethod {
// 具体方法
public void takeNumber() {
System.out.println("取号排队");
}
public abstract void transact(); // 办理具体的业务 //钩子方法
public void evaluate() {
System.out.println("反馈评分");
}
// 模板方法，把基本操作组合到一起，子类一般不能重写
public final void process() {
this.takeNumber();
this.transact();// 像个钩子，具体执行时，挂哪个子类，就执行哪个子类的实现代码
this.evaluate();
}
}
class DrawMoney extends BankTemplateMethod {
public void transact() {
System.out.println("我要取款！！！");
}
}
class ManageMoney extends BankTemplateMethod {
public void transact() {
System.out.println("我要理财！我这里有2000万美元!!");
}
}
练习
6 接口(interface)
概述
举例
应用举例
接口的应用：代理模式(Proxy)
//StaticProxyTest.java
public class StaticProxyTest {
public static void main(String[] args) {
Star s = new Proxy(new RealStar());
s.confer();
s.signContract();
s.bookTicket();
s.sing();
s.collectMoney();
}
}
interface Star {
void confer();// 面谈
void signContract();// 签合同
void bookTicket();// 订票
void sing();// 唱歌
void collectMoney();// 收钱
}
class RealStar implements Star {
public void confer() {
}
public void signContract() {
}
public void bookTicket() {
}
public void sing() {
System.out.println("明星：歌唱~~~");
}
public void collectMoney() {
}
}
class Proxy implements Star {
private Star real;
public Proxy(Star real) {
this.real = real;
}
public void confer() {
System.out.println("经纪人面谈");
}
public void signContract() {
System.out.println("经纪人签合同");
}
public void bookTicket() {
System.out.println("经纪人订票");
}
public void sing() {
real.sing();
}
public void collectMoney() {
System.out.println("经纪人收钱");
}
}
接口的应用：工厂模式
详见 ：拓展：工厂设计模式
接口和抽象类之间的对比
在开发中，常看到一个类不是去继承一个已经实现好的类，而是要么继承抽象类， 要么实现接口。
面试题
排错：
interface A {
int x = 0;
}
class B {
int x = 1;
}
class C extends B implements A {
public void pX() {
System.out.println(x);
}
public static void main(String[] args) {
new C().pX();
}
}
练习
练习：接口冲突的解决方式
7 类的内部成员之五： 内部类
【注意】
1. 非static的成员内部类中的成员不能声明为static的，只有在外部类或static的成员 内部类中才可声明static成员。
2. 外部类访问成员内部类的成员，需要“内部类.成员”或“内部类对象.成员”的方式
3. 成员内部类可以直接使用外部类的所有成员，包括私有的数据 4. 当想要在外部类的静态成员部分使用内部类时，可以考虑内部类声明为静态的
如何使用局部内部类
只能在声明它的方法或代码块中使用，而且是先声明后使用。除此之外的任何地方 都不能使用该类
但是它的对象可以通过外部方法的返回值返回使用，返回值类型只能是局部内部类 的父类或父接口类型
//AnonymousTest.java
interface Product{
public double getPrice();
public String getName();
}
public class AnonymousTest{
public void test(Product p){
System.out.println("购买了一个" + p.getName() + "，花掉了" + p.getPrice());
}
public static void main(String[] args) {
AnonymousTest ta = new AnonymousTest();
//调用test方法时，需要传入一个Product参数，
//此处传入其匿名实现类的实例
ta.test(new Product(){
public double getPrice(){
return 567.8;
}
public String getName(){
return "AGP显卡";
}
});
}
}
练习
判断输出结果为何？
面向对象内容总结
扩展：大话设计模式(带目录完整版) or 深入浅出设计模式(中文版).pdf
Son.java
class Father {
static {
System.out.println("11111111111");
}
{
System.out.println("22222222222");
}
public Father() {
System.out.println("33333333333");
}
}
public class Son extends Father {
static {
System.out.println("44444444444");
}
{
System.out.println("55555555555");
}
public Son() {
System.out.println("66666666666");
}
public static void main(String[] args) { // 由父及子 静态先行
System.out.println("77777777777");
System.out.println("************************");
new Son();
System.out.println("************************");
new Son();
System.out.println("************************");
new Father();
}
}ProductTest.java
public class ProductTest {
public static void main(String[] args) {
TestProduct tp = new TestProduct();
Product p = tp.getProduct();
System.out.println(p.getName());
System.out.println(p.getPrice());
// ----------------------
tp.showProduct(p);
// ------------------------
tp.showProduct(new Product() {// 创建了一个匿名类的对象。
public int getPrice() {
return 7899;
}
public String getName() {
return "iphone5s-土豪金";
}
});
}
public Product getProduct() {
// 创建了一个局部内部类的对象
// class MyProduct implements Product{
//
// @Override
// public int getPrice() {
// // TODO Auto-generated method stub
// return 3899;
// }
//
// @Override
// public String getName() {
// // TODO Auto-generated method stub
// return "ipad air";
// }
//
// }
// return new MyProduct();
return new Product() {// 创建了一个匿名内部类的对象。
public int getPrice() {
return 7899;
}
public String getName() {
return "iphone5s-土豪金";
}
};
}
public void showProduct(Product p) {
System.out.println(p.getName());
System.out.println(p.getPrice());
}
}
interface Product {
public abstract int getPrice();
public abstract String getName();
}LeafTest.java
class Root{
static{
System.out.println("Root的静态初始化块");
}
{
System.out.println("Root的普通初始化块");
}
public Root(){
System.out.println("Root的无参数的构造器");
}
}
class Mid extends Root{
static{
System.out.println("Mid的静态初始化块");
}
{
System.out.println("Mid的普通初始化块");
}
public Mid(){
System.out.println("Mid的无参数的构造器");
}
public Mid(String msg){
//通过this调用同一类中重载的构造器
this();
System.out.println("Mid的带参数构造器，其参数值："
+ msg);
}
}
class Leaf extends Mid{
static{
System.out.println("Leaf的静态初始化块");
}
{
System.out.println("Leaf的普通初始化块");
}
public Leaf(){
//通过super调用父类中有一个字符串参数的构造器
super("123");
System.out.println("Leaf的构造器");
}
}
public class LeafTest{
public static void main(String[] args){
new Leaf();
//new Leaf();
}
}
代码块的使用情境
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
import javax.sql.DataSource;
import org.apache.commons.dbcp.BasicDataSourceFactory;
import org.apache.commons.dbutils.DbUtils;
import com.atguigu.connection.DBCPTest;
import com.mchange.v2.c3p0.ComboPooledDataSource;
public class JDBCUtils {
private static DataSource dataSource = null;
static{
InputStream is = null;
try {
is = DBCPTest.class.getClassLoader().getResourceAsStream("dbcp.properties");
Properties pros = new Properties();
pros.load(is);
//调用BasicDataSourceFactory的静态方法，获取数据源。
dataSource = BasicDataSourceFactory.createDataSource(pros);
} catch (Exception e) {
e.printStackTrace();
}finally{
if(is != null){
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
//使用DBCP数据库连接池实现数据库的连接
public static Connection getConnection2() throws SQLException{
Connection conn = dataSource.getConnection();
System.out.println(conn);
return conn;
}
}章节练习题及面试题
main()方法
选择题
class Test {
public static void main(String[] args) {
String foo = args[1];
String bar = args[2];
String baz = args[3];
}
}
d:\>java Test Red Green Blue
what is the value of baz?
A. baz has value of ""
B. baz has value of null
C. baz has value of "Red"
D. baz has value of "Blue"
E. baz has value of "Green"
F. the code does not compile
G. the program throw an exception
接口
选择题
1)下面关于接口的说法中不正确的是（）。
A．接口中所有的方法都是抽象的
B．接口中所有的方法都是public访问权限
C．子接口继承父接口所用的关键字是implements
D．接口是Java中的特殊类，包含常量和抽象方法
2)Java语言接口间的继承关系是（）。
A．单继承 B．多重继承 C．不能继承 D．不一定
3)一个类实现接口的情况是（）。
A．一次可以实现多个接口 B．一次只能实现一个接口
C．不能实现接口 D．不一定
填空题
1)_____是声明接口的关键字，可以把它看成一个特殊类。接口中的数据成员默认的修饰符是_____，接口中的成员方法默认的修饰符是_____。
2)如果实现某接口的类不是abstract的抽象类，则在类的定义部分必须该接口的所有抽象方法；如果实现某接口的类是abstract的抽象类，则它可以该接口所有的方法。但是对于这个抽象类任何一个非抽象的子类而言，它们父类所实现的接口中的所有抽象方法以及自身所实现接口中的抽象方法都必须有实在的。
补全代码
interface Inter {
void show(int a, int b);
void func();
}
class Demo {
public static void main(String[] args) {
// 补足代码；调用两个函数，要求用匿名内部类
Inter in = new Inter() {
public void show(int a, int b) {
}
public void func() {
}
};
in.show(4, 5);
in.func();
}
}
abstract class 和interface 有什么区别?
答：声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法
接口（interface）是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽象的，没有一个有程序体。接口只可以定义static final成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。然后，它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口
接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)?
答案是： 接口可以继承接口。抽象类可以实现(implements)接口，
抽象类可继承实体类，但实体类必须不能是如下两种情况之一：
1，final修饰符修饰的类是不能的
2，如果此实体类有且仅有私有的构造函数也是不能的。
是否能通过编译？
interface A{
int x = 0;
}
class B{
int x =1;
}
class C extends B implements A {
public void pX(){
System.out.println(x); //super.x A.x
}
public static void main(String[] args) {
new C().pX();
}
}
答案：错误。在编译时会发生错误(错误描述不同的JVM有不同的信息，意思就是未明确的x调用，
两个x都匹配（就象在同时import java.util和java.sql两个包时直接声明Date一样）。对于父类的变量,可以用super.x来明确，
而接口的属性默认隐含为 public static final.所以可以通过A.x来明确。
//写出程序结果
interface A{}
class B implements A{
public String func(){
return "func";
}
}
class Demo{
public static void main(String[] args){
A a=new B();
System.out.println(a.func());
}
}
//编译失败：因为A接口中并未定义func方法。
编一个程序，包含以下文件
（1）Shape.java文件，在该文件中定义接口类Shape，该接口在shape包中。
属性：PI。
接口：求面积的方法area()。
（2）Circle.java文件，在该文件中定义圆类Circle，该类在circle包中，实现Shape接口类。
属性：圆半径radius。
方法：构造器；实现求面积方法area()；求周长方法perimeter()。
（3）Cylinder.java文件，在该文件中定义圆柱体类Cylinder，该类在cylinder包中，继承圆类。
属性：圆柱体高度height。
方法：构造器；求表面积方法area()；求体积方法volume()。
（4）X5_3_6.java文件，在该文件中定义主类X5_3_6，该类在默认包中，其中包含主方法main()，在主方法中创建两个圆类对象cir1和cir2，具体尺寸自己确定，并显示圆的面积和周长；再创建两个圆柱体类的对象cy1和cy2，具体尺寸自己确定，然后分别显示圆柱体cy1和cy2的底圆的面积和周长以及它们各自的体积和表面积。
【编程分析】本题主要考察接口、包、继承、封装等问题。
鸭嘴兽属于脊椎动物中的哺乳动物，太阳花属于植物中的种子植物，而鸭嘴兽和太阳花都属于生物。完成如下要求（共50分，每小题10分）：
1）设计一系列的接口来表示这些规范：生物ß动物ß脊椎动物ß哺乳动物；生物ß植物ß种子植物，并且按照箭头要求来继承；
2）生物都有呼吸方式，只有一个方法声明：void respirations();设计两个类，分别是鸭嘴兽和太阳花，分别实现生物接口的respirations方法，执行方法可以分别输出：“鸭嘴兽是动物，需要呼吸氧气”，“太阳花是植物，可以吸收二氧化碳，呼出氧气”；
3）动物接口拥有方法声明：void run(),鸭嘴兽类可以实现方法，输出信息：“鸭嘴兽只有两只脚，它可以用两只脚奔跑”
4）植物接口都有繁殖方法声明 void reproduction(),太阳花在实现reproduction方法时输出信息“太阳花可以用种子繁殖，也可以用枝条繁殖”
5)声明一个Test类作为测试，执行上述声明的所有方法；
请使用接口编码实现如下需求：乐器（Instrument）分为：钢琴(Piano)、小提琴(Violin).各种乐器的弹奏（ play ）方法各不相同。编写一个测试类InstrumentTest，要求：编写方法testPlay，对各种乐器进行弹奏测试。要依据乐器的不同，进行相应的弹奏。在main方法中创建不同的乐器对象，通过testPlay的弹奏测试方法进行测试。
按要求实现下列问题：
- 动物类Animal包含了抽象方法 abstract void shout()；
- Cat类继承了Animal，并实现方法shout，打印“猫会喵喵叫”
- Dog类继承了Animal，并实现方法shout，打印“狗会汪汪叫”
- 在测试类中实例化对象Animal a1 =new Cat(),并调用a1的shout方法
- 在测试类中实例化对象Animal a2 =new Dog(),并调用a2的shout方法
如下代码是否可以编译通过，如果可以，运行结果是什么？
interface A{
int x = 0;
}
class B{
int x = 1;
}
class C extends B implements A{
public void printX(){
System.out.println(x);
}
public static void main(String[] args) {
new C().printX();
}
}
答案：编译错误
System.out.println(x);报错，x有歧义
内部类
选择题
public class OuterClass {
private double d1 = 1.0;
//insert code here
}
You need to insert an inner class declaration at line 3. Which two inner class declarations are
valid?(Choose two.)
A. class InnerOne{
public static double methoda() {return d1;}
}
B. public class InnerOne{
static double methoda() {return d1;}
}
C. private class InnerOne{
double methoda() {return d1;}
}
D. static class InnerOne{
protected double methoda() {return d1;}
}
E. abstract class InnerOne{
public abstract double methoda();
}
说明如下：
一.静态内部类可以有静态成员，而非静态内部类则不能有静态成员。 故 A、B 错
二.静态内部类的非静态成员可以访问外部类的静态变量，而不可访问外部类的非静态变量；return d1 出错。
故 D 错
三.非静态内部类的非静态成员可以访问外部类的非静态变量。 故 C 正确
四.答案为C、E
Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)
答：匿名的内部类是没有名字的内部类。不能extends(继承) 其它类，但一个内部类可以作为一个接口，由另一个内部类实现
Static Nested Class 和 Inner Class的不同
答：Nested Class （一般是C++的说法），Inner Class (一般是JAVA的说法)。
Java内部类与C++嵌套类最大的不同就在于是否有指向外部的引用上。
注： 静态内部类（Inner Class）意味着
1创建一个static内部类的对象，不需要一个外部类对象，2不能从一个static内部类的一个对象访问一个外部类对象
写出程序结果
class TD {
int y = 6;
class Inner {
static int y = 3;
void show() {
System.out.println(y);
}
}
}
class TC {
public static void main(String[] args) {
TD.Inner ti = new TD().new Inner();
ti.show();
}
}
编译失败，非静态内部类中不可以定义静态成员。
内部类中如果定义了静态成员，该内部类必须被静态修饰。
补足代码
interface Test {
void func();
}
class Demo {
public static void main(String[] args) {
// 补足代码；(匿名内部类)
// new Demo().show(new Test() {
// public void func() {
//
// }
// });
}
void show(Test t) {
t.func();
}
}
判断题
1)内部类（可以/不可以）了解外部类
2)静态内部类用修饰。
3)外部类（可以/不可以）通过类名访问静态内部类里的静态成员（变量和方法）
4)外部类（可以/不可以）通过类名访问非静态内部类里的成员（变量和方法）
5)非静态内部类可以访问外部类的成员，也能访问外部类的成员
6)静态内部类可以访问外部类的成员，不能访问外部类的成员
7)非静态内部类（可以/不可以）用static修饰她的成员（变量和方法）
纠错体
已知有下面类的说明：
public class First {
Privateinta;
static int b = 5;
public class Contents{
publicintc;
Staticintd;
publicvoidf(){
System.out.println(a);
System.out.println(b);
}
}
staticclassTitles{
publicinte;
Staticintf;
publicvoidshow(){
System.out.println(a);
System.out.println(b);
}
}
publicvoidgetInnerClassDate(){
System.out.println(c);//
System.out.println(d);//
System.out.println(e);//
System.out.println(f);//
}
publicstaticvoidmain(String[] args) {
}
}
1)这个类定义有问题吗？如果有请找出。
2)在main方法中如何获得两个内部类的实例对象？并且访问内部类的方法，请写出代码
有一个Car类，有属性temperature（温度），车内有Air（空调），有吹风的功能flow，Air会监视车内的温度，如果温度超过40度则吹冷气。如果温度低于0度则吹暖气，如果在这之间则关掉空调。实例化具有不同温度的Car对象，调用空调的flow方法，测试空调吹的风是否正确
编一个类A，在类中定义局部类B，B中有一个常量name，有一个方法show()打印常量name。进行测试
设计公司类（Lenovo）,有一个接口类Works,里面有接口work()，下面有2个部门（开发部和销售部）,使用内部类分别实现开发部和销售部的工作。
计算器具有work方法，功能是运算，时钟同样具有work方法，功能是计时，有一个手机类Cellphone，同时需要拥有运算和计时功能，通过内部类实现多继承效果。
有一个铃声接口类Bell，有一个接口sound，有一个手机类Cellphone，具有闹钟功能alarmclock，参数是Bell类型，测试手机类的闹钟功能，通过匿名内部类作为参数，打印：懒猪起床了。
抽象类与抽象方法
abstract 的method 是否可同时是static，是否可同时是native，是否可同时是synchronized？
答：都不能
抽象类和抽象方法之间的关系
定义抽象类和抽象方法的关键字是（）。抽象类中（）（可以/不可以）有抽象方法，（）（可以/不可以）有普通方法（）（可以/不可以）有属性；一个类中定义了抽象方法，那这个类（）（必须/不必须）用abstract修饰，即抽象类。
判断题
abstract class Name {
private String name;
public abstract boolean isStupidName(String name) {}
}
这有何错误?
答案: 错。abstract method必须以分号结尾，且不带花括号。
是否可以通过编译？
abstract class Something {
private abstract String doSomething ();
}
答案: 错。abstract的methods不能以private修饰。abstract的methods就是让子类implement(实现)具体细节的，怎么可以用private把abstract method封锁起来呢? (同理，abstract method前不能加final)。
定义一个抽象类Person，有name,age,sex三个属性，创建构造函数，给这三个属性赋值，重写打印描述信息方法，打印三个属性值；这个类中有两个抽象方法work和hello；定义两个子类Teacher，Student；教师的work实现是：教书育人，hello实现是：“同学好”；学生的work实现是：认真学习，hello实现是“老师好”。
定义Shape抽象类，包含私有属性color，创建构造器为color赋值；包含计算周长的方法celPerimeter();定义子类Triangle，包含三边；定义子类Circle，包含半径radius；子类分别实现父类的计算周长功能。
简单工厂模式
叙述工厂模式的设计理念
有一个交通工具接口类Vehicles，有work接口，有Horse类和Boat类分别实现Vehicles，创建交通工具工厂类，有两个方法分别获得交通工具Horse和Boat；有Person类，有name和Vehicles属性，在构造器中赋值，实例化“唐僧”，一般情况下用Horse作为交通工具，遇到大河时用Boat作为交通工具。
有一个农场公司，专门向市场销售各类水果，主要包括下列水果：葡萄 Grape，草莓 Stuawberry，苹果 Apple；有一个Fruit接口，包含grow生长，harvest收获和plant方法，葡萄、草莓和苹果都实现了这个接口；有一个农场园丁类FruitGardener，具有采摘水果的方法getFruit(String fruitName)；这时有人来果园玩，和园丁说介绍一下你的各种水果(创建一个People类进行测试，分别通过农场园丁类得到各种水果)。
有一个显示器接口Graphoscope，具有display方法，有两个类：台式显示器和液晶显示器都实现显示器接口，有一个显示器生产厂家能够生产这两种显示器；有Computer类，具有Graphoscope属性，生产两台电脑，分别配置台式显示器和液晶显示器。
static的使用
是否可以从一个static方法内部发出对非static方法的调用？
答：不可以,如果其中包含对象的method()；不能保证对象初始化.
写一个Singleton出来
Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。
一般Singleton模式通常有几种形式:
第一种形式: 定义一个类，它的构造函数为private的，它有一个static的private的该类变量，在类初始化时实例化，通过一个public的getInstance方法获取对它的引用,继而调用其中的方法。
public class Singleton {
private Singleton(){}
//在自己内部定义自己一个实例
//注意这是private 只供内部调用
private static Singleton instance = new Singleton();
//这里提供了一个供外部访问本class的静态方法，可以直接访问
public static Singleton getInstance() {
return instance;
}
}
//第二种形式:
public class Singleton {
private static Singleton instance = null;
public static synchronized Singleton getInstance() {
//这个方法比上面有所改进，不用每次都进行生成对象，只是第一次
//使用时生成实例，提高了效率！
if (instance==null)
instance＝new Singleton();
return instance;
}
}
其他形式:
定义一个类，它的构造函数为private的，所有方法为static的。
一般认为第一种形式要更加安全些
编译是否通过？
public class Something {
public static void main(String[] args) {
Something s = new Something();
System.out.println("s.doSomething() returns " + doSomething());
}
public String doSomething() {
return "Do something ...";
}
}
看上去很完美。
答案: 错。看上去在main里call doSomething没有什么问题，毕竟两个methods都在同一个class里。
但仔细看，main是static的。static method不能直接call non-static methods。
可改成"System.out.println("s.doSomething() returns " + s.doSomething());"。
同理，static method不能访问non-static instant variable。
写出程序结果
| public class Demo { private static int j = 0; private static boolean methodB(int k) { j += k; return true; } public static void methodA(int i) { boolean b; b = i < 10 | methodB(4); b = i < 10 || methodB(8); } public static void main(String args[]) { methodA(0); System.out.println(j); } } |
final关键字
谈谈final, finally, finalize的区别(后面异常中讲finally)
答：final—修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载
finally—再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）
finalize—方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的
如下程序是否可通过编译？
public class Something {
public int addOne(final int x) {
return ++x;
}
}
这个比较明显。
答案: 错。int x被修饰成final，意味着x不能在addOne method中被修改。
如下程序是否可通过编译？
public class Something {
public static void main(String[] args) {
Other o = new Other();
new Something().addOne(o);
}
public void addOne(final Other o) {
o.i++;
}
}
class Other {
public int i;
}
和上面的很相似，都是关于final的问题，这有错吗?
答案: 正确。在addOne method中，参数o被修饰成final。如果在addOne method里我们修改了o的reference
(比如: o = new Other();)，那么如同上例这题也是错的。但这里修改的是o的member vairable
(成员变量)，而o的reference并没有改变。
是否可以通过编译？
class Something {
int i;
public void doSomething() {
System.out.println("i = " + i);
}
}
答案: 正确。输出的是"i = 0"。int i属於instant variable (实例变量，或叫成员变量)。instant variable有default value。
int的default value是0。
是否可以通过编译？
接上题
class Something {
final int i;
public void doSomething() {
System.out.println("i = " + i);
}
}
和上面一题只有一个地方不同，就是多了一个final。这难道就错了吗?
答案: 错。final int i是个final的instant variable (实例变量，或叫成员变量)。final的instant variable没有default value，必须在constructor (构造器)结束之前被赋予一个明确的值。可以修改为"final int i = 0;"。
代码块
以下代码的运行结果是？
| public class Test { static int x, y, z; static { int x = 5; x--; } static { x--; } public static void main(String[] args) { System.out.println("x=" + x); z--; method(); System.out.println("result:" + (z + y + ++z)); } public static void method() { y = z++ + ++z; } } |
答案：
x=-1
result:3
2474
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
