静态类和静态方法、接口和抽象类、内部类、单子设计模式

领卓教育培训第八天

静态类和静态方法

static关键字

static可以修饰类共有的变量，方法和嵌套类。

static声明的属性和方法与整个类相关，而与类的任何实例无关，因此静态成员经常称为类成员，例如类属性和类方法。

静态的变量和方法可以通过类名.属性名和类名.方法名()直接调用，不需要new一个实例。

一个类的静态属性与方法能够被其他类共享，其数据存放在特定的内存空间中。

例如：Integer类中有parseInt(String s)这个静态方法

Integer.parseInt(String s);将字符串参数作为有符号的十进制整数进行解析

final关键字

被final修饰的类

该类不能被继承（这样可以保证类的安全）。

final类中的所有方法都默认为final。

被final修饰的方法

该方法不能被重写。

final方法无需支持动态绑定，因此效率更高。

被final修饰的变量

该变量一旦被赋值，值就不能被修改。

如果修饰全局变量，必须在声明的同时赋初始值。

如果修饰局部变量，可以先声明再赋值。

常量

常量定义语法：public static final int PORT_NUMBER=1;

常量命名规则：全部单词要大写，单词要用下划线隔开。

代码例子

建一个Person类

[code]public class Person {
    public static final int EYE_NUM=2; //常量
    private int age;
    private String name;
    public static int hands=2; //静态全局变量
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public static void run(){     //静态方法
        System.out.println("我们都会跑！");
    }
}

建一个测试类

[code]public class Test {
    public static void main(String[] args) {
        System.out.println("我们都有"+Person.hands+"双手");
        System.out.println("我们都有"+Person.EYE_NUM+"只眼");
        Person.run();
    }
}

输出结果：

接口和抽象类

接口

接口是一些方法特征的集合，但没有方法的实现，只是声明。接口中定义的方法在不同的地方被实现，可以具有不同的行为。

接口的定义语法：

[code]public interface 接口名{
    方法1；
    方法2；//方法的声明

接口的实现语法：

[code]public class 类名 implements 接口名{
    方法1{}
    方法2{} //方法的实现

接口的实例化

[code]接口名 对象名 = new 类名(实现该接口的类)();
对象名.方法名();  //调用接口声明的方法

代码例子

[code]//创建Fly接口
public interface Fly {
    public void fly();
}

//创建Load接口
public interface Load {
    public void load();
}

//创建Plane类实现两个接口
public class Plane implements Fly,Load{
    @Override
    public void load() {
        System.out.println("我能运货");     
    }
    @Override
    public void fly() {
        System.out.println("我能飞");      
    }
}

//创建Apache类继承Plane类
public class Apache extends Plane{
}

//创建Test类
public class Test {
    public static void main(String[] args) {
        Apache apache = new Apache();
        apache.fly();
        apache.load();
    }
}

运行结果：

面向接口编程

我需要一个人去按要求打印东西

①首先需要打印机，墨盒墨水，纸张：

[code]//创建Print接口
public interface Print {
    public void print(Ink a,Paper b);
}

//创建HPPrint类实现Print接口
public class HPPrint implements Print{
    @Override
    public void print(Ink a, Paper b) {
        System.out.println("我是惠普打印机，我用的墨盒颜色是："+a.getColor()+"  我用的纸张尺寸是："+b.getSize());     
    }
}

//创建EpsonPrint类实现Print接口
public class EpsonPrint implements Print{
    @Override
    public void print(Ink a, Paper b) {
        System.out.println("我是爱普生打印机，我用的墨盒颜色是："+a.getColor()+"  我用的纸张尺寸是："+b.getSize());        
    }
}

//创建Ink接口
public interface Ink {
    public String getColor();
}

//创建BeijingInk类实现Ink接口
public class BeijingInk implements Ink{
    @Override
    public String getColor() {
        return "北京彩色";      
    }
}

//创建ShangHaiInk类实现Ink接口
public class ShangHaiInk implements Ink{
    @Override
    public String getColor() {
        return "上海黑白";
    }
}

//创建Paper接口
public interface Paper {
    public String getSize();
}

//创建ChenGuangPaper类实现Paper接口
public class ChenGuangPaper implements Paper{
    @Override
    public String getSize() {
        return "晨光A4";
    }
}

//创建OrherPaper类实现Paper接口
public class OrherPaper implements Paper{
    @Override
    public String getSize() {
        return "其他A6";
    }
}

②准备好上述三样东西以后，就需要一个人来拿着这三样东西去打印

[code]//创建Person类
public class Person {
    public Print cratePrint(){//得到打印机的方法
        Print print = new HPPrint();
        return print;
    }
    public Ink crateInk(){//得到墨水的方法
        Ink ink = new BeijingInk();
        return ink;
    }
    public Paper cratePaper(){//得到纸张的方法
        Paper paper = new ChenGuangPaper();
        return paper;
    }
    public void print(){
        Print print=cratePrint();
        Ink ink=crateInk();
        Paper paper=cratePaper();
        print.print(ink, paper);    
    }
}

③开始打印

[code]//创建Test类
public class Test {//面向借口编程
    public static void main(String[] args) {
        Person zhangsan = new Person();
        zhangsan.print();
    }
}

抽象类

抽象类的定义

使用abstract关键字定义一个抽象类

[code]public abstract class Person{//定义抽象类
    public abstract void sayHi();//声明抽象方法
}

抽象类在实例化时，要new它的子类，不能new本身。所以说抽象类是一个未定义完整的类，其中的抽象方法要延迟到子类中去实现。

一个抽象类可以没有抽象方法，也可以有多个抽象方法，但如果没有抽象方法，则给抽象类无意义。

一个普通类中不允许有抽象方法。有抽象方法，该类必须为抽象类。

如果抽象类的子类没有实现抽象类中的抽象方法，那么该子类必须为抽象类。同样的，如果接口的实现类没有实现给接口中声明的方法，则该实现类也必须定义为抽象类。

代码例子

[code]//创建一个Person抽象类
public abstract class Person {
    public abstract void sayHi();
}

//创建Chinese类继承Person类
public class Chinese extends Person {
    @Override
    public void sayHi() {
        System.out.println("你好！");
    }
}

//创建Test类
public class Test {
    public static void main(String[] args) {
        Person p1 = new Chinese();//父类new一个子类
        p1.sayHi();
        Chinese p2 = new Chinese();//子类new一个子类
        p2.sayHi();

        Person p3 = new Person() { //匿名内部类          
            @Override
            public void sayHi() {
                System.out.println("Hello!");               
            }
        };
        p3.sayHi();     
    }
}

运行结果：

多态

Open-Close原则

当我们一个软件的需求发生改变时，我们能够以添加新的代码的方式，而不是修改原来的代码的方式来适应需求的改变，如果能做到这一点，我们就讲，这种设计满足Open-Close原则。

多态的本质

①父类的引用指向了自己的子类对象②必须是类与类之间只有关系，要么继承或实现接口③存在方法的重写

内部类

内部类

在一个类的内部又创建了一个类

[code]public class ClassA {
    private int a=1;
    public void testA(){
        System.out.println("外部类的方法");
    }
    class ClassAChild{ //内部类
        private int a=2;
        public void testAChild(){
            testA();//内部类直接调用外部类的方法
            System.out.println("内部类的方法"+"  外部类的属性a="+a);//调用外部类的属性a
        }
    }   
}

//创建Test类
import lz20150721.d5.ClassA.ClassAChild;
public class Test {
    public static void main(String[] args) {
        //内部类的实例化
        ClassAChild classAChild=new ClassA().new ClassAChild();
        classAChild.testAChild();//调用内部类的方法
    }
}

运行结果：

局部内部类

[code]public class ClassA {
    private int a;
    public void testA(){
        class ClassB{
            private int b;
            public void testB(){//定义局部内部类
                System.out.println("局部内部类的方法");
            }
        }
        ClassB classB= new ClassB();
        classB.testB();
    }
}

//创建Test类
public class Test {
    public static void main(String[] args) {
        ClassA classA = new ClassA();
        classA.testA();     
    }
}

运行结果：

匿名内部类

匿名内部类适合创建那种只需要一次使用的类。

定义匿名类不需要class关键字，而是在定义匿名内部类时直接生成该匿名内部类的对象。

最常用的创建匿名内部类的方式是需要创建某个接口类型的对象。

例如：

[code]//创建IA接口
public interface IA {
    public void func();
}
//创建Test类
public class Test {
    public static void main(String[] args) {
        IA a = new IA() {//匿名内部类        
            @Override
            public void func() {
                System.out.println("匿名内部类");                
            }
        };
        a.func();
    }
}

运行结果：

单子设计模式

创建方法

需求只创建一个对象，即可用单子设计模式

1. 隐藏系统的无参构造方法——>private

2. 创建一个静态的得到对象的方法。

3. 创建一个静态的本类的对象。

4. 在静态方法中添加判断语句。

代码实现

[code]//创建Student类
public class Student {//单子设计模式
    private static Student instance;//第三步
    private Student(){//第一步

    }
    public static Student getInstance(){//第二步
        if(instance ==null){//第四步
            instance = new Student();
        }
        return instance;
    }
}

//创建Test类
public class Test {
    public static void main(String[] args) {
        Student zhangsan = Student.getInstance();
        Student lisi = Student.getInstance();
        System.out.println(zhangsan);
        System.out.println(lisi);
    }
}

运行结果：



结果显示两个对象指向的地址相同，说明只创建了一个对象。

简单工厂设计模式