栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

【Java类与对象之基础】

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

【Java类与对象之基础】

对象 一、类与对象 类与对象概念:
  1. 类:类是抽象的,概念的,是一类事物的特征的集合体,代表的是一类事物;类是一种数据类型
  2. 对象:对象是具体的,是实际的,代表的是某一类事物中具体的个体,即实例。
  3. 类是对象的模板,对象是类的一个个体。
创建对象
  1. 先声明再创建:

    Cat cat;  //声明
    cat = new Cat();  //创建
    

    ​

  2. 直接创建

    Cat cat = new Cat();
    

    ​

    对象属性的访问:

    对象名.属性名;
    

    ​

对象的内存分配机制
  1. 实例化对象才会开辟对象空间
  2. new一个对象,就是在实例化一个对象;
package com.muyu.javase.object;

public class ObjectDemo1 {
    public static void main(String[] args) {
        Cat cat = new Cat();//实例化对象
        cat.name = "小橘"; //初始化对象属性
        cat.age = 2;
        cat.weight = 2.5;

        System.out.println(cat.name);
    }

}

//定义猫类
class Cat{
    //声明类属性
    String name;
    int age;
    double weight;

}

Java内存的结构分析:

  1. 栈:一般存放基本数据类型(局部变量);
  2. 堆:存放对象、数组等;
  3. 方法区:常量池(常量,字符串),类加载信息;

对象内存分配机制:

  1. 实例化对象后,先在方法区加载类的属性和方法信息;

  2. 在堆区依据类的信息,开辟对象空间(对象属性未初始化时,使用的是数据的默认值),并依据属性数量在对象空间内部开辟属性空间存储属性值

  3. 初始化对象属性:如果属性是基本数据类型,则直接存在在对象空间内部的属性空间内;

    如果是引用数据类型,则属性空间存储的是引用数据的空间地址,String数据类型的空间地址在方法区的常量池中。

(1)实例化对象;(2)加载类信息;(3)开辟对象空间;(4)(5)(6)初始化对象属性;

二、类属性/成员变量:
  • 属性也叫成员变量,是类的一个组成部分,一般是基本数据类型,也可以是引用类型(对象,数组)
//定义猫类
class Cat{
    //类属性
    String name;
    int age;
    double weight;

}
  • 属性声明:
访问修饰符 数据类型 属性名;//属性声明:
访问修饰符(public, protected, private.默认default)
  • 属性如果不赋值,使用的是对应数据类型的默认值。
三、成员方法: 1、方法定义:
  1. 有返回值
修饰符 返回数据类型 方法名(形参列表){
  方法体;
  return 返回值;
} 
  1. 无返回值
访问修饰符 void 方法名(形参列表){
  方法体;
} 

使用成员方法可以提高代码的复用性

2、方法注意事项和使用细节
  • 方法定义注意事项

    1访问修饰符(作用是控制方法使用范围:public, protected, private.默认default

    2、如果方法要求有返回数据类,则方法体中必须有(return 值;)语句,而且返回值类型必须和return的值类型一致或者兼容。

    3、一个方法最多有一个返回值,如有多个可以返回数组;

    4、如果是void 修饰的方法,可以没有return语句,或者只写return;

    5、方法命名遵循驼峰命名,见名知义。

  • 形参列表注意事项

    • 一个方法可以有0个或者多个参数,中间用逗号隔开;
    • 调用带有参数的方法时,要对应着形参列表传入相同数据类型或者兼容的实参
    • 方法定义是的参数是形式参数,方法调用时传入的参数是实际参数。
    • 参数可以是任意数据类型,包含基本类型和引用类型。
  • 方法调用细节

    • 同一个类中的方法调用,直接使用方法名() 调用。有参数就传入参数
    • 跨类的方法调用,需要先实例化对象,再通过对象.方法名(),调用。有参数就传入参数
    • 跨类的方法调用与访问修饰符有关。
package com.muyu.javase.object;


public class ObjectDemo2 {
    public static void main(String[] args) {
        //创建对象
        People ultraman = new People();
        ultraman.height = 54;
        ultraman.age = 18;
        ultraman.name = "迪迦";
        System.out.println("我叫"+ultraman.name+";"+"我"+ultraman.age+"岁了;"+"我是一名"+People.race);//我叫迪迦;我18岁了;我是一名奥特曼
        ultraman.speek();//我是奥特曼;我要打小怪兽
        ultraman.calculate(100);//我会计算1-100的和:5050
        int sum = ultraman.getSum(5,26);//有返回值需要一个变量进行接收
        System.out.println(sum);//31
    }
}
class  People{
    static String race = "奥特曼"; // 类变量,这个类的属性,可以通过对象.属性名/类名.属性名获取;可以在类的内部同伙类名.属性名调用
    int age ;       //对象变量,只能通过对象.属性名获取; 不能在类的内部调用
    int height;
    String name;

    public void speek(){
        String name = People.race; // 调用类属性
        System.out.println("我是"+name+";"+"我要打小怪兽");
    }
    void calculate(int n){
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
        }
        System.out.println("我会计算1-"+n+"的和:"+sum);
    }
    int getSum(int a, int b){
        int sum = a + b;

        return sum;
    }

    int getSum100(){
        int a = 41;
        int b = 59;
        int sum = getSum(a,b); //直接调用getSum方法
        return sum;
    }
}

3、方法调用机制

  1. 创建对象
  2. 方法区加载类信息(属性,方法)
  3. 开辟对象空间;
  4. 调用方法,在栈区开辟临时的方法执行的独立空间,方法执行完毕,空间销毁;
  5. 返回主方法继续执行后面的程序语句
4、成员方法传参机制(重点)
  • 基本数据类型的传参
package com.muyu.javase.object;

public class ObjectDemo3 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        Calcurlate cal = new Calcurlate();
        cal.getSum(a,b); // 120;a:100
        System.out.println(a+b+";"+"a:"+a); //30;a:10
    }
}
class Calcurlate{
    public void getSum(int a,int b){
        a = 100;
        int sum = a + b;
        System.out.println(sum+";"+"a:"+a);
    }
}

1、实例化对象;

2、加载类信息;

3、返回对象空间地址(cal是对象空间地址的引用);

4、调用对象方法,在栈区开辟临时执行方法的独立空间;

5、对象方法执行完毕,返回执行main方法后面语句,独立空间销毁,变量也被回收。

基本数据类型的传参是 值传递(只拷贝),方法内数据的修改,不会对原数据产生影响

  • 引用数据类型的传递
package com.muyu.javase.object;

public class ObjectDemo4 {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,5};
        Array cal = new Array();
        System.out.println("cal对象方法执行");
        cal.alterArray(a); //10 2 3 4 5
        System.out.println("n"+"main方法执行");
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+ " "); //10 2 3 4 5
        }
    }
}
class Array{
    public void alterArray(int[] a){
        a[0] = 10;
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
    }
}

1、创建数组空间,并返回数组空间地址(a是数组空间地址的引用)

2、创建对象,加载类信息;

3、开辟对象空间

4、返回对象空间地址(cal是对象空间地址的引用)

5、调用对象方法,在栈区开辟临时执行方法的独立空间;

6、此时传递的参数是数组空间的地址,指向的0x1001这个数组,通过索引修改数组的元素。

7、方法执行完毕,销毁独立空间,返回main方法继续执行后续语句,此时main方法中的a指向的数组已经被修改。

package com.muyu.javase.object;

public class ObjectDemo5 {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,5};
        Array2 cal = new Array2();
        System.out.println("cal对象方法执行");
        cal.alterArray2(a);  //10 0 0 0 0 
        System.out.println("n"+"main方法执行");
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+ " "); //1 2 3 4 5
        }
    }
}
class Array2{
    public void alterArray2(int[] a){
        a = new int[5];  //a重新指向了一个新的数组空间,与传入的参数数组断开联系
        a[0] = 10;    
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
    }
}

当形参是引用类型时,成员方法传参数时,实际传递的是引用类型的空间地址的引用。通俗来讲,就是传入的引用类型的一个名称代号,如果在方法内部不将这个名称代号指向另外一个相同的引用类型或者指向空,那么在方法内,这个名称代号就是表示那一个数组,对其做的任何修改,都会影响原数据。

一个引用类型的空间地址可以有多个变量进行引用,但一个变量只能引用一个空间地址,如果要引用别的空间地址,就需要断开与原来空间地址的引用。

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/973115.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号