设计模式，嵌套类，抽象类，接口

1.设计模式
设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格以及解决问题的思考方式。
所谓的单态设计模式指的是：采取一定的方法保证在整个软件系统中，某个类只能存在一个对象，并且该类只提供一个取得其对象实例的方法。 
单态设计模式的实现有两种形式。
(1) 第一种形式：定义一个类，它的构造方法为private，它有一个静态的实例对象，并且此对象访问范围被设置为private，通过getInstance方法获取对此对象的引用，继而调用此对象的相关方法。
【示例15】TestSingle.java
将构造方法定义为私有的，然后通过方法将同一个对象对外公布，代码如下：
public class TestSingle{//形式一 
   private static final TestSingle onlyone=new TestSingle();
   //前面加private static final修饰后只能产生一个对象   
   private TestSingle(){
      //不能在类的外部使用new，但在类的内部可以
   }
   public static TestSingle getTestSingle(){
     return onlyone;//外面只能通过方法调用获得一个对象
   }
} 

2.嵌套类
声明在类的内部的类称之为嵌套类（nested class）
定义语法:
[public] class OuterClass{
    ...
    [public|proteceted|private] [static] class NestedClass{
        ...
    }
}
嵌套类在编译后会生成Outer$Inner.class类文件
1.成员内部类
内部类作为外部类的一个成员存在，与外部类的成员变量、成员方法并列。
注意:
在外部类创建内部类的对象语法是:
外部类.内部类 对象名称=new 外部类().new 内部类();
在内部类调用外部类的属性或方法：
1.在内部类中可以直接调用外部类的成员属性或成员方法
2.如果内部类的成员属性和外部类的成员属性一直，则需要以
外部类.this.属性名称的方式调用。
3.在内部类中如果直接使用this.属性名称表示调用的是内部类的

成员属性。

示例：

/**
成员内部类
*/
public class Test2{
String name="zhangsan";
int age=30;
public void display(){
System.out.println("外部类的方法");
}
/**
成员内部类
*/
public class InnerTest2{
String name="lisi";
int age=20;
public void display2(){
System.out.println("内部类的方法");
}
//在内部类中，可以直接访问外部类的属性和方法
public void display3(){
System.out.println("外部类的属性"+Test2.this.name+Test2.this.age);
display();
System.out.println("内部类的属性："+this.name+this.age);
}
}
public static void main(String[]args){
//通过外部类访问，内部类
Test2 t1=new Test2();
Test2.InnerTest2 t=t1.new InnerTest2();
t.display2();
t.display3();
}
}

2.局部内部类
定义在方法内部的类
注意：
只能在本方法中使用，外部类都无法访问它
局部内部类不能使用访问修饰符
它可以访问外部类的成员，也能访问本方法内用final修饰的局部变量(

但是在JDK8中也可以访问没有final修饰的局部变量).

示例：

/**
局部内部类
*/
public class Test3{
int nu2=22;
public void display(){
int age=20;
String name="zhangsan";
class InnerTest3{
int num=100;
public void test(){
System.out.println("局部内部类"+age);
}
}
InnerTest3 t=new InnerTest3();
t.test();
}
public static void main(String[]args){
Test3 t=new Test3();
t.display();
}
}

3.静态内部类

示例：

/**
静态内部类
*/
public class Test4{
String name="zhangsan";
static int age=20;
public void display(){
System.out.println("外部类普通方法");
}
public static void display2(){
System.out.println("外部类的静态方法");
}
/**
静态内部类
*/
public static class InnerTest4{
String n="ok";
static int num=100;
public void display3(){
System.out.println("内部类的普通方法");
display2();
}
public static void test(){
System.out.println("内部类的静态方法");
}
}
public static void main(String[]args){
InnerTest4.test();
InnerTest4 t=new InnerTest4();
t.display3();
}
}

3.抽象类
定义:就是说如果在一个类中，没有足够的信息去描述一个具体的事物，那么这个类
就是抽象类。比如:图形类（width,height）图形的面积周长如何计算？？？
特点:
1.抽象类中可以有构造方法。
2.抽象类不能实例化。
3.抽象类中可以有成员属性，成员方法，也可以有静态属性和静态方法，其普通类中可以存在的属性和方法，在抽象类中都可以拥有。
4.抽象类必须是abstract关键字修饰的
5.如果一个类中有一个方法是抽象的那么这个类一定是抽象类，但是抽象类中不一定有抽象方法。
6.声明抽象类的语法:
[访问修饰符] abstract class 类名{
...
}
7.抽象类的子类必须重写所有的抽象方法后才能被实例化，否则这个子类也要声明成抽象的。
8.抽象类中的静态方法，不能使抽象的。
抽象方法，语法:
[访问修饰符] abstract 返回值类型 方法名称(参数列表);
注意:抽象方法不能有方法体。

示例：

/**
抽象类 示例
*/
public class Test6{
public static void main(String[]args){
ChangShape2 shape=new ChangShape2(10,20);
shape.area();
shape.zhouChang();
}
}
/**
抽象类
*/
abstract class Shape{
int width;
int height;
public Shape(int width,int height){
this.width=width;
this.height=height;
}
//计算面积的抽象方法
public abstract void area();
//计算周长的抽象方法
public abstract void zhouChang();
public void test(){
System.out.println("抽象类中的普通方法");
}
}
//定义一个长方形
abstract class ChangShape extends Shape{
public ChangShape(int width,int height){
super(width,height);
}
//实现父类中的抽象方法
public void area(){
System.out.println("长方形的面积:"+(super.width*super.height));
}
}
class ChangShape2 extends ChangShape{
public ChangShape2(int width,int height){
super(width,height);
}
public void area(){
super.area();
}
public void zhouChang(){
System.out.println("长方形的周长:"+(super.width+super.height)*2);
super.test();
}
}

4.接口
接口就是标准，通过定义标准规范，然其它类来实现。
特点：
1.使用interface关键字声明接口，语法为:
[访问修饰符] interface 接口名称{

}
2.接口中声明的变量永远都是常量，因为编译时接口会为变量自动添加上public static final
3.接口中声明的方法，只能有方法的声明，不能有方法体，而且方法永远是public修饰的。
4.接口中没有构造方法，所以接口不能被实例化。
5.接口可以继承接口，而且可以继承多个接口，这时，需要用逗号隔开即可
通过implements实现接口，类可以实现多个接口，语法:
[访问修饰符] class 类名 implements 接口1,接口2{

}
如果一个类实现多个接口，用逗号隔开即可；不管实现多少接口，都必须把接口中的
方法实现了，否则当前类就要定义为抽象类。
接口其实是一种特殊的类，在接口的实现类中，可以直接访问接口中的常量或者用接口名称.常量名称。

实现类和接口之间存在着 "like a"像一个的关系。

示例：

/**
声明接口
*/
public class Test7{
public static void main(String[]args){
TestImpl t=new TestImpl();
t.display();
t.test();
t.test2();
}
}
interface TestInterface1{
int num=100;
//声明一个方法
public void display();
}
interface TestInterface2{
String name="zhangsan";
public void test();
}
interface TestInterface3 extends TestInterface1,TestInterface2{
String address="beijing";
public void test2();
}
//接口的实现类
class TestImpl implements TestInterface1,TestInterface2,TestInterface3{
public void display(){
System.out.println("实现了接口中的方法"+TestInterface1.num);
}
public void test(){
System.out.println(name);
}
public void test2(){
System.out.println(address);
}
}

练习题

1.定义一个手机(MobilePhone)接口，它有打电话(call())、接电话(receive())、发送短信息(sendMsg())、接收短信息(receiveMsg())的功能。
2.定义一个照相机(Camera)的接口，它有拍照(takePhoto())的功能。
3.定义一个照相手机(CameraPhone)的接口，它有手机的功能，也有照相机的功能。
4.定义一个NokiaPhone类和一个MotoPhone类，它们都是照相手机。
5.定义一个Student类，它有name、myPhone(类型为CameraPhone)两个属性；有一个带参数的构造方法(给他赋名字和手机)还有一个打电话(myCall())的方法，这个方法调用myPhone的call()方法。
6.定义一个测试类(TestInterface)类，定义一个主方法，创建一个叫“张三”的学生，他的手机是Nokia的，再创建一个叫“李四”的学生，它的手机是Moto的，分别调用它们的myCall()方法来展现多态。