JAVA类和对象（第四节）

类是在描述对象，对象是一个又一个能帮我们解决问题的东西，这些东西并不是凭空出现的，在我们造对象的时候是要根据设计图才可以设计出来的，在java当中这些设计图就叫做类，它是用来描述一类事物的，根据设计图造出来的东西，就是能帮我们解决问题的对象。在java中，必须先设计类，才能获得对象

如何定义类？

类的一个语法是通过class来定义的

//创建类

class ClassName{

          field;//字段（属性）或者成员变量

          method;//行为 或者 成员方法

} 

class为定义的关键字

ClassName为类的名字，采用大驼峰的形式每一个单词的首字母都必须进行大写

{ }中为类的主体

成员属性

class WashMachine{
        //属性，字段，成员变量：这些成员变量是定义在方法外部类的内部
        public String brand; // 品牌
        public String type; // 型号
        public double weight; // 重量
        public double length; // 长
        public double width; // 宽
        public double height; // 高
        public String color; // 颜色
    }

成员方法 

一个类除了有属性组成，还有一种组成。叫做成员方法 。成员方法是如何定义的？比如说洗衣机它可以洗衣服。我们定义的成员方法，它是在类的里面，可以有多个成员方法

  class WashMachine {
        //属性，字段，成员变量：这些成员变量是定义在方法外部类的内部
        public String brand; // 品牌
        public String type; // 型号
        public double weight; // 重量
        public double length; // 长
        public double width; // 宽
        public double height; // 高
        public String color; // 颜色

        //成员方法
        public void washClothes() { // 洗衣服
            System.out.println("洗衣功能");
        }

        public void dryClothes() { // 脱水
            System.out.println("脱水功能");
        }

        public void setTime() { // 定时
            System.out.println("定时功能");
        }
    }

WashMachine也是我们自己定义的类型，所以我们也叫它叫做类，类其实就是类型，类型就是我们自己通过class自己定义的一种类型，有了类型我们就可以用类型来定义变量，所以它就相当于我自己定义的一种类型，或者叫做类

定义类的补充注意事

项用来描述一些事物的类，专业叫做：javabean类，在javabean类中，是不写main方法的
在以前，编写main方法的类，叫做测试类，我们可以在测试类中创建javabean类的对象并进行赋值调用 

例子：dog类

比方说我们再定义一个简单的类，狗类

class PetDog {
public String name;//名字
public String color;//颜色
// 狗的属性
public void barks() {
System.out.println(name + ": 旺旺旺~~~");
}
// 狗的行为
public void wag() {
System.out.println(name + ": 摇尾巴~~~");
}

我们一般情况下，一个类我们就写一个java文件

 例子：学生类

public class Student{
public String name;
public String gender;
public short age;
public double score;
public void DoClass(){}
public void DoHomework(){}
public void Exam(){}
}

注意事项：

1. 一般一个文件当中只定义一个类

2. main方法所在的类一般要使用public修饰(注意：Eclipse默认会在public修饰的类中找main方法),因为我们一个java文件只能有一个public修饰的类

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

3.public修饰的类必须和文件名相同

4.不要去轻易修改public修饰的类的名称，如果要修改需要通过开发工具修改

 类的实例化

什么是实例化？

定义了一个类，就相当于在计算机中定义了一种新的类型 ，与 int ， double 类似，只不过 int 和 double 是 java 语言自

带的内置类型，而类是用户自定义了一个新的类型，比如上述的： PetDog 类和 Student 类。它们都是类 ( 一种新定

义的类型 ) 有了这些自定义的类型之后，就可以使用这些类来定义实例 ( 或者称为对象 )。用类类型创建对象的过程，称为类的实例化 ，在 java 中采用 new 关键字，配合类名来实例化对象。

就是说我们通过关键字new可以实例化多个对象

    class Dog {
        public String name;//名字
        public String color;//颜色
        // 狗的属性
        public void barks() {
            System.out.println(name + ": 旺旺旺~~~");
        }
        // 狗的行为
        public void wag() {
            System.out.println(name + ": 摇尾巴~~~");
        }
    }
    public class JavaClass {
    public static void main(String[] args) {
        Dog dog1 =new Dog();
        Dog dog2 =new Dog();
    }
}

对象的引用.访问属性进行赋值
  

    class Dog {
        public String name;//名字
        public String color;//颜色
        // 狗的属性
        public void barks() {
            System.out.println(name + ": 旺旺旺~~~");
        }
        // 狗的行为
        public void wag() {
            System.out.println(name + ": 摇尾巴~~~");
        }
    }
    public class JavaClass {
    public static void main(String[] args) {
        Dog dog1 =new Dog();
        dog1.name ="小王";
        dog1.color ="紫色";
        Dog dog2 =new Dog();
        System.out.println(dog1.name);
        System.out.println(dog1.color);
    }
}

运行结果：

小王
紫色

这个时候我们可以拼接一下,丰富一下输出

    class Dog {
        public String name;//名字
        public String color;//颜色
        // 狗的属性
        public void barks() {
            System.out.println(name + ": 旺旺旺~~~");
        }
        // 狗的行为
        public void wag() {
            System.out.println(name + ": 摇尾巴~~~");
        }
    }
    public class JavaClass {
    public static void main(String[] args) {
        Dog dog1 =new Dog();
        dog1.name ="小王";
        dog1.color ="紫色";
        Dog dog2 =new Dog();
        System.out.println("姓名:"+dog1.name);
        System.out.println("毛色:"+dog1.color);
    }
}

运行代码

姓名:小王
毛色:紫色

行为也可以通过.来使用

    class Dog {
        public String name;//名字
        public String color;//颜色
        // 狗的属性
        public void barks() {
            System.out.println(name + ": 旺旺旺~~~");
        }
        // 狗的行为
        public void wag() {
            System.out.println(name + ": 摇尾巴~~~");
        }
    }
    public class JavaClass {
    public static void main(String[] args) {
        Dog dog1 =new Dog();
        dog1.name ="小王";
        dog1.color ="紫色";
        Dog dog2 =new Dog();
        System.out.println("姓名:"+dog1.name);
        System.out.println("毛色:"+dog1.color);
        dog1.wag();
    }
}

运行结果：

姓名:小王
毛色:紫色
小王: 摇尾巴~~~

 我们一个类可以创建很多

    class Dog {
        public String name;//名字
        public String color;//颜色
        // 狗的属性
        public void barks() {
            System.out.println(name + ": 旺旺旺~~~");
        }
        // 狗的行为
        public void wag() {
            System.out.println(name + ": 摇尾巴~~~");
        }
    }
    public class JavaClass {
    public static void main(String[] args) {
        Dog dog1 =new Dog();
        dog1.name ="小王";
        dog1.color ="紫色";
        Dog dog2 =new Dog();
        System.out.println("姓名:"+dog1.name);
        System.out.println("毛色:"+dog1.color);
        dog1.wag();
        System.out.println();
        dog2.name="小八";
        dog2.color="黑色";
        System.out.println("姓名"+dog1.name);
        System.out.println("姓名"+dog2.color);
        dog2.barks();
        dog2.wag();
    }
}

 代码运行

姓名:小王
毛色:紫色
小王: 摇尾巴~~~

姓名小王
姓名黑色
小八: 旺旺旺~~~
小八: 摇尾巴~~~

我可以通过new关键字来实例化多个对象 ，new 关键字用于创建一个对象的实例使用， .来访问对象中的属性和方法,同一个类可以创建对个实例

    class Dog {
        public String name;//名字
        public String color;//颜色
        // 狗的属性
        public void barks() {
            System.out.println(name + ": 旺旺旺~~~");
        }
        // 狗的行为
        public void wag() {
            System.out.println(name + ": 摇尾巴~~~");
        }
    }
    public class JavaClass {
    public static void main(String[] args) {
        Dog dog1 =new Dog();
        dog1.name ="小王";
        dog1.color ="紫色";
        Dog dog2 =new Dog();
        System.out.println("姓名:"+dog1.name);
        System.out.println("毛色:"+dog1.color);
        dog1.wag();
        System.out.println();
        dog2.name="小八";
        dog2.color="黑色";
        System.out.println("姓名"+dog1.name);
        System.out.println("姓名"+dog2.color);
        dog2.barks();
        dog2.wag();
        Dog dog3 = new Dog();
        Dog dog4=new Dog();
        Dog dog5=new Dog();
        Dog dog6=new Dog();
        Dog dog7=new Dog();
    }
}

1.引用可以指向引用吗?不可以的引用只能指向对象

Dog dog1 = new Dog();

Dog dog2 = dog1;

不可以的引用只能指向对象

dog2这个引用指向dog1这个引用所指向的对象

2.一个引用能不能指向多个对象？不可以的，一个引用只能指向一个对象 

Dog dog1= new Dog( );

dog1 = new Dog( );

dog1 = new Dog( );

dog1 = new Dog( );

不可以，最终dog1这个引用只能存储一个对象的地址 

3.这代表dog2这个引用，不指向任何对象

Dog dog2 = null;

 如何交换两个数据

    class MyValue{
        public int val;
    }
    public class JavaClass {
        public static void jiaohuan(MyValue val1,MyValue val2){
            int tmp =val1.val;
            val1.val = val2.val;
            val2.val = tmp;
        }
        public static void main(String[] args) {
            MyValue myValue1 =new MyValue();
            myValue1.val = 10;
            MyValue myValue2 = new MyValue();
            myValue2.val =20;
            System.out.println("交换前"+myValue1.val);
            System.out.println("交换后"+myValue2.val);
            jiaohuan(myValue1,myValue2);
            System.out.println("交换前"+myValue1.val);
            System.out.println("交换后"+myValue2.val);
        }
}

 代码运行：

交换前10
交换后20
交换前20
交换后10

this引用 

 我创建了一个类，想通过方法给里面的类进行赋值

    public class Date {
        public int year;//年
        public int month;//月
        public int day;//日
        //steDate是对年，月，日进行赋值
        public void steDate(int y,int m,int d){
            year =y;
            month = m;
            day = d;

        }//打印他们
        public void printDate(){
            System.out.println("年: "+year+"月: "+month+" 日："+day);
        }
        public static void main(String[] args) {
            Date date = new Date();
            date.steDate(1945,9,1);
            date.printDate();
        }
}

代码运行：

年: 1945月: 9 日：1

如果我们在 类行为参数与成员变量相同情况下赋值，它是不行的

  public class Date {
        public int year;//年
        public int month;//月
        public int day;//日
        //steDate是对年，月，日进行赋值
        public void steDate(int year,int month,int day){
            year =year;
            month = month;
            day = day;

        }//打印他们
        public void printDate(){
            System.out.println("年: "+year+"月: "+month+" 日："+day);
        }
        public static void main(String[] args) {
            Date date = new Date();
            date.steDate(1945,9,1);
            date.printDate();
        }
}

运行结果：

年: 0月: 0 日：0

能不能指定当前的这个year是我对象的year

    public class Date {
        public int year;//年
        public int month;//月
        public int day;//日
        //steDate是对年，月，日进行赋值
        public void steDate(int year,int month,int day){
            this.year =year;
            this.month = month;
            this.day = day;

        }//打印他们
        public void printDate(){
            System.out.println("年: "+year+"月: "+month+" 日："+day);
        }
        public static void main(String[] args) {
            Date date = new Date();
            date.steDate(1945,9,1);
            date.printDate();
        }
}

运行结果：

年: 1945月: 9 日：1

为什么要用this？

形参名不小心和成员变量名相同 

public void setDay(int year, int month, int day){
year = year;
month = month;
day = day;
}

this引用指向当前对象，也就代表this代表当前对象的引用，谁调用它，谁就是this 。

1.this的类型本身就是当前对象的类型

2.this只能在成员方法中使用

3.在成员方法中，this只能引用当前对象，不能引用其他对象

如何初始化对象？

说是初始化对象，其实是初始化对象里面的成员

成员变量初始值

局部变量在没有初始化的时候，它会报错，但是我们也没有初始化成员变量，它为什么不报错呢？

成员变量跟局部变量不同，只有局部变量在没有初始化的时候去使用它，它会报错。其他的变量比如说它是成员变量，定义在方法的外边，类的里面。当我们的成员变量没有初始化的时候，它会默认有一个值叫做“默认值”，成员变量如果是int类型默认值是0，如果是布尔类型默认值是false

    public class Date {
        public int year;//年
        public int month;//月
        public int day;//日
        boolean flg; 

        //steDate是对年，月，日进行赋值
        public void steDate(int year,int month,int day){
            year =year;
            month = month;
            day = day;

        }//打印他们
        public void printDate(){
            System.out.println("年: "+year+"月: "+month+" 日："+day);
        }
        public static void main(String[] args) {
            Date date = new Date();
            System.out.println(date.day);
            System.out.println(date.year);
            System.out.println(date.flg);
        }
}

运行结果： 

0
0
false

我们成员变量没有给初始值的时候，它就会有默认值 

构造方法 

构造方法是特殊的方法，该方法没有返回值，方法名和类名是一样的。 

构造方法是怎么被调用的？

构造方法被调用是在实例化对象的时候

    public class Date {
        public int year;//年
        public int month;//月
        public int day;//日
        boolean flg;

        //steDate是对年，月，日进行赋值
        public  Date(){
            this.year=2002;
            this.month=7;
            this.day=23;
            System.out.println("执行了不带参数的构造方法 ");
        }
        public void steDate(int year,int month,int day){
            year =year;
            month = month;
            day = day;

        }//打印他们
        public void printDate(){
            System.out.println("年: "+year+"月: "+month+" 日："+day);
        }
        public static void main(String[] args) {
            //构造方法的调用是发生在实例化对象的时候
            Date date = new Date();
        }
}

代码运行： 

执行了不带参数的构造方法 

当我们没有提供构造方法的时候，java会默认帮你提供一个不带参数的构造方法，也就是说构造方法它至少有一个，也就说当你没有写任何的构造方法的时候，java会自带一个不带参数的构造方法，而不带参数的构造方法里面什么都没有，只不过默认的这个构造方法是没有具体的实现的，所以任何对象的初始化一定会调用构造方法。对象的初始化一定会调用构造方法。实例化一个对象它会调用合适的构造方法，合适意味着有多个构造方法。我们创建对象的时候可以给构造方法传参，从而来初始化我们当前的数据的成员 

    public class Date {
        public int year;//年
        public int month;//月
        public int day;//日
        boolean flg;

        //steDate是对年，月，日进行赋值
        public  Date(){
            this.year=2002;
            this.month=7;
            this.day=23;
            System.out.println("执行了不带参数的构造方法 ");
        }
        public Date(int year,int month,int day){
            this.year=year;
            this.month =year;
            this.day=year;
            System.out.println("执行了带有三个参数的构造方法");
        }

        public void steDate(int year,int month,int day){
            year =year;
            month = month;
            day = day;

        }//打印他们
        public void printDate(){
            System.out.println("年: "+year+"月: "+month+" 日："+day);
        }
        public static void main(String[] args) {
            //构造方法的调用是发生在实例化对象的时候
            Date date = new Date();
            Date date2 = new Date(2003,4,10);
        }
}

运行结果：

执行了不带参数的构造方法 
执行了带有三个参数的构造方法

对象的产生简单来说一定有2步

1.为对象分配内存

2.调用合适的构造方法 

1. 名字必须与类名相同 
2. 没有返回值类型，设置为void也不行 

3. 创建对象时由编译器自动调用就是new的是时候，并且在对象的生命周期内只调用一次(相当于人的出生，每个人只能出生一次) 
4. 构造方法可以重载(用户根据自己的需求提供不同参数的构造方法)

构造方法中，可以通过this调用其他方法来简化代码

    public class Date {
        public int year;//年
        public int month;//月
        public int day;//日
        boolean flg;

        //steDate是对年，月，日进行赋值
        public  Date(){
            /*this.year=2002;
            this.month=7;
            this.day=23;*/
            this(2003,10,2);
            //去调用带有三个参数构造方法
            System.out.println("执行了不带参数的构造方法 ");
        }

        public Date(int year,int month,int day){
            this.year=year;
            this.month =year;
            this.day=year;
            System.out.println("执行了带有三个参数的构造方法");
        }

        public Date(int day) {
            this.day = day;
        }

        public void steDate(int year, int month, int day){
            year =year;
            month = month;
            day = day;

        }//打印他们
        public void printDate(){
            System.out.println("年: "+year+"月: "+month+" 日："+day);
        }
        public static void main(String[] args) {
            //构造方法的调用是发生在实例化对象的时候
            Date date = new Date();
            //Date date2 = new Date(2003,4,10);
        }
}

运行结果：

执行了带有三个参数的构造方法
执行了不带参数的构造方法 

不能够形成环的