JavaSE：类和对象

JavaSE：类和对象

一。类的定义和使用：

1.类的定义：

简单的说，在Java当中，一切皆为类，就洗衣机举一个例子：洗衣机是一个品牌，它就可以看成为一个类，这个洗衣机的型号，重量，功率，尺寸大小等就可以看成属性。这个洗衣机的有着洗衣，烘干，定时等作用，那么就把他们看成功能

2.类的格式：

在Java中定义类要使用class关键字

class Person{
    field;//属性（成员变量）
    method;//行为（成员方法）
}

在上述格式中class是定义类的关键字，Person是类的名字

类中包含的内容称为类的成员。

属性主要是来描述类的，称之为成员属性或者是类成员变量。

方法主要说明类有哪些功能，称为类的成员方法

例子：

class WashMachine{
    public String brand;
    public String type;
    public double weight;
    public double length;
    //.....
    public void washCloth(){
        System.out.println("洗衣功能");
    }
    public void dryCloth(){
        System.out.println("烘干功能");
    }
    public void setTime(){
        System.out.println("定时功能")
    }
}

注意：

类名要使用大驼峰定义

成员前方法统一写成public

此处写法不带static（后面会讲到static的用法）

3.定义一个狗类：

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

注意:

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

下面进行一些概念上的区分：

class person{
    public String name;//普通成员变量
    public int age;//普通成员变量
    public static int count=10;//静态成员变量
    public void sleep(){//普通成员方法
        
    }
    public static void Method(){//静态成员方法
        
    }
}

由此我们可以发现加上static就可以把普通成员变成静态的（后面会专门对static进行分析和理解）

二。类的实例化：

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

Dog pet1=new Dog();
Dog pet2=new Dog();

注意：

new关键字用于创建一个对象的实例

使用 . 来访问对象的方法和属性

同一个类可以创建多个实例

例子：

class Dog{
    public String name;
    public String color;
    public void bark(){
        System.out.println(name+":旺旺旺");
    }
    public void wag(){
        System.out.println(name+":摇尾巴");
    }
}
public class Main{
    public static void main(String[] args){
        Dog pet1=new Dog();
        pet1.name="花花";
        pet1.age=10;
        pet1.bark();
        pet1.wag();
        
        Dog pet2=new Dog();
        pet2.name="灰灰";
        pet2.age=12;
        pet2.bark();
        pet2.wag();
    }
}

一个类可以实例化多个对象，实例化出的对象占用实际的物理空间，存储类成员变量

三。对象的构造及初始化：

1.构造方法：

构造方法是一种特殊的成员方法，名字必须与类名相同，在创建对象的时候，由编译器自动调用，并且在对象的生命周期中只被调用一次

public class Date{
    public int year;
    public int month;
    public int day;
    
    public Date(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(2024,3,23);//这里其实就是进行赋值
        date.printDate();
    }
}

其实还有一种方便的方法进行构造：step1：右击鼠标 step2：找到generate step3：找到construction step4：找到想构造的元素。经过次过程，编译器会自动的给我们写下构造的代码

特征：

1.名字必须与类名相同

2.没有返回值类型，不能写void

3.只有在实例化的时候会被调用

4.构造方法可以被重载

2.就地初始化：

在声明成员变量时，就直接给出了初始值

public class Date{
    public int year=2024;
    public int month=3;
    public int day=23;
    
    public Date(){
        
    }
    public Date(int year,int month,int day){
        
    }
    public static void main(String[] args){
        Date d1=new Date(2020,1,1);
        Date d2=new Date();
    }
}

四。封装：

1.概念：

面向对象程序的三点特征：封装，继承，多态；而类和对象阶段，主要研究的就是封装特性。何为封装呢？简单来说就是套壳屏蔽细节

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行 交互

2.访问限定符：

Java中主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，更符合人类对事物的认
知，而访问权限用来控制方法或者字段能否直接在类外使用。Java中提供了四种访问限定符

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

public：可以理解成一个人的外貌，所有人都可以知道

default：对于自己的家族中不是秘密，但是对于其他家族就是秘密

protected：后面会讲到

而在封装这个模块里，我们经常使用private进行封装，因为使用private来声明变量，则这个变量只会在本类中使用，在其他类中则不会被使用。因此常用封装来隐藏自己的数据等其他信息

当然如果想在其他的类中使用或改变封装声明的对象的数据，也是可以使用的，例子：

//person文件
public class Person{
    private String name;
    private int age;
    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }
    public String getName(){
        return this.name;
    }
    public void setName(String name){
        this.name=name;
    }
}
//test2文件
public class Test2{
    public static void main(String[] args){
        Person person=new Person();
        person.setname("张三");
        System.out.println(person.getName());
    }
}

使用set…和get…来获取和修改private修饰的数据

五。static关键字：

static修饰成员变量：

static修饰成员变量，称为静态成员变量

静态成员变量的特征：

1.不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象之中

2.既可以通过对象访问，也可以通过类名访问，但是更推荐使用类名访问

3.类变量存储在方法区当中

4.生命周期伴随一生

六。对象的打印：

public class Person{
    String name;
    String gender;
    int age;
    public Person(String name;String gender,int age){
        this.name=name;
        this.gender=gender;
        this.age=age;
    }
    public static void main(String[] args){
        Person person=new Person();
        System.out.println(person);
    }
}

这时我们会发现打印结果为一个地址，那么到底如何进行对象的打印呢

其实只要使用toString方法即可

public class Person{
    String name;
    String gender;
    int age;
    public Person(String name;String gender,int age){
        this.name=name;
        this.gender=gender;
        this.age=age;
    }
    public String toString(){
        return "[" + name + "," + gender + "," + age + "]";
    }
    public static void main(String[] args){
        Person person=new Person();
        System.out.println(person);
    }
}

这里的toString其实是可以自动生成的

step1：右击鼠标

step2：找到generate

step3：找到toString

step4：选择想要打印的对象

这样编译器就会自动的生成一串对应的代码，这样及方便又简单

当然，如果想要return别的值也是可以的，只要把自动生成return后面的部分的内容删去换成自己想要的内容即可；