类与对象以及类的继承

类与对象以及类的继承

Java是一门面向对象的语编程言。世界上有众多对象，我们把具有相同属性和方法的对象归为一个类。因此，“类”便是Java代码中的基本单位。下面是对一些名词的解释。

类
类是一个模板，用来定义多个对象共同的属性和方法。比如：学生，手机，食物……
对象
对象就是所属类的一个实例。比如：学生张三，iPhone，米饭……
属性
属性就是对象的状态数据。
方法
方法是对象的行为。

我们如何来定义一个类呢？
格式：public class 类名{
}
在大括号中间，我们定义类的属性和方法。
比如下面这个程序

public class Outman {
	public String name;
	public int blood;
	public int reduce;

	public void kill(Monster m) {
		m.blood -= reduce;

		System.out.println(name + "正在攻击" + m.name + "," + m.name + "掉血" + reduce + ",剩余血量" + m.blood);

	}

}

注意：属性一般是数据，在定义时要注意它的数据类型，以及要判断是公有属性还是私有属性，其中公有属性的定义如上图，私有属性的定义将在下面讲继承时提到；
而定义方法的格式是：
public 返回值类型 方法名(参数类型 参数名，，){ 方法体…}
与C语言中定义函数很相似。

定义好类了之后，我们就要在主函数中调用其中的属性和方法了。首先要创建对象，因为是面向对象程序设计。创建对象的格式：
类名 对象名 = new 类名();
接着我们要做的是调用属性和方法。格式如下：
调用属性：对象名.属性名 = 值; （字符串要用双引号括起来，数字类的直接写）
调用方法：对象名.方法名(实参，，);
下面举一个例子

public class Qaz {
	public static void main(String[] args) {

		Outman ou = new Outman();
		ou.name = "奥特曼";
		ou.blood = 100;
		ou.reduce = 10;

		Monster mo = new Monster();
		mo.name = "小怪兽";
		mo.blood = 100;
		mo.reduce = 5;
		
		ou.kill(mo);
	}
}

由上面这个程序我们可以发现，”Outman类”和”Monster类”具有相同三种属性，”name”,”blood”,”reduce”.这意味着，在这两个类中，我们分别定义了这三种属性。很明显，相同的代码我们写了两次，为了减少代码的冗余，我们引入“继承”的概念。
顾名思义，在人的意识里，总是子辈继承父辈。在程序设计中也可以用到这个概念，子类可以继承父类的属性和方法，并且，每个子类只能有一个父类，而父类可以拥有多个子类，这也是符合我们人类的常理的。

先来看一个例子。

程序一

public class People {
	private String name;
	private int blood;
	private int reduce;

	public void setName(String n) {
		name = n;
	}
	public void setBlood(int n){
	   blood=n;
	
	}

	
	public void setReduce(int n){
		
		reduce=n;
	}
	public String getName() {
		return name;
	}
    public int getBlood(){
    	return blood;
    	
    }
    public int getReduce(){
    	
    	return reduce;
    }
}

程序二

public class Outman extends People {
	public void kill(Monster m) {
		int a = m.getBlood();
		int b = getReduce();
		m.setBlood(a - b);

		System.out.println(
				getName() + "正在攻击" + m.getName() + "," + m.getName() + "掉血" + getReduce() + ",剩余血量" + m.getBlood());

	}
}

我们可以来分析一下这两个程序的关系。在第一个程序中，我们定义了一个“People”类，并且定义了它的属性和方法。在前面我们讲类与对象时，定义过一个”Outman“类以及它的属性”name“，”blood“，”reduce“。这三个属性和我们现在定义的”People“类的属性一样的，于是我们可以采取”继承“的方式，在定义”Outman“类时，直接将”People“的属性继承过来。
于是有了第二个程序。
在定义”Outman”类时，直接在后面添加extends People,意味着继承了”People”类。
因此，我们可以总结出子类在继承父类时，如何定义的格式。
格式：public class 子类 extends 父类{
}
通过这样的格式，我们便能使子类继承到父类的属性和方法，也就不用再重新写一遍代码了。这样的好处是什么呢？在前面讲类与对象时，我们还定义了一个”Monster”类，也具有相同的属性和方法。于是，我们可以同样的方法让“Monster”类继承“People”类，减少了再定义一次属性的时间。如下：

public class Monster extends People {

	public void kill(Outman o) {
		int m = o.getBlood();
		int n = getReduce();

		o.setBlood(m - n);

		System.out.println(
				getName() + "正在攻击" + o.getName() + "," + o.getName() + "掉血" + getReduce() + "，剩余血量" + o.getBlood());

	}

}

我们再回到刚刚的程序一，讲一讲私有属性。
在Java中，子类是无法继承父类的私有属性的，因为类具有封装性。因此，我们在定义了父类的私有属性之后，要再定义一个方法，把属性初始化，相当于把私有属性变得公有（但实际上不是公有），使子类也可以继承父类的私有属性。当然，在后面使用相关属性时，应使用已经加上前缀的属性名，而不是直接使用。
有一点要注意的是，我们在初始化私有属性时返回类型为空，也就是在之后使用这个属性时，虽然不会报错但是无法输出值的。所以我们还要定义一个能够返回值的方法。下面讲一下两种方法的定义格式。
初始化属性——定义set方法：public void set属性名(数据类型 变量名){
属性名= 变量名;
}
返回属性值——定义get方法：public String get属性名(){
return 属性名;
}

注意：第一排的属性名要大写并且和set/get连在一起

我们在进行类的继承的时候，会继承到父类方法。可是，对于不同的子类，会进行的方法是不一样，所以我们不能一成不变地继承所有。我们要根据子类的个性特点进行方法的重写。
方法重写的规则是：1.有继承关系的两个类之间 2.返回值类型，方法名，参数类型(个数，顺序)完全一样
格式：public 返回值类型 方法名(参数类型 参数名，，){ 新的方法体…}

关于自动转型和强制转型
自动转型定义是将子类对象的类型定义为父类类型，也就是说子类可以自动转换成父类。
如下程序：

public class Manage{
      public static void main(String[] args){
              Student st = new UNStudent();
              st.setName("小花")；
              st.study();
       
             System.out.println("名字："+st.getName());
   }
}

我们可以清楚的看到，在第三行中，等号前面的类是父类，而等号后面的类是子类，前后类名不统一，可是也没有报错。这就是因为，UNStudent是Student的子类，它可以自动转换成父类。自动转型，有极大的好处。
先看下面这个程序段。

java.awt.FlowLayout flow = new java.awt.FlowLayout();
		jf.setLayout(flow);

		javax.swing.ImageIcon image = new javax.swing.ImageIcon("C:\\Users\\LLY\\Pictures\\Saved Pictures\\timg.jpg");
		javax.swing.JLabel jla = new javax.swing.JLabel(image);
		java.awt.Dimension dm = new java.awt.Dimension(777, 400);
		jla.setPreferredSize(dm);
		jf.add(jla);

		javax.swing.JTextField jtf1 = new javax.swing.JTextField();
		javax.swing.JTextField jtf2 = new javax.swing.JTextField();
		java.awt.Dimension dm1 = new java.awt.Dimension(700, 40);
		// java.awt.Dimension dm2=new java.awt.Dimension(300,30);
		jtf1.setPreferredSize(dm1);
		jtf2.setPreferredSize(dm1);
		javax.swing.JLabel jla1 = new javax.swing.JLabel("账号");
		jf.add(jla1);
		jf.add(jtf1);
		javax.swing.JLabel jla2 = new javax.swing.JLabel("密码");
		jf.add(jla2);
		jf.add(jtf2);

		javax.swing.JCheckBox jcb1 = new javax.swing.JCheckBox("记住密码");
		javax.swing.JCheckBox jcb2 = new javax.swing.JCheckBox("自动登录");
		jf.add(jcb1);
		jf.add(jcb2);

我们可以看到，在这个程序段中，add方法使用了许多次，却是在不同的类的对象中使用的。通过追溯，我们发现，add方法属于Component类，而众多使用add方法的类，都是Component的子类。也就是说，它们通过自动转型，变成了父类，也就可以调用add方法，不用再重新定义一个新方法了，这节省了时间。
子类可以自动转成父类，但父类不能自动转成子类。不过，如果需要用父类调用子类特有的方法，就需要将父类强制转型成子类。
格式：子类名 子类对象=（子类名）父类对象
转型好之后就可以使用子类对象来调用子类方法了。

关于接口类
在讲接口类之前，我们先来讲讲类的类型。第一个是普通的类类型，第二个是接口类型，第三个是介于普通类和接口类之间的抽象类。由于抽象类和普通类很相似，在这里就不多加赘述了。
接下来具体说一下接口类。
和普通的类一样，接口在定义时也拥有一个关键字，不过不是class，而是interface。
于是定义的格式是这样的：public interface 类名{
}
与一般类不同的是，这里大括号里的内容有所变化。
首先会定义静态常量。格式是：public static final 数据类型 属性名=初始值；
其中，“public static final”是默认的，不管写不写，在接口类中，都默认存在。也就是说，一旦给属性赋予初始值，这个值便不能再更改，也就相当于一个常量了。
然后会定义抽象方法。格式是：public abstract 返回值类型 方法名（）；
注意：抽象方法中是没有方法体的。
一般我们使用接口通过的方法都是接口的实现。也可以说是继承接口。不过我们在继承类是使用的是extends ，而实现接口使用的是implements。并且，一个子类只能继承一个父类，但可以实现多个接口。
格式：public class 子类 extends 父类 implements 接口类，接口类，，{}

由于在接口中我们定义的都是抽象方法，所以为了使用这些方法，我们在子类实现接口时，要实现（重写）接口中的所有抽象方法。这里的重写，和上面的方法重写是一样的，这里不再赘述。

最后讲讲我在写程序的过程中，遇到的困难和问题。
1.有时候，在方法比较复杂不好直接继承的时候，可以分别写两次代码。
2.在主函数调用属性和方法时，要注意一个特殊情况，就是私有属性的调用，是通过调用方法的方式。不要弄错格式了。
3.在进行属性值的比较、输出时，要使用具有返回值的方法，也就是get方法，而不是set方法。
4.如果调用的私有属性名太长，降低了可读性，可以定义一个变量来代替。格式如下：
类型 变量名=对象.方法（）；
当然，这个方法需要有返回值。这个变量的使用规则是，可以单独进行值的比较，如果要进行值的运算，需要在初始化方法中进行，这样运算才是有效的，值才会变。

以上。