蓝杰之牛刀小试1

1    类是什么，对象是什么？
学习c++接触过类，但是完全被他打败了，云里雾里。。。。

。。。。
现实生活中，存在很多形象的东西可以很容易的理解这个看

起来很玄乎的东西比如常见的名词：学生，老师，大学。而

对象就是类里面具体的某一个，例如学生类里的张超，王龙

辉，黄俊波；老师类里的张老师，胡老师，陈老师；大学类

里的中南大学，湖大，哈佛。
下一步就是将现实的东西或者叫想法用java语言表达出来，

就像用汉字表达一样.具体就得学习语法知识。（初级阶段只

需多大多练，语法来源不用管，就像学汉语从来不问为什么

要有主谓宾一样，用的多就会知道！！）
@@@@@@@@@@@@@@@@@@@@@@@@
//定义一个类型，比如学生类型，用到关键字class，代码是
public class Student{
        }
对于任何一个类（型），肯定都有自己的特点（属性），比

如学生之所以成为学生，而不叫做电脑，应为学生有自己的

特点如：名字，性别，年龄，学号，学分等等代码如下
public class Student{

private String name;
private String sex;
private int age;
private int score;

}
然后是---设置---学生的名字，性别，年龄，学分代码：
public class Student{

   private String name;
   private String sex;
   private int age;
   private int score;
//设置学生的姓名
  public void setName(String s){
      name=s;
     }
//设置学生的年龄
  public void setAge(int t){
       age=t;
     } 
  //定义学生玩(的方法)
  public void study(){
  score+=score;
  System.out.println(name+"正在玩CF很开心，学分

是："+score);

    }
}


@@@@@@@@@@@@@@@@@@@@@@@

对象 ：对象是通过类来创建的。如创建一个学生对象，代码

如下：
//测试类型的定义
public class Test{
   //主函数，照抄就行
   public static void main(string args[]){
    //创建一个学生对象
    Student stu1=new Student();
    //该学生stu1设置名字，年龄，玩
    stu1.setName("小沈阳");
    stu1.setAge(20);
    stu1.study();
     }
       
}
运行结果如下：小沈阳正在玩CF很开心，学分是：0


1 数据类型


数据类型：原始数据类型与引用类型。
原始数据类型是系统自带的，包括有：
        字节型（Byte  8bite），整型（int  4byte）
，短整型（short  2Byte），长整型（long  8Byte），
字符型（char 2Byte），
浮点型（float  4Byte），双精度型（double  8Byte）。
      

数据类型的定义int A=10；float s=1.1。
引用类型是指有类创建的对象的类型。

@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
2值传递与引用传递


值传递的范围是8个原始数据类型。代码如下：
public class Student{
   //创建一个改变值的方法
    public void changByte(Byte t){
       t=125;
        }

    }
   
   
  //创建一个Test类实现该调用
  public class Test{
      public static void main(String args[]){
       Student s1=new Student();
       Byte i=-50;
      
       s1.changByte(i);
       System.out.print("调用了changByte后，这里的i值是"+i);
     
      }
 
 
     }


   代码输出得到的结果是：调用了changByte后，这里的i值是-50。
  
   值传递是将类Test类中的i复制一个传给了形参Byte t，在方发
changByte中i的值确实是改变了，但结果并不影响Test类中的i值。




引用传递
//定义一个学生类型
public class Student{
    public void setName(String s){
       name=s;
       }
     public String getName(){
        return name;
        }
      private String name;
 
}
//定义一个Manager类型
public class Manager{
   public void changName(Student A){
      String newName="CF救世主时代";
      A.setName(newName);
     
       }
     }
//定义一个Test类型
public class Test{
   public static void main(String args[]){
     Student s1=new Student();
     s1.setName("王龙辉");
     Manager m1=new Manager();
    
     m1.changName(s1);
     String name=s1.getName();
     System.out.print("这个时候你的名字是："+name);
  
       }


   }
  代码输出的结果是：这个时候你的名字是：CF救世主时代


  总结：
  对比两个实例可以清楚的知道值传递与引用传递的区别：
在两个Test类中都分别试图改变i的值与s1所指向的实体“王龙辉”，
但是值传递并没有改变i的值，一用传递改变了“王龙辉”成“CF救
世主时代”。



1继承
现实例子：大学生类继承学生类，中南大学学生类继承大学生类。
我们称学生类是父类，大学生类跟中南大学生是子类。同时大学生
类也是父类，中南大学生类是大学生类的子类（相对）。


继承的关键字是：extends.
代码如下：
//定义一个学生类
public class Student{
   private String name;
   private int energy=100;
  
  //定义设置名字的方法
     public void setName(String s){
        name=s;
       }
  //定义玩穿越火线的方法
     public void playCF(int hour){
      energy-=hour*4;
      
     System.out.print(name+"无语了，快挂科了，纠结中。。。"+energy);
      
          }
      
     }
    
//另外写一个大学生类，继承学生类

public class UnStudent extends Student{
    
     //主函数
     public static void main(String args[]){
      
       UnStudent u1=new UnStudent();
      
     //继承后调用Student类里的方法
    
       u1.setName("宋远剑");
       u1.playCF(100);
      
         }


     }
    
  运行该代码得到的结果是：宋远剑无语了，快挂科了，纠结中。。。-300
 
 
总结：继承的好处很容易就可以看见了，对于大学生跟学生肯定有很多相似的
方法，用extends关键字就可以避免同样的代码在打一次，非常方便！！！
 
 
 
2  重写

重写：毕竟父类与子类会有些差别，大学生的方法跟学生类的方法肯定有不一样
的地方，这就要用到“重写”，即重写继承类里的方法。代码如下



//另外写一个大学生类，继承学生类

public class UnStudent extends Student{

      public void playCF(int hour){
       
         energy+=hour*3;
         System.out.print(name+"：虽然当时玩的很开心，后来很不爽，何去何从？？？"+energy);
       }
  
   

    //主函数
     public static void main(String args[]){
      
       UnStudent u1=new UnStudent();
      
    //继承后调用Student类里的方法
    
       u1.setName("宋远剑");
       u1.playCF(100);
      
         }


     }
//这个类只是重写了方法playCF,输出的结果是：
宋远剑：虽然当时玩的很开心，后来很不爽，何去何从？？？400
（还有一点需要改动，由于权限的限制，Student类中private
String name;private int energy要去掉private。——意外收获）

3重载
重载：重载跟重写的区别在于重载要方法的参数是不相同的。 
还是上一个例题：


//另外写一个大学生类，继承学生类

public class UnStudent extends Student{

      public void playCF(int hour,int t){
       
         energy+=hour*3;
         energy+=energy*t;
         System.out.print(name+"：虽然当时玩的很开心，后来很不爽，何去何从？？？"+energy);
       }
  
   

    //主函数
     public static void main(String args[]){
      
       UnStudent u1=new UnStudent();
      
    //继承后调用Student类里的方法
    
       u1.setName("宋远剑");
       u1.playCF(100);
      
         }


     }
输出的结果是：宋远剑：虽然当时玩的很开心，后来很不爽，何去何从？？？2000

4自动转型
自动转型是指子类对象会自动转型为父类对象，代码如下
public class UnStudent extends Student{
    public static void main(String args[]){
      //自动转型
     
Student u1=new Student();

      //转型后只能调用父类中的方法

u1.setName("李胜楠");
u1.playCF(100);

          }
输出结果为：李胜楠无语了，快挂科了，纠结中。。。-400








构造器
//构造器是用来在创建对象时调用用的例如：
    new Student()用来创建一个新的学生对象,实际完整形式是new public Student（）;
//每一个类都有一个默认无参的构造器，而且必须跟类名字是相同的
//用关键字new来调用，无返回值标志void，即不能写成public void Student（）；
应该是public Student；举例如下：


//定义一个学生类
public class Student{
   private String name;
   private int energy=100;
  
  //定义设置名字的方法
     public void setName(String s){
        name=s;
       }
  //定义玩穿越火线的方法
     public void playCF(int hour){
        energy-=hour*4;
      
        System.out.print(name+"无语了，快挂科了，纠结中。。。"+energy);
      
          }
      
     }
-----该学生类里边有默认的无参构造器public Student（）；
————————————————
//定义一个Test类

public class Test {
public static void main(String args[]){
Student s1=new Student();
                s1.setName("宋远剑");
s1.playCF(100);

  }
    }

—————————————————
下面用有参构造器
—————————————————
//定义一个学生类
public class Student{

   private String name;
   private int energy=100;

   public Student(String s){
         name=s;
        }
    //定义玩穿越火线的方法
     public void playCF(int hour){
        energy-=hour*4;
      
        System.out.print(name+"无语了，快挂科了，纠结中。。。"+energy);
      
          }
————————————————
//定义一个Test类
public class Test {
     public static void main(String args[]){
       
        Student s1=new Student("宋远剑");
s1.playCF(100);

  }
    }
两个Test类输出的结果是相同的：宋远剑无语了，快挂科了，纠结中。。。-300

//有参的构造器一旦创建，默认的无参构造器便失效，而且创建对象的时候就要
给对象初始化


！！1.构造器和方法的区别：
1形式上：构造函数没有返回值标志void，要有关键字new来调用。而且必须
与类名相同，每个类有一个默认的无参构造器。一旦编写了有参的构造器，默
认的就失效。

2具体作用上：构造器用来创建新的对象，方法是用来被对象调用。构造器
跟方法都可以被重载。








2.重写和重载的区别:
重载是在类中可以创建多个方法，他们具有相同的名字，不同的参数类型
和个数，不同的定义。在调用的时候可以输入不同的参数类型与个数达到
调用不同方法的目的。
重写指在子类中某方法对父类中的方法进行重新定义，但是方法名跟传入
的参数类型与个数需要相同，从而在调用子类的方法时不能执行父类的方法。