Java面向对象设计

类

每个类都有属性即变量，和方法。
每个类都有一个构造函数，其函数名与类名相同。构造函数是在创建类的对象后自动执行，通常用于初始化数据。
方法的调用：类的方法通过类的对象调用：对象.方法名

继承性：

• 格式： public class 类名 extends 父类名
  {
  }
  子类继承父类后，子类可以共享父类的public和protected的属性和方法。子类也可以重写父类的方法来覆盖。子类可以有自己的属性和方法

类的实例化（创建类的对象)
父类对象可以父类实例化创建
子类对象可以通过子类实例化创建，有两种方式

class J_Employee{
	public int m_workYear;
	public J_Employee() {
		m_workYear = 1;
	}
	
	public void show() {
		System.out.println("这里是父类！");
	}
}

public class J_Teacher extends J_Employee {
	public int m_classHour;	//授课时间
	
	public J_Teacher() {
		m_classHour = 96;
	}
	
	public void show() {
		System.out.println("这里是子类");
	}
	
	
	public static void main(String args[]) {
		J_Employ tom1 = new J_Employee();	//父类对象
		J_Teacher tom2 = new J_Teacher();	//子类对象
		J_Employee tom3 = new J_Teacher(); 	//子类对象
		tom1.show();
		tom2.show();
		tom3.show();
	}
}

判断对象是否属于某个类：对象名 instanceof() 类名

多态性

静态多态性：同名函数的参数类型不同或参数数目不同。
动态多态性：子类继承父类的方法后，重写同名方法会覆盖父类的方法。
子类中调用父类方法或父类属性时，通过super.方法名 来调用

包

格式：
package 包名；//现在位置的包
import 包名.*; //导入包

封装性

封装性指的是类成员的访问权限，有public，protected，default，private

访问控制模式	在同一个类内	在同一个包内	子类	所有类
公共模式：public	允许访问	允许访问	允许访问	允许访问
保护模式：protected	允许访问	允许访问	允许访问	不能
默认模式：default	允许访问	允许访问	不	不
私有模式：private	允许访问	不	不	不

抽象类与接口

抽象类是只写类的具有什么属性和方法，但方法不能进行任何运算、操作
接口内只能写抽象方法，不能写属性
interface 接口名{

}
接口的实现：
class 类名 implements 接口名

static 和 final

静态属性static：上一次运行的结果会保留下来，应用于这次计算
静态方法中只能直接访问静态属性，而非静态属性的访问需要创建实例对象后，通过对象名.属性访问
静态属性和静态方法可以通过类名.属性或类名.方法名

最终 final 修饰的属性和方法不能进行更改。

内部类

几个类进行嵌套，就出现了外部类和内部类
内部类可以进行访问外部类的属性和方法。
外部类不能内部类的东西。

内部类的实例化：
内部类的实例化要通过外部类的对象调用：

J_Test a = new J_Test();
j_Test .J_Inner b = a.new J_Inner();

匿名内部类：是只进行一次的类。
new 类名（）{

}

方法调用的值传递方式

基本数据类型值传递例程

public class J_primitive{
	public static void mb_method(int a){
		System.out.println("在 a++之前："+a);
		a++;
		System.out.println("在a++之后："+a);
	}
	public static void main(String args[]){
		int i =0;
		System.out.println("方法调用之前i:"+i);
		mb_method(i);
		System.out.println("在方法调用之后i:"+i);
	}
}

引用数据类型值传递例程(通过参数传递另一类的对象）

class J_Time{
	public int m_month = 1;
}
public class J_Referce{
	public static void mb_method(J_Time t)
	{
		System.out.println("在t.m_month++之前 t.m_month:"+t.m_month);
		t.m_month++;
		System.out.println("在t.m_month++之后 t.m_month:"+t.m_month);
	}

	public static void main(String args[ ]){
		J_Time a = new J_Time();
		System.out.println("方法调用之前a.m_month:"+a.m_month);
		mb_method(a);
		System.out.println("方法调用之后a.m_month:"+a.m_month);
}