类与对象

对象instance

含义：一种数据结构(对数据的管理模式)，存放数据和数据的行为。

内存上：一块存放数据集合的内存块!。

对象本质：一种数据的组织方式。

类

组成：

  • 成员变量:属性[描述信息]

  • 成员方法:行为[能做的事]

对象与类的关系

  • 1.对象是具体事物，类是对对象的抽象。

  • 2.可理解位：类是对象的一种模板，对象是类的一个具体实例。

  • 3.类描述同一类型对象的一个抽象概念，类中定义了这一类对象所应具有的共同的属性方法。

举例:飞机设计图就相当于类(抽象虚拟),真正制造出来并呈现在你面前的飞机是new出来的对象(现实) 。

示例：

package com.itcode.demo3;  

import java.util.Arrays;  

/** 
 * @Auther: 成都码到功成学员 
 * @Description: 
 */  
public class Test {  
    // 属性  
    int age;  
    String name;  

    // 方法  
    public int getAge() {  
        return age;  
    }  
    // 方法  
    public static void main(String[] args) {  
        // new Test()代表创建了对象。并把对象地址值赋给局部变量t。  
        Test t = new Test();  
    }  
}

属性

类或类对象包含的数据。作用域是整个类体。

定义成员变量时可以对其初始化，如未定义，Java使用默认值对其初始化。

Java默认初始化值：

数据类型

默认值

整型

0

浮点型

0.0

字符型

‘\u0000’

布尔型

false

所有引用类型

null

示例：

package com.itcode.demo3;  

import java.util.Arrays;  

/** 
 * @Auther: 成都码到功成学员 
 * @Description: 
 */  
public class Test {  
    // 属性  
    int age;  
    String name;  

    // 方法  
    public int getAge() {  
        return age;  
    }  
    // 方法  
    public static void main(String[] args) {  
        // new Test()代表创建了对象。并把对象地址值赋给局部变量t。  
        Test t = new Test();  
        System.out.println(t.name);// null 引用类型  
        System.out.println(t.age);// 0 基本类型  
    }  
}

java虚拟机内存

内存分为栈stack、堆heap、方法区method area。

栈：

    1. 每个方法被调用都会创建一个栈帧/线程(存储局部变量、操作数、方法出口等)。

    1. 栈是线程私有，线程间不能共享。

    1. 存储特性：先进后出。

    1. 栈由系统自动分配，速度快。栈内存空间连续。

堆：

    1. 存储创建好的对象和数组(数组也是对象)。

    1. 堆只有一个，被所有线程共享。

    1. 堆是不连续的内存空间，分配灵活，速度慢。

方法区：

    1. 方法区只有一个，被所有线程共享!

    1. 方法区实际也是堆。

    1. 存放程序中永远不变或唯一的内容。存储类信息【Class对象】、静态变量/方法、常量等。

关于对象与类关系的示例代码分析

重点必看

当class文件被加载至JVM里面时，会执行静态的main方法，同时在栈为main方法开启一个栈帧。

找到类型为TextStu定义的stu变量,目前它的值为null。

执行到new TextStu()的时候，会去调用TextStu类默认提供的无参构造方法，同时会在栈为构造方法开启开启栈帧。

构造方法执行完毕会在堆开辟一块TextStu对象的空间，类的属性与方法加载至对象中，并为属性分配初始化值。

堆会为TextStu对象分配一个地址值15db9742，把地址值赋值给变量stu。当我们使用stu时，stu会根据地址值15db9742去堆里面寻找。

执行到“stu.id = 2002;”，内存中id的值变为2002。执行到“stu.name = "成都码到功成"”，把方法区中的"成都码到功成"的地址值告诉给堆中的name。当你调用stu.name时，会在堆内存对象里面再根据地址值去找到方法区的"成都码到功成"，并将这个值给stu.name。记住，堆里面的name的值并不是"成都码到功成"，它的值只是字符串常量的地址值！类似的操作下去内存中age的值变成20。

执行到“Computer com”同时也会在栈main方法栈帧里面建立一个变量com，初始化值为null。

执行到“new Computer()”，会调用Computer类默认提供的无参构造方法，在栈里面为Computer类开启一个新的栈帧。

在堆里面为Computer类开辟一块空间，并把类的属性brand加载至内存，为其分配值null。

为空间分配地址值6d06d69c，并把6d06d69c给变量com，把变量com和名字为6d06d69c的内存空间关联起来。

执行到“com.brand = "神舟"”，把方法区的字符串“神舟”的地址值给brand。

执行到“stu.computer = com”，记住这里是把变量com的内存地址值赋值给stu.computer。所以堆里面15db974内存空间里面的属性computer的值就是Computer地址值6d06d69c。

当我们调用方法eat()时，打印“学生吃饭……”。

调用study方法时，study方法里面有“computer.brand”。computer属性是地址值6d06d69c，computer.brand就是6d06d69c.brand。brand有对字符串“神舟”的引用，所以study()方法的打印结果就是“学生学习电脑，请选神舟”。

注意：构造方法栈帧出栈时机：在堆开辟完空间并把地址值给常量stu/com时。

示例：

package com.itcode.demo;  

/**      
 * @author: 成都码到功成学员  
 * @description:  
  * 对象与类 
  * 学生类示例 
 */  
class Computer{  
    String brand;  
}  
public class TestStu {  

    // 成员属性  
    int id;  
    String name;  
    int age;  

    // 引用计算机  
    Computer computer;  

    // 成员方法  
    public void study() {  
        System.out.println("学生学习电脑，请选" + computer.brand);  
    }  

    public void eat() {  
        System.out.println("学生吃饭……");  
    }  

    // 程序执行入口  
    public static void main(String[] args) {  
        // TODO Auto-generated method stub  
        TestStu stu = new TestStu();// 创建对象，//系统默认提供无参构造方法（作用：创建类的对象）  
        // com.itcode.demo.TestStu@15db9742的15db9742是TestStu对象在堆中的地址值。  
        System.out.println("TestStu地址值：" + stu);   
        stu.id = 2002;  
        stu.name = "成都码到功成";  
        stu.age = 20;  
        Computer com = new Computer();  
        System.out.println("Computer地址值：" + com); // 6d06d69c  
        com.brand = "神舟";  
        stu.computer = com;  

        // 调用方法  
        stu.eat();  
        stu.study();  
    }  
}

效果：

匿名对象

没有名字的对象，比如new Stu()，对象在堆内存已经产生，但没有实际引用。

基本使用：

  • 1、方法中作为实参进行参数传递；

  • 2、只调用一次对象方法时，如new Stu().eat()

注意：对象要进行多个成员操作时，必须给对象起名。

弊端，对象一建立就变成了垃圾，无法再使用，只能使用一次。

方法

代码块/语句块

用花括号扩起的不限数量的Java语句。

代码块之间可以嵌套，嵌套代码块之间不能定义同名变量。

代码块的变量作用域仅限于此代码块，任意内部代码块可以调用外部定义的变量。

方法

  • 1.概述：特供特定功能的代码块。

  • 2.作用：定义类的实例的行为功能实现。是面向对象的核心。

  • 3.格式：

修饰符1,修饰符2,…… 返回值类型 方法名(形参列表){
    java语句……
    Return 返回值;
}

  • 4.术语介绍

形参：接收外界传入的数据。

实参：调用方法时实际给方法的值。

返回值：方法执行完毕返回给调用者的数字。

返回值类型：事先约定的返回值类型。如果无返回时，需把返回值类型定义成void。

注意：

  • 1、所调用方法的形参列表（参数个数、数据类型、顺序）必须和实参匹配。

  • 2、return 语句终止方法运行并指定返回数据。

  • 3、参数传递：基本类型传递值的副本，引用类型传递对象引用值。

示例：

package com.itcode.method;  

/**      
 * @author: 成都码到功成学员  
 * @Description:  
 * 方法使用 
 */  
public class TestMethod {  

    public static void main(String[] args) {  
        // TODO Auto-generated method stub  
        int sum = mAirthmetic(23, 4, 12);  
        System.out.println(sum);  
    }

    // 定义一个乘法  
    public static int mAirthmetic(int a, int b, int c) {  
        int d = a + b +c;  
        return d; //return的作用：1.结束方法。 2.返回值。  
    }  

}

方法重载（overload）

一个类出现一个以上同名方法，只要参数类型不同，与返回值类型无关。

记住，一个类永远不能出现两个完全一模一样的的方法。

构成重载：参数顺序不同，参数个数不同，参数类型不同。

注意：只有返回值或者形参名称不同不构成方法重载。返回值类型不同也不构成重载。

如【int a(int i)与void a(int i)】和【int a(int inx)与int a(int sit)】不构成。

// int a,int b 形参  
public static int add(int a,int b){  
    return a+b;  
}  
public static void main(String[] args) {  
    // 23, 34 实参  
    HelloWorld.add(23, 34);  
}

示例：

package com.itcode.method;  

/**      
 * @author: 成都码到功成学员  
 * @Description:  
 * 方法重载 
 */  
public class TestMethod {  

    public static void main(String[] args) {  
        // TODO Auto-generated method stub  
        int sum =23;  
        System.out.println(sum);  
    }  

    public static int add(int a, int b) {  
        return a + b;  
    }  

    // 参数个数不同构成重载  
    public static int add(int a, int b, int c) {  
        return a + b + c;  
    }  

    // 参数类型不同构成重载  
    public static int add(byte a, int b) {  
        return a + b;  
    }  

    // 参数顺序不同构成重载  
    public static int add(int a, byte b) {  
        return a + b;  
    }  

    // 参数名称不同不构成重载  
    public static int add(int a, byte ab) {  
        return a + ab;  
    }  

    // 返回值类型不同不构成重载  
    public static void add(int a, byte ab) {  
        System.out.println(a + ab);  
    }  


}

递归

关键词：本质、递归头体、耗时。

本质：自己调用自己。爬虫的本质就是递归。

递归头：什么时候不调用自身方法，也就是递归的结束条件，没有头会陷入死循环。

递归体：什么时候调用自身方法。

Previous面向过程和面向对象Next构造方法

Last updated

Was this helpful?