JAVA类和对象的详细学习笔记加代码

6 篇文章 0 订阅
本文详细讲解了Java中的类与对象概念,包括对象定义、类的抽象、创建过程、静态与非静态方法区别、源文件多类、引用与实例、String比较、equals与toString重写,以及数组与对象的共同点、构造方法、可变长参数和This关键字的应用。
摘要由CSDN通过智能技术生成

类和对象的详细笔记加代码

1、对象的定义:

对象是看得见的,比如学生张三

万事万物皆为对象
对象由属性和行为组成
对象的属性描述的是对象的特征
对象的行为指的是对象具有哪些功能

在java中,属性和行为又叫做成员变量和方法

2、类的定义:

是抽象的,比如一个班的学生,他们都有名字和学号
类是对具有相同属性和特征的同一对象的抽象

3、对象的创建过程:

从现实世界中—>抽象出属性和行为—>封装成类—>创建对象

创建一个Student类

package test_oop;

public class Student {
    //类定义了属性和行为
    //属性
    String name;
    int sno;

    //行为
    public void study(){
        System.out.println("学习");
    }

}

再创建一个测试类

package test_oop;

import java.sql.SQLOutput;

//测试类
public class Test {


    public static void main(String[] args) {
        int a = 10;
        //1.类是一种自定义的数据类型(引用类型),类似于int (类型) a(变量名) = 10(赋值)
        //2.类是对象的模板

        //创建对象后,该对象的属性会默认赋值
        Student student1 = new Student();
        System.out.println("student1.name:"+student1.name);//student1.name:null
        System.out.println("student1.sno:"+student1.sno);//student1.sno:0

        //可以再赋值,覆盖默认值
        student1.name="张三";
        student1.sno=001;
        System.out.println("student1.name:"+student1.name);
        System.out.println("student1.sno:"+student1.sno);

        System.out.println("---------------");
        //声明变量
        int a2;
        //后赋值
        a2 = 20;
        //创建对象也可以先声明,再赋值
        Student student2;
        student2 = new Student();
        student2.name = "李四";
        student2.sno = 002;
        System.out.println("student2.name:"+student2.name);
        System.out.println("student2.sno:"+student2.sno);


    }
}

4、类的定义顺序:

1.先定义一个类
public class 类名{}

2.定义类的属性(成员变量)
访问修饰符 类型 变量名;

3.定义类的方法
访问修饰符 返回值类型 方法名(参数){}

注意:一个类中可以只定义属性或者方法,两者也可以同时定义,若什么也不定义的话,这个类就没有意义。

5、静态方法和非静态方法被测试类调用的区别

静态方法:类名.方法名()
非静态方法:对象.方法名()

有以下举例:

package test_oop;

public class Car {
    //成员变量
    String brand;
    double price;

    //非静态方法
    public void sumPrice(int num){//返回值类型为void
        System.out.println("汽车总价格为:"+num*price);
    }
    //静态方法
    public static void run(){
        System.out.println("汽车在跑---");
    }

}
package test_oop;

import java.util.Scanner;

public class TestCar {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        Car car = new Car();
        car.price = 200000;
        int num = scan.nextInt();
        System.out.println("买了"+num+"辆汽车");
        //调用非静态方法 对象.方法
        car.sumPrice(num);
        //调用静态方法 类名.方法
        Car.run();
    }
}

6、一个源文件中可以有多个类吗?

在一个源文件中可以有多个类,但只有一个是public修饰的类,public修饰的类的名称一定要与源文件的名字一样。
举例如下:

package test_oop;

public class TestClass {//public修饰的类
}

class MyTest{}
class MyTest1{}
class MyTest2{}

如果一个源文件中没有public修饰的类
则可以命名与类名不同的名称

package test_oop;



class MyTest{}
class MyTest1{}
class MyTest2{}

7、引用和实例(对象)的区别

引用保存了对象的首地址,创建一个实例(对象)的过程,也就是实例化的过程。
过程:在new 构造方法()的过程中,为创建的对象分配堆内存,内存中存储了这个对象的属性和属性值。

在下面的测试类中 stu1和stu2是不同的对象,它们的的地址值不通过

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


        Student stu1 = new Student();
        System.out.println("stu1的地址:"+stu1);
        //stu1的地址:test_oop.Student@4554617c

        Student stu2 = new Student();
        System.out.println("stu2的地址:"+stu2);
        //stu2的地址:test_oop.Student@74a14482
    }
}

8、String类型的地址(==)和值(equals)的比较

package test_oop;

public class TestString {
    public static void main(String[] args) {
        String s1 = new String("name");
        String s2 = new String("name");
        System.out.println("s1=" + s1);//s1=name String类中重写了toString 方法
        System.out.println("s2=" + s2);//s1=name

        System.out.println("s1 == s2" + (s1 == s2));//s1 == s2false 比较的是地址
        System.out.println("s1.equals(s2)"+s1.equals(s2));//s1.equals(s2)true 比较的是值
    }
}

9、自定义类型的equals()重写,toString()重写

在Student类中重写equals(),toString()

package test_oop;

public class Student {
    //类定义了属性和行为
    //属性
    String name;
    int sno;

    //行为
    public void study(){
        System.out.println("学习");
    }

    public String getName() {
        return name;
    }

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

    public int getSno() {
        return sno;
    }

    public void setSno(int sno) {
        this.sno = sno;
    }

//    重写toString()输出stu对象的时候自动调用
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", sno=" + sno +
                '}';
    }
//重写equals(),调用的时候比较的是stu1.name和stu2.name
    @Override
    public boolean equals(Object obj) {
        Student stu = (Student) obj;
        return name.equals(stu.name);
    }
}

在测试类中测试重写的方法

package test_oop;

public class TestToStringEquals {
    public static void main(String[] args) {
        Student stu1 = new Student();
        stu1.setName("stu2");
        Student stu2 = new Student();
        stu2.setName("stu2");

        //没有重写时,输出的是对象的地址,比较的是对象的地址
        /*System.out.println("stu1:"+stu1);//stu1:test_oop.Student@4554617c
        System.out.println("stu2:"+stu2);//stu2:test_oop.Student@74a14482
        System.out.println(stu1.equals(stu2));//false*/

        //重写后,输出的是stu1.sno..对象的名字,学号,比较的是名字
        System.out.println("stu1:"+stu1);//stu1:Student{name='stu2', sno=0}
        System.out.println("stu2:"+stu2);//stu2:Student{name='stu2', sno=0}
        System.out.println(stu1.equals(stu2));//true

    }
}

10、引用类型 数组和自定义对象的共同点:

两者都是引用类型,在引用2=引用1时,两者指向的是同一个地址,两者的值相互影响,对象1的值改变,对象2中的值同样要改变

参考测试代码

package test_oop;

public class TestArrayClass {
    public static void main(String[] args) {
        //数组和自定义对象的共同点
        int[] a = new int[3];
        a[0] = 10;
        changeArray(a);//相当于 int b = a
        System.out.println(a[0]);//20

        Student student = new Student();
        student.name = "lili";
        changeStudent(student);//相当于 Student student2 = student
        System.out.println(student.name);//zs
    }


    /**
     * 改变数组的值
     * @param b
     */
    private static void changeArray(int[] b) {
        b[0] = 20;
    }

    /**
     * 改变对象的属性值
     * @param student2
     */
    private static void changeStudent(Student student2) {
        student2.name = "zs";
    }
}

11.构造方法

每一个类中都必须有构造方法,且至少有一个
(1)构造方法在程序中的调用方式是,new 类名(),类名()是构造方法,与成员方法相区分,对象.方法。
(2)在一个类中没有构造方法,程序中也会自动的生成一个默认的空构造方法,而成员方法必须创建才能调用。
(3)如果在一个类中定义了有参的构造方法,程序不会子动的生成默认的空构造方法,因此需要自己去定义一个默认的构造方法。
(4)构造方法的特征:public(修饰符) 没有返回类型 类名()
(5)构造方法的作用:创建对象,分配内存空间,给对象的属性赋初值,成员方法的作用是创建对象的行为。
(6)构造方法分为默认的构造方法(隐式的构造方法,两者型式一样),有参构造方法

如上面的第三点所述:

public class Student {
    //类定义了属性和行为
    //属性
    String name;
    int sno;

    public Student() {//无参的构造方法
    }
    public Student(String name){//有参的构造方法
        this.name = name;
    }
}
package test_oop;

public class Test3 {
    public static void main(String[] args) {
        Student student = new Student("lisi");//给属性赋初值
        System.out.println(student.name);//lisi
    }
}

12.方法中的可变长参数

只能放在方法的参数的末尾,且一个方法只有一个可变长参数

package test_oop;

public class Test4 {
    public static void main(String[] args) {
        printStr(3,"hello");
        printInt(3,5,6,7);
    }
    public static void printStr(int a,String s){//非可变长参数
        for (int i = 0; i < a; i++) {
            System.out.println(s);
            //hello
            //hello
            //hello
        }
    }
    public static void printInt(int a,int... b){//可变长参数本质上就是数组
        for (int i = 0; i < a; i++) {
            System.out.println(b[0]);
            System.out.println(b[1]);
            System.out.println(b[2]);
            //5 6 7

        }
    }
}

13.This关键字

目的,区分成员变量和局部变量
package test_oop;

public class Car {
//成员变量
String brand;
double price;

public Car(){//构造方法也可以方法重载
    this("大众");//调用当前类的有参构造 不能使用Car("大众")
    System.out.println("无参构造");
}
public Car(String brand){

    System.out.println("有参构造");
    this.brand = brand;//调用当前类的属性
}
//非静态方法
public void sumPrice(int num){//返回值类型为void

    System.out.println("汽车总价格为:"+num*price);
}
//静态方法
public void run(){
    this.sumPrice(200000);//this.方法 调用当前类的方法
    System.out.println("汽车在跑---");
}

public static void main(String[] args) {
    Car car = new Car();//先调用Car() 在调用Car("大众")
    //有参构造
   // 无参构造
    car.run();
    //汽车总价格为:0.0
    //汽车在跑---
}

}

14.类的方法重载(overload)
定义:在一个类中,具有二个或以上的同名方法,且方法的参数(个数,类型,顺序)不同,与返回值类型无关

package test_oop;

import java.sql.SQLOutput;

public class Test6 {
    public static void main(String[] args) {
        Test6 t = new Test6();
        t.testMethod("1");
        t.testMethod(2);
        t.testMethod("第三个",3);
        t.testMethod(4,"第四个");

    }
    public void testMethod(String s){
        System.out.println("第一个");
    }
    public void testMethod(int a){
        System.out.println("与第一个类型不同");
    }
    public void testMethod(String s,int a){
        System.out.println(s+"与第一个数量不同");
    }
    public void testMethod(int a,String s){
        System.out.println(s +"与第三个顺序不同" );
    }

}

15.Package 包名

小写字母命名
命名方式:com.公司名.项目名.模块名

16.导包

使用Java.lang下的类不用导包
可以通过类名.方法/属性名,创建对象使用如Math.PI Math.abs(-3)等等
静态导包(不推荐,可读性差,不知道变量和方法的来源)

三者在类中的顺序

package test_oop;//1

import java.util.Scanner;//2
import static java.lang.Math.*;//静态导包不推荐

public class Test5 {//3
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);//导包 java.util 不导包可以使用java.util.Scanner
        String name = sc.next();
        System.out.println("sname:"+name);

        System.out.println(PI);//不知道来源 *
        System.out.println(Math.random());//使用Java.lang下的类不用导包
    }
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

陈lr

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值