JAVA类和对象

如何创建类

⚠Java当中一切皆对象

⚠如何描述对象？用类。

我们可以类当成一个模板，用来描述对象特征，行为等等

//自定义的类型 -> 你定义的一个 Java当中 没有的类型
class PetDog {
    public String name;//名字
    public String color;//颜色
    // 狗的属性
    public void barks() {
        System.out.println(name + ": 旺旺旺~~~");
    }

    // 狗的行为
    public void wag() {
        System.out.println(name + ": 摇尾巴~~~");
    }
}

如何修改文件内类的名称

因为这样不方便更改类的名称 

类的实例化

定义了一个类，就相当于在计算机中定义了一种新的类型 ，与 int ， double 类似，只不过 int 和 double 是 java 语言自 带的内置类型，而类是用户自定义了一个新的类型，比如上述的：PetDog 类。它是类 ( 一种新定义的类型) 有了这些自定义的类型之后，就可以使用这些类来定义实例 ( 或者称为对象 ) 。

用类类型创建对象的过程，称为类的实例化 ，在 java 中采用 new 关键字，配合类名来实例化对象。

实例化出来的东西就是一个真正的实体

    public static void main(String[] args) {
        //通过new 关键字 可以实例化 多个对象
        //任何变量在使用的时候是已经被赋值的
        //.用来访问对象的属性或者方法
        PetDog petDog1 = new PetDog();
        petDog1.name = "feifei";
        petDog1.color = "红色";
        System.out.println(petDog1.name);
        System.out.println(petDog1.color);
        petDog1.barks();
        petDog1.wag();
        System.out.println("=============");


        PetDog petDog2 = new PetDog();
        petDog2.name = "花花";
        petDog2.color = "灰色";
        petDog2.barks();
        petDog2.wag();

        System.out.println(petDog2.name);
        System.out.println(petDog2.color);
    }

 new petdog1和2相当于开辟两块内存

this关键字

作用一

public class Date {
    public int year;
    public int month;
    public int day;
    
    public void setDate(int y, int m, int d){
        year = y;
        month = m;
        day = d;
    }

    public static void main(String[] args) {
        Date date = new Date();
        date.setDate(1999,1,1);
    }
}

 

但是如果再创建一个新的日期，同样调用这个方法，那么问题来了，你怎么知道是给哪个对象调用的方法呢？ 

Date date2 = new Date();
date2.setDate(1989,11,11);

 其实系统是知道的

这里的this用来判断是哪个date来调用这个方法 

这里的year，month，day其实是

this.year = y;
this.month = m;
this.day = d;

作用二

设计另一个setDate和print方法

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

    public void print(){
        System.out.println("year: " + year + "month: " + month + "day: " + day);
    }

在调用这些方法的时候发现打印结果全都是0？？？

在setDate方法里面，形参和成员变量相同，由于局部变量优先原则，形参给形参自己赋值了，相当于什么都没赋，打印出来的就是int形式的null也就是0

修改setDate方法，在每个形参前面加一个this指向当前对象。this表示对当前对象的引用

所以当我们的形参变量和成员变量一样的时候，要在形参前面加一个this

所以尽量使用this，一定错不了

实例化对象

对于局部变量，在使用时一定要初始化，否则会报错

成员变量也同理，在没有初始化的时候

String类型默认为null，int类型为0，float类型为0.0f，double类型为0.0

方法一：就地实例化

直接在命名成员变量的时候就赋值

class Student{
    /**
     * 成员属性 / 成员变量： 定义在方法外部，类内部的变量
     *
     * 成员变量
     *      1. 静态成员变量
     *      2.普通成员变量->
     */
    public String name = "张三";
    public int age = 10;

这种适用于特殊的业务需求，比如任何一次对象实例化后都期望这个对象叫做张三，年龄是10岁。

方法二：默认初始化

    public static void main(String[] args) {
        /**
         * 实例化对象
         */
        Student student = new Student();
        student.name = "张三";
        student.age = 10;
        student.show();

方法三：构造方法

1.没有返回值

2.方法名与类名相同

class Student{
    public String name ;
    public int age ;
    public Student(){
        this.name = "鼠标";
        this.age = 9;
        System.out.println("Student()....");

这里的构造方法是由下面这个语句调用的

Student student = new Student();

在生成对象，也就是对象实例化的时候，有两个关键步骤：

1.为对象分配空间

2.调用合适的构造方法

 现在我又写了一个方法，与刚刚的方法名相同

    public Student(String name, int age){
        this.name = name;
        this.age = age;
        System.out.println("Student(String,int)");
    }

我们现在知道，构造方法可以有很多个，相同名字的构造方法之间构成重载关系

---

一旦有了方法重载，那我们就可用this来简化第一个构造方法的代码

//调用其他构造方法->只能在构造方法中写
this("鼠标",9);//这个只能出现在当前构造方法的第一行

这也是this的第三个作用

---

当我们没有写任何一个构造方法的时候，Java会自动提供一个不带任何参数的构造方法。

下面的代码代表调用两个构造方法，如果我把第一个构造方法删除

系统会自动报错，因为第一个对象没有方法可以调用

如果我们已经写了一个构造方法了，那么Java就不再自动提供新的构造方法了

---

写构造方法的小技巧：

鼠标右键选择generate或者按ALT+insert(也就是0)，选择想要添加的变量进行构造，如果有多个变量就按住CTRL点就行了

---

⚠使用构造方法时不要形成环，否则系统会懵圈

封装

OOP有几个重要特征：封装，继承，多态

private初认识

当我们把public改成private之后

右边无法初始化name，也就是无法使用

所以封装也就是被private修饰的成员变量或者方法，只能在当前类中使用，不透露具体细节

那我非要在另一个类中使用的话，也有办法，上面图片已经说了一种了，就是直接在创建对象的时候给出成员变量的值

另一种我们可以用方法

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

//测试函数
Person person = new Person();
person.setName("张三");
System.out.println(person.getName());

 这种方法相当于接口，封装只对外开放接口方便其他人与程序交互

访问限定符

public ：可以理解为一个人的外貌特征，谁都可以看得到

default: 对于自己家族中 ( 同一个包中 ) 不是什么秘密，对于其他人来说就是隐私了

private ：只有自己知道，其他人都不知道

包 

在面向对象体系中， 为了更好的管理类，把多个类收集在一起成为一组，称为软件 包。有点类似于目录。 包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式 ，比如：一

个包中的类不想被其他包中的类使用。包还有一个重要的作用： 在同一个工程中允许存在相同名的类，只要处在 不同的包中即可。

e.g import java.util.Arrays 就是专门组织管理和数组相关的类

如何导入包

import java.util.Date;
public class Test2 {
    public static void main(String[] args) {
        Date date = new Date();
        int[] array = {1,2,3};
        System.out.println(Arrays.toString(array));

 一般建议具体到哪一个包，不要加个*涵盖了事

import java.util.*;

在这种情况下，Java自己会乱

如果出现两种包混合使用，就要具体去创建对象

java.util.Date date = new java.util.Date();

 导入静态包

import static java.lang.Math.*;
public class Test {
    public static void main(String[] args) {
    double x = 30;
    double y = 40;
    // 静态导入的方式写起来更方便一些.
    // double result = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
    double result = sqrt(pow(x, 2) + pow(y, 2));
    System.out.println(result);
    }
}

双击shift搜索math可以找到背后的代码，我们找到java.lang这个包