第五章 高级类的特性2

关键字static

static String country;// 类变量不用实例化，直接类名.属性名使用，是类的一部分，被所有类的实例化对象所共享，也可以叫静态变量
int age;//实例变量，只有实例化后才能使用，属于实例化对象的一部分，不能共用

如果方法与调用者无关，则这样的方法通常被声明为类方法，由于不需要创建对象就可以调用类方法，从而简化了方法的调用

public class Utils {
//判断是否为空字符串
public static boolean isEmpty(String s) {
boolean flag=false;

if(s!=null && !s.equals("") ) {
flag=true;

//多次使用，所以抽取到工作类
};
return flag;
}
}

public static void main(String[] args) {
String s ="11";

System.out.println(Utils.isEmpty(s));
}

单例设计模式

单例(Singleton)设计模式-饿汉式

/**
* 单例模式-饿汉式
* @author xrh
*
*/
public class Single {

//私有的构造,调用这个类的人不能随便new对象
private Single() {

}
//私有的Single类型的类变量
private static Single sin =new Single();

public static Single getInstance() {
return sin;
}

}

懒汉式

/**
* 单例模式-懒汉式  最开始对象是null直到第一个调用，才new一个对象，之后所有的都用这个对象
* @author xrh
*
*/
public class Single {

//私有的构造,调用这个类的人不能随便new对象
private Single() {

}
//私有的Single类型的类变量
private static Single sin =null;

public static Single getInstance() {
if (sin == null) {
sin=new Single();

}
return sin;
}

}

public static void main(String[] args) {

Single s =Single.getInstance();
Single s1 =Single.getInstance();
Single s2 =Single.getInstance();
}

单例模式，软件的运行有且只有一个实例化对象（只会new一次）
懒汉式与饿汉式的区别是什么时候去New

懒汉式是在第一次调用getInstance方法是来new对象，以后再有人调用getIntance方法直接返回第一次New好的对象

饿汉式，是在类加载之后，还没有调用就先new好一个对象，以后不论谁来调用getInstance方法，都是直接返回之前new好的对象

理解main方法

public static void main(String[] args){}
由于java虚拟机需要调用类的main()方法，所以该方法的访问权限必须是public，又因为java虚拟机在执行main()方法时不必创建对象，所以该方法必须是static的，该方法接收一个String类型的数组参数，该数组中保存执行java命令时传递给所运行的类的参数。

类的成员之四：初始化块（代码块）

对Java对象进行初始化

public class Person {
String name;
public Person() {
this.name="张三";
System.out.println("执行的是构造方法");

}
//非静态的代码块
{
System.out.println("执行的是非静态代码块");
}
}

public class Test {
public static void main(String[] args) {
new Person();
}
}   //输出：执行的是非静态代码块
//       执行的是构造方法

先执行的是代码块，后执行构造方法
静态代码块（只执行一次，非静态New一次对象运行一次）

public class Person {
String name;
static int a;
public Person() {
this.name="张三";
System.out.println("执行的是构造方法");

}
//非静态的代码块
{
System.out.println("执行的是非静态代码块");
}
//静态代码块
static{
a=1;//这里只能使用静态static修饰的属性和方法
showA();

}
public static void showA() {
System.out.println(a);
}
}

静态代码块的执行顺序先于非静态执行顺序
一般编程中，使用更多的是静态代码块，初始化类的静态属性（static属性），以及下面这种情况

public class Person {
String name;
static int a;
public Person() {
this.name="张三";
System.out.println("执行的是构造方法");

}
//非静态的代码块
{
System.out.println("执行的是非静态代码块");
}
//静态代码块
static{
a=1;//这里只能使用静态static修饰的属性和方法
showA();

}
public static void showA() {
System.out.println(a);
}

public void test() {
System.out.println("person的test方法");
}
}

public class Test {
public static void main(String[] args) {
//匿名内部类
Person p =new Person() {//一个Person的匿名子类

//现在想把name改成李四，但不想动Person的代码
{  //用代码块代替构造器
super.name="李四";
}
@Override
public void test() {
System.out.println("===");//这里可以重写test方法，构建了一个没有类名的Person的子类
}							  //也就是匿名的Person子类，这种没有类名，不能用new创建对象
//如果还要在构造器中初始化属性就没有办法了，就要用代码块初始化
};
System.out.println(p.name);
p.test();
}
}

类的成员之五：内部类

public class Test {
int i;
public int j;
private int k ;

class A{
int i;

public void set1() {
Test.this.i=1;
Test.this.j=2;
Test.this.k=3;

}

public void sset() {
this.i=5;

}

}

public void setInfo() {
new A().set1();  //外部类要用自己内部类的方法，必须先new内部类的对象
}

public void showInfo() {
System.out.println(this.i);
System.out.println(this.j);
System.out.println(this.k);
}
public static void main(String[] args) {
Test t=new Test();
t.setInfo();
t.showInfo();
}
}

内部类主要解决java不能多重继承的问题

public class Test1 {
public static void main(String[] args) {
A a=new A();
a.testB();
a.testC();
}
}
/**
* 现在类A想同时获得类B和C的方法，并重写
* 可以使用内部类变相的实现类的多重继承，可以同时继承多个类
* @author xrh
*
*/

class A{           //java不支持class A extends B,C这样写

public void testB() {
new InnerB().testB();
}
public void testC() {
new InnerC().testC();
}

private class InnerB extends B{
@Override
public void testB() {

System.out.println("这是重写之后的testB方法");
}
}
private class InnerC extends C{
@Override
public void testC() {
System.out.println("这是重写之后的testC方法");
}
}

}

class B{
public void testB() {

}
}

class C{
public void testC() {

}
}

关键字final

在Java中声明类、属性和方法时，可使用关键字final来修饰,表示“最终”
final标记的类不能被继承
final标记的方法不能被子类重写
final标记的变量(成员变量或局部变量)即称为常量，名称大写，且只能被赋值一次。多个单词用_连接。
类：public final class Test{}
方法：public final void test (){}
变量：final String NAME_1=“张三”，不能使用默认final String name;得赋值

final static String NAME_1="" //final static一起修饰变量，就叫全局常量，静态就是全局的意思？

抽象类（abstract class）

随着继承层次中一个个新子类的定义，类变得越来越具体，而父类则更一般，更通用。类的设计应该保证父类和子类能够共享特征。有时将一个父类设计得非常抽象，以至于它没有具体的实例，这样的类叫做抽象类。

动物类普遍，鸟类，狗类更具体，动物类抽象类，抽象化处理，不写具体的方法体

用abstract关键字来修饰一个类时，这个类叫做抽象类；
用abstract来修饰一个方法时，该方法叫做抽象方法

抽象类不能被实例化。抽象类是用来作为父类被继承的，抽象类的子类必须重写父类的抽象方法，并提供方法体。若没有重写全部的抽象方法，仍为抽象类。

public abstract class Animal {
public abstract void test();//没有方法体

public abstract void move();

}

class Dog extends Animal{

@Override
public void test() {
// TODO Auto-generated method stub

}

@Override
public void move() {
System.out.println("跑");

}

}
class Fish extends Animal{

@Override
public void test() {
// TODO Auto-generated method stub

}

@Override
public void move() {
System.out.println("游");

}

}

public class Test {
public static void main(String[] args) {
Dog d =new Dog();
d.move();
}
} //输出  游

练习：编写一个Employee类，声明为抽象类，包含如下三个属性：name，id，salary。提供必要的构造器和抽象方法：work()。对于Manager类来说，他既是员工，还具有奖金(bonus)的属性。请使用继承的思想，设计CommonEmployee类和Manager类，要求类中提供必要的方法进行属性访问。

public abstract class Employee {
public Employee() {

}
String name;
int ID;
double salary;//有零有整

public abstract void work();
}

class CommonEmployee extends Employee{

public void setCommonEmployeeInfo(int id,String name,double salary) {
super.ID=id;
super.name=name;
super.salary=salary;

}
public void getCommonEmployeeInfo() {
System.out.println(super.ID);
System.out.println(super.name);
System.out.println(super.salary);
}

@Override
public void work() {
System.out.println("这是一个普通员工");
}
}

class Manager extends Employee{
double bonus;
String name;
int ID;
double salary;

public void setManagerInfo(int id,String name,double salary,double bonus) {
super.ID=id;
super.name=name;
super.salary=salary;
this.bonus=bonus; //自己的属性
}
public void getMangerInfo() {
System.out.println(super.ID);
System.out.println(super.name);
System.out.println(super.salary);
System.out.println(this.bonus);
}

@Override
public void work() {

System.out.println("这是一个领导");
}

}

public class Test {
public static void main(String[] args) {
CommonEmployee co =new CommonEmployee();
co.work();
co.setCommonEmployeeInfo(123,"张三", 4445.5);
co.getCommonEmployeeInfo();
}
}

模板方法设计模式

抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式
当功能内部一部分实现是确定，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。
编写一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给其子类实现，就是一种模板模式。

public abstract class Template {
public abstract void code();

public final void getTime(){
long start = System.currentTimeMillis();
code();
long end = System.currentTimeMillis();
System.out.println("执行时间是："+(end - start));
}

}
class TestTmp  extends Template{
public void code(){
int k=0;
for(int i = 0;i<999999;i++){
k+=1;
}
}
}

public class Test {
public static void main(String[] args) {
TestTmp t =new TestTmp();
t.getTime();
}
}

接口

从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现
接口就不是类，实际类
一个类可以实现多个接口，接口也可以继承其它接口
如果有继承父类又实现接口，则先写extends，后写implements


父类需要稳定的抽象，如果父类老在改，基于这个父类的子类都受到影响。有时需要在父类增加一些方法，所以只能新建一个接口，在接口上扩展方法，需要的子类自行实现接口。



新建一个person类

public abstract class Person1 {
int age;
String name;
int sex;
public abstract void showInfo();

}

新建cooking sing接口

public interface Cooking {
void fry();  //炒菜

}

public interface Sing {
void sing();
}

新建SCTeacher继承Person类，实现两个接口

/**
* 描述一个会唱歌的厨子是老师
* @author xrh
*
*/
public class SCTeacher extends Person1 implements Cooking,Sing{
String course;

public void setInfo() {  //写完shouInfo 方法，再写一个set方法
super.age=22;
super.name="张三";
super.sex=0;

this.course="数学";
}

@Override
public void showInfo() {
System.out.println("一个会唱歌的厨子是老师的信息是");
System.out.println(super.age);
System.out.println(super.name);
System.out.println(super.sex);
System.out.println(this.course);

}
@Override
public void fry() {
System.out.println(super.name+"是一个会炒菜的");

}
@Override
public void sing() {
System.out.println(super.name+"是一个会唱歌的");

}

}

test测试

public class Test {
public static void main(String[] args) {
SCTeacher sc =new SCTeacher();
sc.setInfo();
sc.showInfo();
sc.fry();
sc.sing();
}
}

抽象类是对于一类事物的高度抽象，其中既有属性也有方法
接口是对方法的抽象，对一系列动作的抽象

工厂方法(FactoryMethod)

它通过面向对象的手法，将所要创建的具体对象的创建工作延迟到了子类，从而提供了一种扩展的策略，较好的解决了这种紧耦合的关系。

/**
* 宝马车的产品接口
* @author xrh
*
*/
public interface BMW {
//产品的信息介绍
//车的发动方式

void showInfo();
}
/**
* 构建具体的宝马车类
* @author xrh
*
*/

class BMW3 implements BMW{

@Override
public void showInfo() {
System.out.println("这是宝马3系");

}

}

class BMW7 implements BMW{

@Override
public void showInfo() {
System.out.println("这是宝马7系");

}

}

class BMW5 implements BMW{

@Override
public void showInfo() {
System.out.println("这是宝马5系");

}

}

/**
* 汽车生产工厂接口
* @author xrh
*
*/
public interface BMWFactory {
BMW productBMW();

}
/**
* 实现具体的车型的生产工厂
* @author xrh
*
*/

class BMW3Factory implements BMWFactory{
public BMW productBMW() {
System.out.println("生产宝马3系车");
return new BMW3();

}
}

class BMW5Factory implements BMWFactory{
public BMW productBMW() {
System.out.println("生产宝马5系车");
return new BMW5();

}
}

class BMW7Factory implements BMWFactory{
public BMW productBMW() {
System.out.println("生产宝马7系车");
return new BMW7();

}
}

public class Test {
public static void main(String[] args) {
//开发人员B的工作
BMW b3 =new BMW3Factory().productBMW();
b3.showInfo();

BMW b5 =new BMW5Factory().productBMW();
b5.showInfo();

BMW b7 =new BMW7Factory().productBMW();
b7.showInfo();

}
}

通过工厂把new对象给隔离，通过产品的接口可以接受不同实际产品的实现类，实例的类名的改变不影响其他合作开发人员的编程

面向对象内容总结