Java类与对象、构造器和方法的重载

Java是一种面向对象的程序设计语言（Object Oriented Programming：OOP），面向对象的程序设计语言中有类和对象的概念，它们在概念上有什么区别呢？这往往是一个令面向对象的初学者感到迷惑的问题。下面的解说虽然针对的是Java语言，但对所有面向对象的程序设计语言都通用。什么是类在面向对象的程序设计语言中，类是对一类“事物”的属性与行为的抽象。举一个浅显的例子。Person（人）是对地球上所有具有特殊智能的生物包括你，我，他，张三，李四等的抽象。
“你”，“我”，“他”，“张三”，“李四”等等都属于“人”这一类所包含的个体。

Java语言中对类Person的定义往往如下：
　　public class Person {
　　 private String name; //属性：姓名
　　 private int height; //属性：身高
　　 private int weight; //属性：体重
　　
　　 public Person() {}
　　 public Person(String name, int height, int weight) {
　　 this.name = name;
　　 this.height = height;
　　 this.weight = weight;
　　 }
　　
　　 //... some methods...
　　
　　 public void doSth() { //行为：
　　 //... do something
　　 }
　　}

什么是对象
简单一点说，对象是类的具体的个体。比如，张三是类Person的一个对象。Person可能存在无数个对象（就好像地球上存在数十亿人一样）。
　　
　　Java中，对象的创建可以使用new来创建一个对象。比如：
　　Person zhangsan = new Person(“Zhangsan”, 170, 65); //创建对象：“Zhangshan”
　　zhangsan.doSth(); //对象行为：对象自己发出行为
　　
　　类和对象的关系
　　
　　类和对象的区别
　　1，类是一个抽象的概念，它不存在于现实中的时间/空间里，类只是为所有的对象定义了抽象的属性与行为。就好像“Person（人）”这个类，它虽然可以包含很多个体，但它本身不存在于现实世界上。
　　2，对象是类的一个具体。它是一个实实在在存在的东西。
　　3，类是一个静态的概念，类本身不携带任何数据。当没有为类创建任何对象时，类本身不存在于内存空间中。
　　4，对象是一个动态的概念。每一个对象都存在着有别于其它对象的属于自己的独特的属性和行为。对象的属性可以随着它自己的行为而发生改变。

定义类的基本格式：

[修饰符] class 类名
{
    //零到多个构造器...
    //零到多个成员变量...
    //零到多个方法...
    //零到多个初始化块...
}
修饰符 可以为 public final abstract 或者不写
类名：大驼峰命名

一、构造器
构造器也叫构造方法或者构造函数,构造器与类名相同，没有返回值，连void都不能写;

/*
      * 构造器定义格式：
           [修饰符] 类名 (形参列表)
           {
              //构造器方法体代码
           }
           
     构造器的修饰符  public private protected
      */
     public ClassDemo() {
           System.out.println("无参构造器");
     }
     public ClassDemo(int i){
           System.out.println("一个参数的构造器");
     }

（1）名称与类名相同，没有返回值，不能写void
（2）如果类中没有手动添加构造器，编译器会默认再添加一个无参构造器
（3）如果手动添加了构造器（无论什么形式），默认构造器就会消失
（4）构造器可以重载
（5）形参列表不同有两点不同：形参个数不同，形参类型不同
二、成员变量
成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。

// 成员变量
     // [修饰符] type 成员变量名称 [= 默认值];
     // 修饰符 (public protected private)三选一、 static、final
     // 实例变量
     int intNum;
     int intNum2=10;
     //类变量
     public static String str="111";

实例变量和类变量区别：实例变量去实例new出来使用，类变量只需访问他的方法就可调用
static修饰成员方法最大的作用，就是可以使用"类名.方法名"的方式操作方法，避免了先要new出对象的繁琐和资源消耗

三、方法
Java方法是语句的集合，它们在一起执行一个功能。
（1）方法是解决一类问题的步骤的有序组合
（2）方法包含于类或对象中
（3）方法在程序中被创建，在其他地方被引用

// 方法
     /*
      * [修饰符] 方法的返回值类型 方法名称 (形参列表) { //方法体代码 [return 返回值;] } 修饰符 (public
      * protected private)三选一、 static、final、synchronize、native
      */

四、创建对象
对象是根据类创建的。在Java中，使用关键字new来创建一个新的对象。创建对象需要以下三步：
（1）声明：声明一个对象，包括对象名称和对象类型。
（2）实例化：使用关键字new来创建一个对象，只是为对象在内存中开辟空间。
（3）初始化：使用new创建对象时，会调用构造方法初始化对象，对象中的值赋初始 值。

/**
 *
 * @author en
 *类的定义
 *[修饰符] class 类名 
 *{
 *    零到多个构造器...
 *    零到多个成员变量...
 *    零到多个方法...
 *}
 *修饰符 可以为 public final abstract 或者不写
 *类名：首字母大写，驼峰命名
 */
public class SimplePerson {
     //构造器
    /*
     * [修饰符] 构造器名称 (形参列表)
     * {
     *    //构造器方法体代码
     * }
     * 修饰符可以是 public private protected,也可以不写
     *
     * 名称与类名相同，没有返回值，不能写void
     * 构造器可以重载
     * 如果类中没有手动添加构造器，编译器会默认再添加一个无参构造器
     * 如果手动添加了构造器（无论什么形式），默认构造器就会消失
     *
     */
     public SimplePerson(){
           
     }
     
     //成员变量
     /*
      * [修饰符] type 成员变量名称 [= 默认值];
      * 修饰符  (public protected private)三选一、 static、final
      */
     String name;
     int age;
     
     //方法
     /*
      * [修饰符] 方法的返回值类型 方法名称 (形参列表)
      * {
      *    //方法体代码
      * }
      * 修饰符  (public protected private)三选一、 static、final
      */
     public void say(String text){
           System.out.println(this.age +"岁的"+this.name+"说：\""+text+"\"");
     }
}
public class Demo1 {
     public static void main(String[] args) {
           //声明对象
           SimplePerson simplePerson;
           //过new关键字调用SimplePerson类的构造器，返冋一个SimplePerson实例
           simplePerson=new SimplePerson();
           
           //一般都把 声明 和 new合在一起写
           SimplePerson person=new SimplePerson();
           
           person.age=20;
           person.name="小明";
           
           person.say("不知道说啥");
     }
}

五、this指当前对象的引用

public class Person {
     String name;
     int age;
     static int intA;
构造器的重载：跟类名相同
     //构造器的重载：形参列表不同  
     public Person(){
           System.out.println("无参构造方法");
           this.age=20;
           this.name="小明";
     }
     public Person(int age){
           this.age=age;
           this.name="小明";
           System.out.println("有参构造方法1");
     }
     public Person(int age,String name){
           this(age);//调用另外一个构造方法
           this.name=name;
           System.out.println("有参构造方法2");
     }
     public Person(String name,int age){
           this(age,name);
           System.out.println("有参构造方法3");
     }

方法的重载(Overload)
（1）重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。
（2）每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。
（3）最常用的地方就是构造器的重载。

//方法的重载 overload
     /*
      * 构成重载的前提：调用者相同，方法名相同，形参列表不同；
      * 被重载的方法必须形参列表不一样(参数个数或类型不一样)；
      * 被重载的方法可以改变返回类型；
      * 被重载的方法可以改变访问修饰符；
      * 被重载的方法可以声明新的或更广的检查异常；
      * 方法能够在同一个类中或者在一个子类中被重载。
      * 返回值类型不能作为重载函数的区分标准。
      * 修饰符不会影响到方法的重载
      */
      */
     /*
      * 方法的三个要素：调用者（对象，类）、方法名、形参列表
      */
     public void say(String text){
           System.out.println(this.age +"岁的"+this.name+"说：\""+text+"\"");
     }
     
     
    public String say(String text,String state) {
           return this.age +"岁的"+this.name+state+"的说：\""+text+"\"";
     }
     String say(String text,String state,String location){
           return this.age +"岁的"+this.name+"在"+location+""+state+"的说：\""+text+"\"";
     }
     
     public static void Say(String text){
           System.out.println(text);
     }
     
     public static void Say1(String text){
           System.out.println(text);
     }
}
调用重载方法
public class Demo2 {
     public static void main(String[] args) {
           Person person = new Person();
//         person = new Person(10, "小明");
           
           person.say("不知道说啥");
           System.out.println(person.say("不知道说啥","郁闷"));
           System.out.println(person.say("不知道说啥","郁闷","教室"));
     }
}