类与对象 && 继承

 

以下是本人的对类与对象、继承的一些理解，如有错误之处万望谅解，如有朋友愿意指正，十分乐意，万分感谢！

 

类与对象

 

 

类与对象是学习编程的基础（大概吧），那么何为类？何为对象呢?

 

一、简介

        何为类？说到类我想先说一下何为对象，在现实生活中，对象可以用来指代你的男/女朋友，按我的理解，我认为对象就是一个个具体的个体，比如一个学生，一个篮球，一个苹果都是一个个对象，
而类呢，就是对对象的抽象，就比如我们说的分而类之的感觉，比如在这里，球类是对篮球的一个抽象，篮球属于球类，而球类也可以产生一个篮球，再如学生类，学生类可以看作一个个学生的总体，在这
个总体里我们可以找出一个个学生，也就是具体到一个学生（个体），水果类同理。
 

二、类结构
 可以看作 类 = 属性 + 方法 ； 关键词 ：calss
 public class 类名
                {      //属性
                       访问权限  变量类型  变量名
                     
                      //方法（行为）
                       访问权限   返回类型  方法名（参数类型1 参数1， 参数类型2 参数2.....）{  方法体  }；
                       /*参数可以无；
                         * 如果{}省略未写此方法为虚方法，即没有方法体*/
                 }
 三、访问权限
 

	当前类中	同一个包下	子类中	其他
public	ok	ok	ok	ok
protected	ok	ok	ok
缺省（什么也不写）	ok	ok
private	ok

四、调用属性/方法 
        1、生成一个对象(关键词new)  格式：【类名 对象名 = new 类名; 】
        2、调用属性或者是调用方法    格式：【对象.属性名;   //   对象.方法名; 】

五、例子(学生类)
 

public class Student  {
    //属性
    public String name = "bcd";
    public String sno;
   
    //方法是设置名字
    public void setName(String name1)
    {
        name = name1;
    }
    //方法,此方法的作用为输出“xxx正在学习”
    public void study()
    { 
            // 方法体
           System.out.println(name + "正在学习。");
     }
    //主方法
    public static void main(String[] args){
      //类实例化，生成一个对象学生
       String name = "abc";
       Student stu = new Student();
       
       stu.setName(name);
       stu.study();
       
       Bread1 bread = new Bread1();
       bread.type = "盼盼"; //引用属性的时候一定要给属性赋值
       System.out.println(bread.type);
       
   }
}

class Bread1 {
       public String type = "盼盼";
        public void eat() {
            System.out.println("xxx正在吃" + type  + "面包");
        }
}

 三、注意事项
 对java来说：
               1、在一个java文件来说，可以写多个类，但是只能有一个public类，而且文件名要与public修饰的类名相同。

 

 

继承
 一、简介
 继承是一个类A拥有另一个类B的的所有属性和方法，同时它也可以有自己特有的（B没有的），简而言之，可以看作是对另一个类B的扩展。我们把A类叫做子类，B类叫做父类，子类继承父类即A类继承B类
  A类可以拥有B类的所有的属性和方法，但是某个属性或者某个方法是否能直接使用还要取决于该属性或者该方法的访问权限修饰符。
 二、结构 【 关键词（extends）】
               【格式：public class 子类名 extends 父类名 {} 】。在写子类的时候注意相同的属性或者方法是不需要再重新写一遍的，直接调用或者间接使用。可以添加新的属性或者方法。
 三、访问权限（这里和上面一样）
 

	当前类中	同一个包下	子类中	其他
public	ok	ok	ok	ok
protected	ok	ok	ok
缺省（什么也不写）	ok	ok
private	ok

 四、子类的实现
 1、产生一个子类对象。【子类名 对象名 = new 子类名; 】，此时父类、子类的方法均可以调用
 五、父类、子类的相互转型
 1、自动转型。子类对象可以自动转换成父类对象。【父类名 对象名 = new 子类名; 】此时的方法调用以子类为准，这个只要涉及同名方法时，调用的时子类的方法而不是父类的。这个主要是用在当需要传入不确定的子类对象
或者是父类对象时，可以将参数设为父类对象，而子类对象声明为父类。
 2、强制转型。父类A对象a强制转换成子类B对象b。【B b = (B) a;】
 六、方法的重写
 当父类的方法不能满足我们的需求时，我们可以对父类的方法进行重写，但是要注意两点：
 1、必须要有继承关系
 2、方法的声明，除了访问权限可以扩大，其他（返回值类型、方法名、参数）必须完全一样。
 七、例子：

场景：柯南 、 凶手 、黑衣人 PK
 柯南 和 凶手互相PK，采用回合制，每次攻击，让对方的血量减少攻击方的攻击值，重复，直到某一方的血量小于等于0，
获胜的一方继续和 黑衣人PK，黑衣人每次攻击让对方的血量减少自己的两倍攻击值，重复，直到某一方的血量小于等于0.
 输出：战斗过程，战斗结果。
 要求：每个类至多有一个攻击方法。

 

主类（柯南）

 1 package object;
 2 
 3 import java.util.*;
 4 
 5 public class Curnane {
 6     public String name;
 7     public int blood = 100;
 8     protected int attack = 0;
 9     
10     public void get(String name1,int bl,int ac)
11     {
12         name = name1;
13         blood = bl;
14         attack = ac;
15     }
16     
17     public int attack(Curnane c) {
18         if(c.blood > 0)
19         {
20             c.blood -= attack ;
21             System.out.println(name + "正在攻击" + c.name + " ; "+c.name+ "的血量减少: "+attack+ ".  "
22                     + "此时双方的剩余血量分为: "+c.name +": "+ c.blood + ";"+ name + ": "+ blood);
23             
24             if(c.blood <= 0)
25             {
26                 System.out.println();
27                 System.out.println("Game over! "+name + " 胜利 ！");
28             }
29         }
30         return c.blood;
31     }
32 }

两个子类

 1 package object;
 2 
 3 import java.util.*;
 4 
 5 public class Muederer extends Curnane{
 6     
 7 }
 8 
 9 
10 
11 package object;
12 
13 public class Black extends Curnane{
14     
15     public int attack(Curnane c) {
16         if(c.blood > 0)
17         {
18             int t = attack*2;
19             c.blood -= t ;
20             System.out.println(name + "正在攻击" + c.name + " ; "+c.name+ "的血量减少: "+ t + ".  "
21                     + "此时双方的剩余血量分为: "+name +": "+ blood + "; "+ c.name + ": "+c.blood);
22             
23             if(c.blood <= 0)
24             {
25                 System.out.println();
26                 System.out.println("Game over! "+name + " 胜利 ！");
27             }
28             
29         }
30         return c.blood;
31     }
32 
33 }

主方法

 1 package object;
 2 
 3 public class begin {
 4     public void pk(Curnane c1, Curnane c2)
 5     {
 6         int blood1 = 0;
 7         int blood2 = 0;
 8         blood1 = c1.blood;
 9         blood2 = c2.blood;
10         while(blood1 > 0 && blood2 > 0)
11         {
12             blood1 = c2.attack(c1);
13             if(blood1 <= 0 ) break;
14             
15             blood2 = c1.attack(c2);
16             if(blood2 <= 0 ) break;
17         }
18         
19     }
20     public static void main(String[] args) {
21         String cname = " 柯南 ";
22         String mname = " 凶手 ";
23         String bname = " 黑衣人 ";
24         int blood1 = 100; //柯南
25         int blood2 = 100;  //凶手
26         int blood3 = 80;   //黑衣人
27         int attack1 = 2;//柯南
28         int attack2 = 3;//凶手的攻击值
29         int attack3 = 4;//黑衣人的攻击值
30         
31         begin b = new begin();
32         Curnane curnane = new Curnane();
33         Curnane muederer = new Muederer();
34         Black black = new Black();
35         
36         Curnane winner = new Curnane();
37         
38         curnane.get(cname,blood1,attack1);
39         muederer.get(mname, blood2,attack2);
40         black.get(bname, blood3, attack3);
41         
42         b.pk(curnane,muederer);
43         
44         
45         
46         if(blood1 > blood2)     winner = curnane;
47         else  winner = muederer;
48         
49         b.pk(winner,black);
50     }
51 
52 }