手把手教会你Java的面向对象(入门篇)

手把手教会你Java的面向对象(入门篇)

1.类和对象

类是什么

类是一种自定义的类型,也是一种模型.

类是一种对象的统称,而对象是这种类的具体实现

对象是一个又一个根据设计图设计出来的房子.

2.如何创建对象

1. 第一步:做出房子的设计图
2. 第二步:根据设计图造出具体的房子
3. 第三步:定义出一个类,
4. 第四步: 根据类来实例化对象

类的定义

通过class关键字来定义类(命名方式必须采用大驼峰来命名,

如果是两个单词,则两个单词的首字母必须大写)

//定义了一个名为Animal的类
public class Animal{
    
}

//定义一个名为(ComputerGame)电脑游戏的类(大驼峰的方式)
class ComputerGame{
    
}

类里面有什么

1.** 成员变量(成员属性)**
2. 成员方法(动作,行为)

成员变量是用来描述类
成员方法是用来说明类有哪些动作和功能

//定义了一个名为Animal的类
public class Animal{
    //定义了成员属性
    public String name;  //成员属性,描述这个动物类的名字
    public int age;   //成员属性,描述动物的年龄
    
    public void eat(){     //成员方法.描述这个动物类的动作和功能
        System.out.println("eat()");
    }
}

小tips:

1. 类名必须采用大驼峰
2. 一个文件名中只能有一个public修饰的类(且public修饰的类名必须与文件名保持一致)
3. 成员属性的位置定义在类的里面,成员方法的外面

如何创建对象

对象是通过new关键字来创建的

Animal animal = new Animal();

public static void main(String[] args){
    Animal animal = new Animal();
}

此方式称为类的实例化,

通过new关键字创建了(实例化了)一个名为animal的对象,

此时会在堆内存上开辟出来一块空间,空间里面存放成员属性和成员方法,

这块空间会有一个地址(0x9),0x9会被赋给一个名叫animal的变量,此变量称作对象的引用.

animal只是一个引用,内存图如下

如何访问成员属性和成员方法

public static void main(String[] args){
    //创建了(实例化了)一个名为animal的对象
    Animal animal = new Animal();
    
    //通过对象的引用来访问对象的属性和方法
    System.out.println(animal.name);
    System.out.println(animal.age);
}

小tips:

1. 同一个类可以创建多个不同的对象(同一张设计图可以设置多个房子)
2. 通过new关键字来创建对象(new出来的对象都在堆中存储)
3. 类只是一个设计图(模版),不占用内存,而new出来的对象实际占用堆中的内存
4. 通过对象的引用.来访问对象的属性
5. 在没有给对象的属性赋值之前,都会自动初始化
6. 引用数据类型赋值为null,基本数据类型赋值为0

数据类型初始化的值

1. int ------> 0
2. float ------> 0.0f
3. char ------> ‘\u0000’
4. boolean ------> flase

注意:局部变量必须自己初始化,否则会报错

3.构造方法

作用:为对象当中的成员进行初始化,但不是开辟空间

//定义了一个名为Animal的类
public class Animal{
    //定义了成员属性
    public String name;  //成员属性,描述这个动物类的名字
    public int age;   //成员属性,描述动物的年龄
    
    //定义了一个无参的构造方法
     public Animal(){
         System.out.println("无参的构造方法");
    }
   

    //定义了一个有参的构造方法
    public Animal(String name, int age){
        this.age = age;
        this.name = name;
        System.out.println("有参的构造方法");
    }
    
    public void eat(){     //成员方法.描述这个动物类的动作和功能
        System.out.println("eat()");
    }
}

小tips:

1. 构造方法分为无参的构造方法和有参的构造方法
2. 构造方法的名字必须和类名一样
3. 构造方法没有返回值,也不能用void
4. 若类中没有写构造方法,则编译器会自动提供一个无参的构造方法
5. 构造方法可以重载

例子如下

public static void main(String[] args){
    //创建了(实例化了)一个名为animal的对象
    Animal animal = new Animal();//此时也会调用无参的构造方法
    
    Animal animal8 = new Animal("小猴",23);  //此时会调用有参的构造方法   
   
}

this()

首先this代表当前对象的引用

而this()表示:在当前类中的一个构造方法内部去调用其他的构造方法(有点绕哈,咱们直接上手代码)

public class Animal{
    //定义了成员属性
    public String name;  //成员属性,描述这个动物类的名字
    public int age;   //成员属性,描述动物的年龄

    public Animal(){
        //此时无参的构造方法被调用时,执行以下代码,
        this("小黄",24);//这个this()会去调用有参的构造方法,并且把name和age初始化
        System.out.println("无参的构造方法");
    }

    public Animal(String name, int age){
        this.age = age;
        this.name = name;
        System.out.println("有参的构造方法");
    }
}


class Text {
    public static void main(String[] args) {
        //创建了(实例化了)一个名为animal的对象
        Animal animal = new Animal();//调用无参的构造方法,
        
        System.out.println("=================");
            
        System.out.println(animal.name);//打印初始化好的name和age
        System.out.println(animal.age);

    }
}

this

先说结论: this的作用:代表当前对象的引用,采取就近原则

public class Year {
    public int year;
    public int month;
    public int day;

    public Year(int year, int month, int day) {
        year = year;       //第一行
        month = month;     //第二行
        day = day;         //第三行
    }

    
    public Year() {
    }
}


class Text{
    public static void main(String[] args){
        Year year = new Year(2008,8,8);
        System.out.println(year.year);
        System.out.println(year.month);
        System.out.println(year.day);
    }
}

输出结果为0：

为什么？

上面代码中有参构造方法中的第一，二，三行都只是局部变量的赋值 ，2008的确赋值给了year，8赋值给了month，8赋值给了day，

但是！！！

这个year，month，day都只是这个构造方法内部的局部变量而已！！！

局部变量并不能影响到new出来的对象当中的属性(此时对象当中的属性依旧没有被赋值)

那我们应该怎么办呢？

啊哈，Java当中的this关键字就是解决这类问题的。

如果我们将上面的代码换成：

public class Year {
    public int year;
    public int month;
    public int day;

    public Year(int year, int month, int day) {
        this.year = year;       //第一行
        this.month = month;     //第二行
        this.day = day;         //第三行
    }

    
    public Year() {
    }
}


class Text{
    public static void main(String[] args){
        Year year = new Year(2008,8,8);
        System.out.println(year.year);
        System.out.println(year.month);
        System.out.println(year.day);
    }
}

执行结果为：

因为this代表了对象的引用,但是静态的成员变量不支持this,因为静态的成员变量是属于类的,不是属于对象的.

4.static关键字

静态成员变量

1. 当成员变量被static关键字修饰之后,叫做类变量

2. 不属于某一个具体的对象,而是属于整个类,由所有对象共享.

3. 而且内存上也不在new出来的堆里面了,而是在方法区里面了.

4. 不用通过对象引用访问,直接通过类名.访问

//创建一个名为Month的类
public class Month {
    //初始化一个静态成员变量为小周
    public static String name = "小周";
}
class Text1{
    public static void main(String[] args) {
        //可直接通过类名.静态成员变量名来访问
        System.out.println(Month.name);
    }
}

静态成员方法

由static修饰的成员方法,叫做静态成员方法

注意:

1. 非静态的方法可以调用静态的方法和成员,也可以调用非静态的
2. 静态的方法不可以直接调用非静态的成员,必须要先创建对象来调用
3. 类变量声明周期在类上,存储在方法区上
4. 因为静态方法不依赖于对象,所以内部不能使用this

public class Text3 {
    public Text3() {

    }

    //定义一个静态的方法eat()
        public static void eat(){
            System.out.println("吃饭了");
            //show();  //运行失败,因为在静态方法中不能直接调用非静态的方法
            System.out.println("===============");
    }

        //定义一个非静态的方法show()
        public void show() {
            eat(); //调用了静态的方法,没事哒,可运行
            System.out.println("展示");
    }

    public static void main(String[] args) {
        eat(); //可以直接运行的
        show();  //运行出错,因为在static方法中不能直接调用非静态方法
        Text3 test = new Text3(); //要先创建对象,再通过对象的引用去调用
        test.show();         //再通过对象的引用去调用
    }

}

总结

1. 类是一个模版,设计图,而对象是根据设计图建造出来的实体化的房子,
2. 对象的创建过程分为两步
3. 第一步:通过new关键字在堆中开辟出一块内存
4. 第二步:通过调用构造方法对对象进行初始化
5. this关键字代表当前对象的引用
6. static修饰的成员属于类,不属于对象了.

以上就是本次面向对象的入门篇,还有很多不足,希望各位友友可以指出!!!