大学笔记-java面向对象工程

java类 对象与方法的定义

java语言中的类，对象，对应着客观存在着的一种事物，
例：类-狗
对象-一只狗
属性-狗的品种，名字，出生地等等；
方法-狗的行为，撒尿，

定义一个类

public class name(){
int t;
int x;
int s;//相当于类的属性
}

定义一个方法

public class name(){
	//无返回值的方法
	public void method(){}
	//有返回值的方法
	public 返回值数据类型 method(){
	return 返回值（返回数据）；
	}
	//参数方法
	public String method(参数类型 参数名，参数类型 参数名){
	return 返回值；//相当于定义变量，变量的值由调用时赋予；
	}
	//调用参数方法
	public static void main(String[] args){
		name un=new name();
		un.method(参数1，参数2，参数3){
//方法内可用参数
}
	}
}

对象

局部变量、局部方法

public class method(){
	int x;//定义在类里的叫成员方法；
	void wd(){}//修饰符+返回值类型+方法名的叫局部方法
	public static void main(String[] args){
method un=new method();
un.wd;
}
}

成员变量、构造方法

public class theaver(){
public theaver(int a,int b){}//方法名和类名一样的方法叫构造方法；
void tu(){
int num;//定义在方法内的变量是成员变量，它只能在方法内使用。
}
public static void main(String[] args){
	theaver one=new theaver(int a,int b);//定义对象时调用构造方法，用参数区别不同的构造方法,一个对象只能定义一次；

}
}

构造方法的重载

public class theaver(){
public theaver(int a,int b){}//方法名和类名一样的方法叫构造方法；
public theaver(double a,double b){}
public theaver(String a,String b){}
public static void main(String[] args){
	theaver one=new theaver(int a,int b);//定义对象时调用构造方法，用参数区别不同的构造方法,一个对象只能定义一次；
theaver two=new theaver(double a,double b){}//想再次调用别的构造方法只能在定义一个对象，共同完成类的实现
theaver three=new theaver(String a,String b){}
}
}

static修饰符

static修饰符，楼主理解的意思是：
因为在内存调用中，static比普通属性要提前调用，
所以可以把static修饰的属性/方法看做楼层较高（高级别）的属性，而普通的是楼层较低（低级别）的属性。
高楼层看不到低楼层的人，相当于高级别无法引用低级别，
而低楼层可以看到高楼层的人，相当于低级别可以引用高级别。
其他方面均用此思想；

public class theaver(){
static int a=3;//一个静态的数据，叫做类数据
static void method(){//一个静态的方法，叫类方法
	System.out.println("你好，世界！");
}
public static void main(String[] args){
	theaver.a;//调用类方法与类属性与其他不同；直接用类名.属性名就行了。也可以用普通方法的办法;

}
}

java的封装性

private 加方法，变量，方法
只能在本类中被调用。
当一个变量被封装
用public 的set get方法赋值，调用它
private int a;
public void seta(int a){
	this.a=a;
}
public int geta(){
return this.a;
}
其他同理

java的继承性

例如：
类：动物
类：小狗
现实中 “小狗” 属于“动物”中的一类，有动物的一些特征，也有一些他独有的特征。
在java中，这种情况我们可以用“继承”的方式表达；

public class Animal{
	/Animal类代表动物，里面存放动物都会有的特征；
	static int a=8;//每天睡八小时
}
public class Dog extends Animal{
/Dog类表示小狗，里面存放小狗专门的属性
static int b=3;//小狗每天叫3小时

}

其中Dog称为子类，Animal称为父类。子类能调用父类的一切属性与方法，而且还可以定义同名的属性，用this. 和super.区分调用，而定义同名的方法叫做重写方法。

用类名作为数据类型，创建类属性的数组对象；

public class C {
	/**
	 * 这种 实例化C类型的数组，可以同时定义对个对象同时储存不同的数据
	 * 
	 * @param a
	 */
	 //首先把C的构造方法建立一个参数
	C(String a){
		System.out.println(a);
	}
	int roll;
	public static void main(String[] args) {
		C roll[]= {
				new C("dsf"),
				new C("sdf")
		};
		
	}
}

接口

定义一个接口

接口有继承性，可以继承多个父类接口，性质与类继承差不多

public interface 接口名 extends 父接口1，父接口2{
	//常量定义 默认用 public static final 修饰
	//方法定义 默认用  public abstract 修饰
}

插入，调用接口

public class 类名 implements 接口名1，接口名2{}

异常

所有异常的父类 Throwable
throws Exception //写在类后面
throw new Exception(“输出异常文本”);//写在代码块中
抛出一个对象

public class test {

	public static void main(String[] args) throws MyException {
		
			throw new MyException();
		
}
}

try{
}catch(Exception e){
}finally{
//一定会执行的代码
}

自定义一个异常类
覆盖掉API自带的异常Exception
更加方便

public class MyException extends Exception{
	MyException() {
		super("自定义抛出异常");
	}
}

反射

思路：用API里定义的关于Class类的一系列反射类与方法来访问
Class类中的一些方法

创建Class的对象

1.思路：创建一个Class类对象，赋予本类的对象类值；

Class c=本类.class;

2.思路：创建一个Class对象，把本类实例化，把实例化对象的数值赋给Class对象

Jiekou js=new Jiekou();
Class d=js.getClass();

3.思路：创建一个Class对象，使用Class里静态方法.forName(“包名.本类名”);给对象赋值
注意：因为可能出现找不到类的ClassNotFoundException异常，需要加入抛出异常代码

try {
Class c=Class.forName("homework4_8.Jiekou");
System.out.println(c.getConstructor());
}catch(ClassNotFoundException e){
System.out.println("jixu");
}

Class中的常用方法

访问构造方法

Class.getConstructors();//访问public修饰符的所有构造方法，返回一个数组元素
getConstructor(Class<?>...parameterTypes)//访问public修饰符指定构造方法
Class.getDeclaredConstructors();//访问所有的构造方法，不管修饰符是什么，返回一个数组元素
getDeclaredConstructor(Class<?>...parameterTypes)//访问所有修饰付的指定构造方法

用Constructor类访问构造方法的各种参数

Class c=Jiekou.class;
//给Constructor[]新建一个对象，把返回的数组元素填进去
Constructor[] cons=c.getDeclaredConstructors();
for(int i=0;i<cons.length;i++) {
//新建Constructor对象，储存之前数组
Constructor consit=cons[i];
//Constructor.isVarArgs()方法输出一个boolean值，判断该构造方法参数是否可变
System.out.println("是否是可变参数"+consit.isVarArgs());
//Class.getParameterTypes()方法 返回构造方法的参数类型 可直接打印
Class[] parameterTypes=consit.getParameterTypes();
//打印参数类型
System.out.println(parameterTypes[j]);
//.getExceptionTypes()方法 返回可能抛出的异常信息 可直接打印
Class[] exceptionTypes=consit.getExceptionTypes();
}

访问成员变量

用Field类进行访问成员变量数据
创建Field类变量

Class c=Jiekou.class;
		Field [] fields=c.getDeclaredFields();
			Field field=fields[0];

方法：
.getName() 返回变量名称
.getType() 返回变量数值类型
Field.get(j) 返回变量的值 j为引用类型的变量（实例化的对象，用非本类的对象会报错，但static静态变量不会报错）

访问方法

用Method类访问方法

Class c=Jiekou.class;
Method[] methods=c.getDeclaredMethods();
Method method=methods[];

方法：
Method.getName() //返回方法名称信息
Method.getReturnType()//返回 方法返回值类型
Method.invoke(引用类型参数，参数1，参数2.);// 执行方法，参数内第一个写本类参数，后面方法本来参数