Java学习总结：类和对象，类的继承，接口/事件

1.类和对象

对象(object)：任何一个具体的事物或物体。

类(class)：对具有相同属性和方法的对象的抽象。类在使用时，需要定义类的属性和方法。同时，类名和文件名需保持相同。

举例：小明正在学习Java课程，学分增加了5 分，现在的学分是95分。

对象1 小明：属性：名字，学分；方法：学习   < --------- > 类1 Student

对象2 Java：属性：名字，学分；方法：无  < --------- > 类2 Course

首先定义Student类：

public class Student {
	//属性
	public String name;
	public int score;
	
	//方法
	public void study(Course c) {
		score += c.score;
		System.out.println(name+"正在学习"+c.name+"，学分增加了"+c.score+"分，"
				+ "现在分数是"+score+"分。");			
	}
}

接着定义Course类：

public class Course {
	//属性
	public String name;
	public int score;

    //方法：无
}

在调用类时，要先根据类创建一个对象名，用对象名来调用类里面的属性和方法。创建对象的格式：类 对象变量名 = new 类( )。

最后编写一个主程序运行：

public class Manage {
	public static void main(String[] args) {
		//创建对象名
		Student stu = new Student();
		stu.name = "小明";
		stu.score = 90;
		
		Course c = new Course();
		c.name = "Java";
		c.score = 5;
		
		stu.study(c);				
	}
}

注意：在上述类的定义里用到的都是public权限。如果使用private，则需要额外在类里编写方法访问该私有属性。

//类1 Student
public class Student {
	//属性
	private String name;
	private int score;
	
    //访问私有属性方法
	public void setName(String n) {
		name = n;
	}
	public void setScore(int s) {
		score = s;
	}
	public String getName() {
		return name;
	}
	public int getScore() {
		return score;
	}

	//方法
	public void study(Course cp) {
		score = getScore() + cp.getScore();
		System.out.println(getName()+"正在学习"+cp.getName()+
				"课程，学分增加了"+cp.getScore()+
				"分，现在的分数是"+score+"。");
	}		
}

//类2 Course
public class Course {
	//属性
	private String name;
	private int score;
	
    //访问私有属性方法
	public void setName(String n) {
		name = n;
	}
	public void setScore(int s) {
		score = s;
	}
	public String getName() {
		return name;
	}
	public int getScore() {
		return score;
	}
}

//主程序
public class Manage {
	public static void main(String[] args) {
		//创建对象
		Student stu = new Student();
		stu.setName("芦振");
		stu.setScore(90);
		
		Course c = new Course();
		c.setName("Java");
		c.setScore(5);
		
		stu.study(c);	
	}
}

2.类的继承

继承：生活中存在包含所属关系的事物。比如：爷爷-->爸爸-->孙子

类的继承规则：(1) 子类(派生类)和父类(基类，超类)必须有相同的属性和方法名。

                         (2) 一个子类只能继承一个父类。一般调用格式： public class 子类 extends 父类 ( implements 接口1，接口2，...){ }。

                         (3) 子类会继承父类中的所有属性和方法,但私有属性和方法不能直接使用。

                         (4) 子类可以重写(overwrite)父类中的方法，但必须和父类中的方法同名同参。重写后，调用时调用子类的方法；未重写则直接调用父类中的方法。

                         (5) 子类会继承父类中的所有属性和方法,但私有属性和方法不能直接使用(setName( ),getName( )...)。

类的继承作用：多态，即同一类型的对象可以具有不同的行为，增加了程序的灵活性。

//定义父类：Student
public class Student {

	private String name;
	
	//方法
	public void setName(String n) {
		this.name = n;   //super表示当前类的父类对象; this表示本类对象
	}
	public String getName() {
		return name;
	}
	public void study() {
		System.out.println(name+"正在学习！");
	}

}

//定义子类：UNStudent
public class UNStudent extends Student {

	//定义自己的方法
	public void printname() {
		System.out.println("名字是"+getName());
	}
		
	//方法重写
	//作用于有继承关系的两个类之间   
	//(子类的访问修饰符大于等于父类)返回值类型,方法名,参数类型(个数,顺序)完全一样
	public void study() {
		System.out.println("子类重写父类的学习方法!");
	}

}

//定义子类:Teacher
public class Teacher extends Student{
    
    //方法里面传递的参数的是父类Student的对象s
	public void teach(Student s) {
		s.study();
	}

}

//主程序
public class Manage {

	public static void main(String[] args) {
		
		//自动转型(向上转型)
		Student un = new UNStudent();  //注意左边是父类+对象名
		un.setName("小明");
		un.study();
		//un.printname()不能被执行，因为Student类里面没有printname()方法。此时要用到强制转型
		
		//强制转型(向下转型):只能子类强制转型
		UNStudent unst = (UNStudent) un;
		unst.printname();
		
        //使用Teacher子类
		Teacher te = new Teacher();
		te.teach(un);		
	}

}

注意：(1) 自动转型：只能调用父类和子类同时定义的方法。

                un.printname()不能被执行，因为Student类里面没有printname()方法。此时要用到强制转型

           (2) 强制转型：只能将子类强制转型。此处格式：子类 对象名1 = （想转化的类） 对象名2

           (3) 子类的访问修饰符必须大于父类；访问修饰符权限大小关系：public > default(缺省) > protected > private。

访问权限	同一类内	同一包内	子类	任何地方
private	√
protected	√	√
default	√	√	√
public	√	√	√	√

 

3.接口/事件

接口（interface）是一种特殊的类，只有方法名没有方法体。事件是接口里面方法的参数，也是一种类。

接口是子类的父类，其子类可以自动转型为实现的接口类。同时子类可以继承多个接口。一般调用格式： public interface 子类 implements 接口1，接口2，...{}

接口中定义的方法是虚拟方法，子类继承以后必须实现（implement）接口中的方法。

//定义一个接口类
public interface Person{

    //接口没有属性，只有虚拟的方法，并且没有方法体。
    public void friend(String name);
    public void study(int hour);

}

//实现接口类，重写接口中的方法
public class Student implements Person{

    private String name;
    private int score;

    public Student(String n){
        this.name = n;
    }

    //实现接口中的friend方法:方法体可以空，但是必须方法必须出现在这里。
    public void friend(String name){

    }

    //实现接口中的study方法
    public void study(int hour){
        score = 3*hour;

    }

    //定义子类自己的方法
    public void show(){
        System.out.println(name + "得分" + score);
    }
}

//主程序
public class Manage {

	public static void main(String[] args){

	    Student stu = new Student("小明");
	    stu.study(5);
	    stu.show();
	}

}