静态类和静态方法、接口和抽象类、内部类、单子设计模式
静态类和静态方法
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类
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("我们都会跑！");
}
}建一个测试类
public class Test {
public static void main(String[] args) {
System.out.println("我们都有"+Person.hands+"双手");
System.out.println("我们都有"+Person.EYE_NUM+"只眼");
Person.run();
}
}输出结果：
接口和抽象类
接口
接口是一些方法特征的集合，但没有方法的实现，只是声明。接口中定义的方法在不同的地方被实现，可以具有不同的行为。
接口的定义语法：
public interface 接口名{
方法1；
方法2；//方法的声明接口的实现语法：
public class 类名 implements 接口名{
方法1{}
方法2{} //方法的实现接口的实例化
接口名 对象名 = new 类名(实现该接口的类)();
对象名.方法名(); //调用接口声明的方法代码例子
//创建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();
}
}运行结果：
面向接口编程
我需要一个人去按要求打印东西
①首先需要打印机，墨盒墨水，纸张：
//创建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";
}
}②准备好上述三样东西以后，就需要一个人来拿着这三样东西去打印
//创建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);
}
}③开始打印
//创建Test类
public class Test {//面向借口编程
public static void main(String[] args) {
Person zhangsan = new Person();
zhangsan.print();
}
}抽象类
抽象类的定义
使用abstract关键字定义一个抽象类
public abstract class Person{//定义抽象类
public abstract void sayHi();//声明抽象方法
}- 抽象类在实例化时，要new它的子类，不能new本身。所以说抽象类是一个未定义完整的类，其中的抽象方法要延迟到子类中去实现。
- 一个抽象类可以没有抽象方法，也可以有多个抽象方法，但如果没有抽象方法，则给抽象类无意义。
- 一个普通类中不允许有抽象方法。有抽象方法，该类必须为抽象类。
- 如果抽象类的子类没有实现抽象类中的抽象方法，那么该子类必须为抽象类。同样的，如果接口的实现类没有实现给接口中声明的方法，则该实现类也必须定义为抽象类。
代码例子
//创建一个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原则。 - 多态的本质
①父类的引用指向了自己的子类对象②必须是类与类之间只有关系，要么继承或实现接口③存在方法的重写
内部类
内部类
在一个类的内部又创建了一个类
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();//调用内部类的方法
}
}运行结果：
局部内部类
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关键字，而是在定义匿名内部类时直接生成该匿名内部类的对象。
- 最常用的创建匿名内部类的方式是需要创建某个接口类型的对象。
例如：
//创建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. 在静态方法中添加判断语句。
代码实现
//创建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);
}
}运行结果：
结果显示两个对象指向的地址相同，说明只创建了一个对象。