java面向对象（static.代码块,数组,引用传递,final,继承,重载,多态,抽象类）

static

static 是一个公共属性，只需要更改一次，所有对象的值都会改变，一般由对象的最高代表（类

修改。

它可以在没有实例化对象时使用。普通代码中很少用到static。

static方法只能调用static方法、static属性，非static方法可以调用static方法，static属性。

例子

class Book{
	private String title;
	private static int count = 0;
	public Book(){
		this("notitle - " + count++);
	}
	public Book(String title){
		this.title = title;
	}
	public String getTitle(){
		return this.title;
	}
}
public class test {
	public static void main(String[] args) {
		System.out.println(new Book("java").getTitle());
		System.out.println(new Book("jsp").getTitle());
		System.out.println(new Book().getTitle());
		System.out.println(new Book().getTitle());
	}
}

代码块

  普通代码块、构造代码块（构造块比构造方法先执行）、静态代码块（static，最先执行）

class JavaDemo{
	static {
		System.out.println("静态代码块");
	}
	{
		System.out.println("构造代码块");
	}
	public JavaDemo(){
		System.out.println("构造方法");
	}
}
public class test {
	public static void main(String[] args) {
		new JavaDemo();
	}
}

数组（引用数据类型）、foreach

public class test {
	public static void main(String[] args) {
		int [] array = new int[3];
		array[0] = 11;
		array[1] = 22;
		array[2] = 33;
		
		for(int i: array){
			System.out.println(i);
		}
	}
}

可变参数 方法（int ...data）

引用传递示例应用

类关联（人和车的关系），自身关联（人与孩子），合成设计模式（电脑、主机、内存、显卡）

string类中，== 与equals，==比较的是地址，string会开辟新地址，所以不同。

 基本数据类型，==则比较的是其存储的值是否相等；

继承

子类更加具体，是父类的扩充，可以消除重复

class 子类 extends 父类

先实例化父类，再实例化子类,隐藏了 super();

只能继承一个父类，但可以嵌套，私有对象不能直接调用，可以通过public方法调用

覆写

会把父类的方法覆盖

子类权限必须>=父类权限,一般是等于。如果父类是private子类没法覆写，只是新写方法而已

属性覆盖：子类与父类属性名称相同，就近取用。

super关键字：可以调用父类的方法，super.父类方法

重载与覆写的区别：

概念、范围、限制（权限）

final关键字

final类不能有子类

final方法不能被覆写

final变量是常量且必须被赋值，static final 常量名必须全是大写

多态

方法的多态性：重载、覆写

对象的多态性：

父类->子类 自动，对象只能用父类中有的方法，实现效果是子类；

子类->父类 强制，核心是new的对象，方法写成方法（父类对象），为了方便不同子类都可以调用

class A {
	public void print() {
		System.out.println("【A】 public void print (){}");
	}
}

class B extends A {
	public void print() {
		System.out.println("【в】 public void print (){}");
	}
}

public class DtDemo {
	public static void main(String[] args) {
		//父类 -> 子类
		A a = new B();
		a.print();
		System.out.println(a instanceof B); // true
		
		//子类 -> 父类
		A a2 = new B();
		B b = (B)a2;
		b.print();
		System.out.println(b instanceof A); // true
		//错误示例 ClassCastException
		A b2 = new A();
		B b3 = (B)b2;
		b3.print();
	}
}

抽象类（继承最好只继承抽象类和接口,抽象类类似于模板（模板设计））

只声明，而未实现，要求使用abstract

所有的抽象类必须有子类

抽象类的子类必须覆写抽象类的全部抽象方法

抽象类的对象可以通过对象多态性，利用子类为其实例化

也有抽象类中本身就有子类，调用该方法只能返回提供的子类，封装性好

抽象类中可以有构造方法

对象实例化操作：类的加载、类对象的空间开辟、进行类对象中的属性初始化

(如果构造方法没有执行，那么对象中的属性一定都是其对应数据类型的默认值)

抽象类中可以没有抽象方法（仍然不可以示例）

抽象类不能用final，private，因为他必须有子类

内部抽象类可以用static,外部抽象类不能用

abstract class A{
	// {}为方法体，抽象方法不包含方法体
	public abstract void fun() ;
}
class B extends A{
	@Override //覆写
	public void fun() {
		System.out.println("hello world!");
	}
}
public class CxlDemo {
	public static void main(String[] args) {
		B b = new B();
		b.fun();
	}
}

抽象类的概念的总结

总结：

通过此程序的定义结构可以了解：

.抽象类在实际的使用过程之中会定义一些固化的模式，它只能接收几种特定的指令；

.但是每种指令的具体实现由子类负责完成，父类只做方法的约定

1. 抽象类虽然定义了子类必须要做的事，但是抽象类依然会存在有单继承局限
2. 抽象类的使用必须要通过子类进行对象实例化处理。

abstract class Action {
	public static final int EAT_FLAG = 1;
	public static final int SLEEP_FLAG = 5;
	public static final int WORK_FLAG = 10;

	public void command(int cmd) {
		switch (cmd) {
		case EAT_FLAG:
			this.eat();
			break;
		case SLEEP_FLAG:
			this.sleep();
			break;
		case WORK_FLAG:
			this.work();
			break;
		case EAT_FLAG + SLEEP_FLAG + WORK_FLAG:
			this.eat();
			this.sleep();
			this.work();
			break;
		}
	}

	public abstract void eat();

	public abstract void sleep();

	public abstract void work();
}

class Human extends Action {
	public void eat() {
		System.out.println("人吃饭需要吃熟食,干净的食物");
	}

	public void sleep() {
		System.out.println("人困了就要睡觉");
	}

	public void work() {
		System.out.println("人要努力拼搏");
	}

}

class Pig extends Action {
	public void eat() {
		System.out.println("猪用槽子吃。吃糠");
	}

	public void sleep() {
		System.out.println("猪在圈里睡");
	}

	public void work() {
	}
}

class Robot extends Action {
	public void eat() {
		System.out.println("机器人补充能量");
	}

	public void sleep() {
	}

	public void work() {
		System.out.println("机器人不停工作");
	}
}

public class CxlDemo2 {
	public static void main(String[] args) {
		fun(new Human());
		fun(new Pig());
		fun(new Robot());
	}

	public static void fun(Action action) {
		action.command(Action.EAT_FLAG + Action.SLEEP_FLAG + Action.WORK_FLAG);
	}
}