第一章、对象和类

一、面向对象的程序设计

1.抽象的数据类型

2.什么是类

3.总结

二.定义一个类

1.定义类的成员变量

2.定义类的成员的方法

3.类的成员变量和方法总结

4.创建并使用对象

第二章、方法

一.方法的重载

1.方法的标识

2.方法的重载

3.访问重载方法

4.重载总结

二、构造方法

1.构造方法

2.构造方法的作用

3.规则

4.this关键字：

5.this();

第三章、数组

一、引用类型数组

1.数组是对象

2.引用类型数组的声明

3.数组的初始化(重点)

4、数组的元素是基本类型数组（二维数组）

5.总结

第四章、对象内存管理（重点）

一、堆内存

1.对象存储在堆中

2.成员变量的生命周期

3.垃圾回收机制（面试，建议研究）

4.内存泄漏

5.System.gc()方法

二、非堆-栈

1.栈存的是方法中的局部变量

2.局部变量的生命周期

3.成员变量和局部变量的区别

三、非栈-方法区

1.存放类的信息

2.方法只有一份，唯一性

四、堆、栈、方法区的区别

第一章、对象和类

一、面向对象的程序设计

1.抽象的数据类型

将不同类型的数据的集合组成的整体用来描述一种新的事物。
人 : 包含了 (String name , int age ,char sex ,double salary) 4中不同类型的数据组成的整体学生 : 包含了(String name, double score,String grade) 也是不同类型的数据组成的整体
思考 : 人把大象装进冰箱分几步？
人：数据类型有(String name ,int age ....) 功能(人装大象打开冰箱门关上冰箱门)行为大象：数据类型( double weight ,String name) 行为(被人拿起，装进冰箱)冰箱：数据类型( String singe) 行为(关门，开门)
上面所出现的人、学生、大象、冰箱都是一种抽象数据类型----类！

类是Java语言最基本单位。

2.什么是类

类的成员：

属性（成员变量）方法（函数，成员的行为）

public class Person{//该类只定义了4个成员变量

//成员变量 
String name; 
int age; 
char sex; 
double salary; }

3、类的转化过程

打印学生的第一个方法

 

public static void sudentInfo(String name,int age,char sex,double number) {
    System.out.println("---------------"); 
    System.out.println("姓名: " + name); 
    System.out.println("年龄:" + age); 
    System.out.println("性别: " + sex); 
    System.out.println("学号:" + number); 
}

参数中多种不同类型的数据，我们考虑采用抽象数据类型-类来替换参数类型

打印学生信息的第二种方式

package com.hqyj.oop.classes;
//学生类
public class Student {

    String name;
    int age;
    double score;

    //打印学生基本信息的方法--数据和操作数据的行为统
    public  void studentInfo (Student student) {
        System.out.println("姓名:" + student.name) ;
        System.out.println("年龄:" + student.age);
        System.out.println("分数:" + student.score);
    }

}

打印学生信息方法只能针对Student数据操作，是属于Student自身方法，因此没有实现数据与操作数据的行为统一

打印学生信息的第三种方法

package com.hqyj.oop.classes;
//学生类
public class Student {

    //属性
    String name;
    int age;
    double score;

    //打印学生基本信息的方法--数据和操作数据的行为统
    //方法：
    public  void studentInfo (Student student) {
        System.out.println("姓名:" + student.name) ;
        System.out.println("年龄:" + student.age);
        System.out.println("分数:" + student.score);
    }
    public static void main(String[] args) { 
        Student stu = new Student(); 
        stu.sudentInfo(); 
    }
    
}

Student打印学生的信息方法只针对与Student操作，是Student内部的方法。

类的组成：属性(数据本身)和方法(操作数据的行为)

3.总结

类是一种抽象的数据类型

OOP(Object Oriented Programming)面向对象编程实际是分类型思想。将过程种出现的数据泛化称为类。

类的组成:属性和方法

main方法也属于类的方法

二.定义一个类

1.定义类的成员变量

用于描述该类型对象共同的数据结构

public class Student {

    //属性
    String name;
    int age;
    double score;
 }

成员变量如果不赋初始值时，则系统会提供默认的初始值

整型(byte short int long): 默认值为0

浮点型(float double): 默认为0.0

字符型(char):默认为空字符

布尔型(boolean):默认为false

2.定义类的成员的方法

用于描述对象的行为，封装对象的功能。

public class Person { 
//成员方法 ！！！main方法也时类的组成元素之一 
     public void show() { 
       System.out.println("show....") 
    } 
 }

3.类的成员变量和方法总结

1.定义打印学生信息的方法，然后以name、age、score作为参数

2.name、age、score是属于学生类的，因此可以使用参数为Student student

3.打印学生信息的方法属于学生的行为，放在学生类中

4.使用Student类，采用new Student；方式

5.发现new Student（）；不能同时为同一个对象设置多个属性值

6.采用引用的概念,Student s = new Student();

7.通过引用打点的方式，访问定义在类中的属性和方法，--->s.name = "zhangsan",s.studentInfo();

8.类是一个数据类型

4.创建并使用对象

4.1通过使用new（）关键字创建对象

通过 new 类名(); 表示创建了该类的对象，也叫做!类的实例化(instantiation)!

new Person();//实例化人类对象

4.2 引用类型变量

为了能够对实例化的对象进行访问控制，需要使用一个特殊的变量--引用

Person p = new Person(); //p：指向对象的引用

引用存储的是对象的地址信息，"指向对象的引用"。

可以通过引用采用打点的形式访问对象的成员。

在Java中，除了8种基本类型外，其他类型都为引用数据类型--且默认值为null

Person p = new Person();//实例化人类对象 
p.name = "zhang3";//引用访问属性 
p.age = 16; 
p.show();//引用访问方法 

Person p1 = p; 
Person p2 = new Person(); 
p2.name = "zhang3"; 
p2.age = 16; 
p2.show(); 

System.out.println(p == p1);//t p和p1由同样的地址值 System.out.println(p == p2);//f p和p2两个new关键字。只要new就会创建对象，地址就 不一样

4.3引用类型变量的赋值传递：

相同类型之间引用相互赋值

引用类型之间的赋值不会创建新的对象，但有可能会使两个引用指向同一对象

Person p1 = new Person();
Person p2 = new Person();
Person p3 = p2;

System.out.println(p1);//classes.Person@  1540e19d--->散列码（地址）
System.out.println(p2);//classes.Person@  677327b6--->散列码（地址）

System.out.println(p3 == p2);   //true
System.out.println(p2 == p1);   //false

4.4 null和nullPointerException

空指针异常：

对于引用类型变量可以赋值为null，null的含义为“空”，表示没有指向任何对象。

当引用的值为null时,再去调用其成员会抛出nullPointerException

//5.空指针异常
p3 = null;   //斩断p3的联系，引用p3没有任何指向
p3.name = "zhangs";  //没有编译错误，但逻辑不对
// ava.lang.NullPointerException发现运行时异常，空指针异常
//解决空指针异常-->用户输出语句打印当前对象，发现其值是不是为null

4.5总结

1.不同类型组成的抽象！数据类型！---类

2.类的组成有属性和方法

3.属性是成员变量，成员变量有默认的初始值

4.通过new关键字实例化对象

5.通过Person p = new Person();中引用P打点访问定义在类中的属性和方

6.引用数据类型：出了八大基本类型以外，其他所有的类型都为引用数据类型，且默认值为null

“在java中凡是以大驼峰命名法命名的，都为类。都为引用数据类型，且默认值都为null

7.引用存储的是对象的地址值，多个引用可以指向同一个对象

8.一个引用没有任何指向时，即引用的值为null时，再通过引用访问属性和方法会产生异常--空指针异常

第二章、方法

一.方法的重载

1.方法的标识

方法的唯一标识就是: 方法的名字和参数列表

一个类中不能出现两个方法的标识完全一样的方法

2.方法的重载

方法名相同但参数列表不同称为方法的重载

public void show(){} 
//互相构成重载 
public void show(int i) {}
public class Person {
        //属性
        String name;
        int age;
        double salary;
        //方法
    public void show() {
        System.out.println("show.......");
    }
    public void show(int x) {
        System.out.println("show.......");
    }

}

3.访问重载方法

编译器在编译时会根据方法的标识调用不同的方法

4.重载总结

1.方法的唯一标识(方法的签名）：方法名和参数列表

2.一个类中不能出现两个方法签名完全相同的方法

3.但是可以出现方法名相同，但参数列表不同的两个方法互相构成重载

二、构造方法

1.构造方法

方法的名字与类名相同

不写返回值类型

在new Person（）中执行Person的构造方法

ublic class Person {
        //属性
        String name;
        int age;
        double salary;
        //构造方法
    
    public Person() {
        System.out.println("Person...constructor...");
    }
    }

}

2.构造方法的作用

能够创建一个具备初始属性的对象

给对象属性进行初始化的

3.规则

当没有显式的定义构造方法，系统会提供一个默认的无参构造

当显式的写出了一个任意的构造方法，系统就不默认提供无参构造了

构造方法的重载，提供初始化的属性不一致

 public Person() {
        System.out.println("Person...constructor...");
    }
    //构造方法的重载

    public Person(String name,int age,double salary) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

4.this关键字：

区分属性和参数

为了增加代码的可读性，构造方法的参数名字和属性名应保持一致，

为了区分构造方法的参数和属性同名问题，所以使用this

this；指当前对象，谁调用了属性或者方法，this就指谁！！！

public Person(String name,int age,double salary) {
   
    this.name = name;
    this.age = age;
    this.salary = salary;

}

5.this();

---1.必须放在构造方法的第一行！

---2.等同于调用了对应参数的无参构造方法

---3.只能用在当前类对象中

public Person(String name,int age,double salary) {
    this();
    this.name = name;
    this.age = age;
    this.salary = salary;

}

第三章、数组

一、引用类型数组

1.数组是对象

数组是引用数据类型

数组对象在堆中创建，声明的变量是引用类型，引用存储的是数组对象的地址值，指向数组对象

可以将数组中的元素看成对象的成员变量，只不过类型完全一致而已。

2.引用类型数组的声明

数组的元素可以为任意类型，当然也可以为引用类型。

引用类型数组元素存储的不是对象本身，而是存储元素对象的引用

3.数组的初始化(重点)

数组元素的默认值都为null。

如果希望每个元素都指向具体的对象，则需要对每一个元素都使用new创建实例。

//1.person数组---引用类型
Person[] person = new Person[3];
System.out.println(Arrays.toString(person));

//2.对引用类型少数组赋值
person[0] = new Person("zhang2",25,10000);
person[1] = new Person("liu6",22,8000);
person[2] = new Person("wang2",23,10000);

4、数组的元素是基本类型数组（二维数组）

//1.二维数组----数组的元素为基本类型数组
//一维数组：
int[] arr1 = new int[3];
int[] arr2 = {1,2,3};
int[] arr3 = new int[]{1,2,3};

//二维数组
int[][] arrs1 = {new int[]{1,2},new int[]{2,3},new int[] {4,5,6}};
int[][] arrs2 = new int[][]{new int[]{1,2},new int[]{2,3},new int[] {4,5,6}};
//3种
//两个长度都写：
int[][] arrs3 = new int[3][2];
//只写一个长度
int[][] arrs4 = new int[3][];
arrs4[0] = new int[]{1,2,3};
arrs4[1] = new int[]{4,2,5};
arrs4[2] = new int[]{2,2,3};
System.out.println(arrs4);    //地址值

//遍历二维数组
for (int i = 0; i < arrs4.length; i++) {
    for (int j = 0; j < arrs4[i].length; j++) {
        System.out.print(arrs4[i][j]);
    }
    System.out.println();

5.总结

1.引用类型数组的概念：除了基本类型的其他类型数组，都能叫做引用类型数组

2.数组是对象，数组的元素可以看成对象的成员变量

3.数组的引用存储的是数组的对象的地址值

4.对应引用类型数组，数组元素存储的是对象的地址，而不是对象本身“数组持有对象的引用”

5.person[0]person[1]person[2]等价于Person p =new Person()中的P，没有区别

6.二维数组----数组的元素为基本类型数组

第四章、对象内存管理（重点）

一、堆内存

1.对象存储在堆中

JVM分为三个区域 : 堆(heap) 、栈(stack)、方法区（method）

JVM为Java程序提供并管理所需要的内存空间。

堆中存储使用new关键字创建的对象---数组、String、Person等等。

通过new创建的对象，在堆中。

2.成员变量的生命周期

当一个引用值为null时，该对象没有任何引用指向，则该对象被视为废弃对象，属于被回收(GC线程)范围。

成员变量的生命周期: 从对象在堆中创建，到对象从堆中被回收为止。

3.垃圾回收机制（面试，建议研究）

垃圾回收器(Garbage Collection ,GC),是JVM自带的一个线程(自动运行的),用于回收没有任何引用指向的对象。

垃圾回收器会自动帮Java程序员处理垃圾。

在main函数下面，有一个线程自动回收不用的对象，叫做守护线程。

4.内存泄漏

内存泄漏: 不再使用的对象没有被及时回收,积攒过多导致程序奔溃。

5.System.gc()方法

GC线程不会刚发现无用对象就会回收，如果需要强制回收，则使用System.gc()方法

这个方法强制调度GC线程回收无用对象。

二、非堆-栈
类中的变量叫：成员变量；方法中的变量叫：局部变量

1.栈存的是方法中的局部变量

2.局部变量的生命周期

生命周期: 栈帧被创建开始-方法执行完毕栈帧被销毁结束，局部变量也随之销毁。

栈帧中存储的是: 局部变量和参数等。

3.成员变量和局部变量的区别

三、非栈-方法区

1.存放类的信息

2.方法只有一份，唯一性
当类的信息加载到方法区时，类中的类方法的定义也被加载在方法区中。

无论创建多少对象，所有的对象是公用方法区中一个方法的定义。

四、堆、栈、方法区的区别

堆存的是成员变量

栈存的是局部变量

方法区存的是类信息

例

五、绘制下列代码内存区域图:

public class HomeWork1 { 
      String a = "java"; 
      String b = "c++"; 
      public void showInfo(String res) { 
          String c = res + a +"."+ b ; 
          System.out.println(c); 
       }
       public static void main(String[] args) { 
          HomeWork1 hw = new HomeWork1(); 
          hw.showInfo("编程语言:"); 
          } 
     }

java 面向对象编程

第一章、对象和类

一、面向对象的程序设计

3.总结

类是一种抽象的数据类型

OOP(Object Oriented Programming)面向对象编程实际是分类型思想。将过程种出现的数据泛化称为类。

类的组成:属性和方法

main方法也属于类的方法

二.定义一个类

2.定义类的成员的方法

用于描述对象的行为，封装对象的功能。

public class Person { //成员方法！！！main方法也时类的组成元素之一 public void show() { System.out.println("show....") } }

第二章、方法

一.方法的重载

1.方法的标识

方法的唯一标识就是: 方法的名字和参数列表

一个类中不能出现两个方法的标识完全一样的方法

3.访问重载方法

编译器在编译时会根据方法的标识调用不同的方法

4.重载总结

1.方法的唯一标识(方法的签名）：方法名和参数列表

2.一个类中不能出现两个方法签名完全相同的方法

3.但是可以出现方法名相同，但参数列表不同的两个方法互相构成重载

二、构造方法

1.构造方法

方法的名字与类名相同

不写返回值类型

在new Person（）中执行Person的构造方法

ublic class Person { //属性 String name; int age; double salary; //构造方法 public Person() { System.out.println("Person...constructor..."); } } }

2.构造方法的作用

能够创建一个具备初始属性的对象

给对象属性进行初始化的

5.this();

---1.必须放在构造方法的第一行！

---2.等同于调用了对应参数的无参构造方法

---3.只能用在当前类对象中

public Person(String name,int age,double salary) { this(); this.name = name; this.age = age; this.salary = salary; }

第三章、数组

一、引用类型数组

1.数组是对象

数组是引用数据类型

数组对象在堆中创建，声明的变量是引用类型，引用存储的是数组对象的地址值，指向数组对象

可以将数组中的元素看成对象的成员变量，只不过类型完全一致而已。

2.引用类型数组的声明

数组的元素可以为任意类型，当然也可以为引用类型。

引用类型数组元素存储的不是对象本身，而是存储元素对象的引用

第四章、对象内存管理（重点）

一、堆内存

1.对象存储在堆中

JVM分为三个区域 : 堆(heap) 、栈(stack)、方法区（method）

JVM为Java程序提供并管理所需要的内存空间。

堆中存储使用new关键字创建的对象---数组、String、Person等等。

通过new创建的对象，在堆中。

2.成员变量的生命周期

当一个引用值为null时，该对象没有任何引用指向，则该对象被视为废弃对象，属于被回收(GC线程)范围。

成员变量的生命周期: 从对象在堆中创建，到对象从堆中被回收为止。

4.内存泄漏

内存泄漏: 不再使用的对象没有被及时回收,积攒过多导致程序奔溃。

5.System.gc()方法

GC线程不会刚发现无用对象就会回收，如果需要强制回收，则使用System.gc()方法

这个方法强制调度GC线程回收无用对象。

二、非堆-栈
类中的变量叫：成员变量；方法中的变量叫：局部变量

1.栈存的是方法中的局部变量

2.局部变量的生命周期

生命周期: 栈帧被创建开始-方法执行完毕栈帧被销毁结束，局部变量也随之销毁。

栈帧中存储的是: 局部变量和参数等。

3.成员变量和局部变量的区别

三、非栈-方法区

1.存放类的信息

2.方法只有一份，唯一性
当类的信息加载到方法区时，类中的类方法的定义也被加载在方法区中。

无论创建多少对象，所有的对象是公用方法区中一个方法的定义。

Java相关栏目本月热门文章

java 面向对象编程

第一章、对象和类

一、面向对象的程序设计

3.总结 类是一种抽象的数据类型 OOP(Object Oriented Programming)面向对象编程实际是分类型思想。将过程种出现的数据泛化称为类。 类的组成:属性和方法 main方法也属于类的方法

二.定义一个类

2.定义类的成员的方法 用于描述对象的行为，封装对象的功能。 public class Person { //成员方法 ！！！main方法也时类的组成元素之一 public void show() { System.out.println("show....") } }

第二章、方法

一.方法的重载

1.方法的标识 方法的唯一标识就是: 方法的名字 和 参数列表 一个类中不能出现两个方法的标识完全一样的方法

3.访问重载方法 编译器在编译时会根据方法的标识调用不同的方法

4.重载总结 1.方法的唯一标识(方法的签名）：方法名和参数列表 2.一个类中不能出现两个方法签名完全相同的方法 3.但是可以出现方法名相同，但参数列表不同的两个方法互相构成重载 ​

二、构造方法

1.构造方法 方法的名字与类名相同 不写返回值类型 在new Person（）中执行Person的构造方法 ublic class Person { //属性 String name; int age; double salary; //构造方法 public Person() { System.out.println("Person...constructor..."); } } ​ }

2.构造方法的作用 能够创建一个具备初始属性的对象 给对象属性进行初始化的

5.this(); ---1.必须放在构造方法的第一行！ ---2.等同于调用了对应参数的无参构造方法 ---3.只能用在当前类对象中 public Person(String name,int age,double salary) { this(); this.name = name; this.age = age; this.salary = salary; ​ }

第三章、数组

一、引用类型数组

1.数组是对象 数组是引用数据类型 数组对象在堆中创建，声明的变量是引用类型，引用存储的是数组对象的地址值，指向数组对象 可以将数组中的元素看成对象的成员变量，只不过类型完全一致而已。

2.引用类型数组的声明 数组的元素可以为任意类型，当然也可以为引用类型。 引用类型数组元素存储的不是对象本身，而是存储元素对象的引用

第四章、对象内存管理（重点）

一、堆内存

1.对象存储在堆中 JVM分为三个区域 : 堆(heap) 、栈(stack)、方法区（method） JVM为Java程序提供并管理所需要的内存空间。 堆中存储使用new关键字创建的对象---数组、String、Person等等。 通过new创建的对象，在堆中。

2.成员变量的生命周期 当一个引用值为null时，该对象没有任何引用指向，则该对象被视为废弃对象，属于被回收(GC线 程)范围。 成员变量的生命周期: 从对象在堆中创建，到对象从堆中被回收为止。

4.内存泄漏 内存泄漏: 不再使用的对象没有被及时回收,积攒过多导致程序奔溃。

5.System.gc()方法 GC线程不会刚发现无用对象就会回收，如果需要强制回收，则使用System.gc()方法 这个方法强制调度GC线程回收无用对象。

二、非堆-栈 类中的变量叫：成员变量；方法中的变量叫：局部变量

1.栈存的是方法中的局部变量

2.局部变量的生命周期 生命周期: 栈帧被创建开始-方法执行完毕栈帧被销毁结束，局部变量也随之销毁。 栈帧中存储的是: 局部变量和参数等。

3.成员变量和局部变量的区别

三、非栈-方法区

1.存放类的信息

2.方法只有一份，唯一性 当类的信息加载到方法区时，类中的类方法的定义也被加载在方法区中。 无论创建多少对象，所有的对象是公用方法区中一个方法的定义。

Java相关栏目本月热门文章

3.总结

类是一种抽象的数据类型

OOP(Object Oriented Programming)面向对象编程实际是分类型思想。将过程种出现的数据泛化称为类。

类的组成:属性和方法

main方法也属于类的方法

2.定义类的成员的方法

用于描述对象的行为，封装对象的功能。

public class Person { //成员方法！！！main方法也时类的组成元素之一 public void show() { System.out.println("show....") } }

1.方法的标识

方法的唯一标识就是: 方法的名字和参数列表

一个类中不能出现两个方法的标识完全一样的方法

3.访问重载方法

编译器在编译时会根据方法的标识调用不同的方法

4.重载总结

1.方法的唯一标识(方法的签名）：方法名和参数列表

2.一个类中不能出现两个方法签名完全相同的方法

3.但是可以出现方法名相同，但参数列表不同的两个方法互相构成重载

1.构造方法

方法的名字与类名相同

不写返回值类型

在new Person（）中执行Person的构造方法

ublic class Person { //属性 String name; int age; double salary; //构造方法 public Person() { System.out.println("Person...constructor..."); } } }

2.构造方法的作用

能够创建一个具备初始属性的对象

给对象属性进行初始化的

5.this();

---1.必须放在构造方法的第一行！

---2.等同于调用了对应参数的无参构造方法

---3.只能用在当前类对象中

public Person(String name,int age,double salary) { this(); this.name = name; this.age = age; this.salary = salary; }

1.数组是对象

数组是引用数据类型

数组对象在堆中创建，声明的变量是引用类型，引用存储的是数组对象的地址值，指向数组对象

可以将数组中的元素看成对象的成员变量，只不过类型完全一致而已。

2.引用类型数组的声明

数组的元素可以为任意类型，当然也可以为引用类型。

引用类型数组元素存储的不是对象本身，而是存储元素对象的引用

1.对象存储在堆中

JVM分为三个区域 : 堆(heap) 、栈(stack)、方法区（method）

JVM为Java程序提供并管理所需要的内存空间。

堆中存储使用new关键字创建的对象---数组、String、Person等等。

通过new创建的对象，在堆中。

2.成员变量的生命周期

当一个引用值为null时，该对象没有任何引用指向，则该对象被视为废弃对象，属于被回收(GC线程)范围。

成员变量的生命周期: 从对象在堆中创建，到对象从堆中被回收为止。

4.内存泄漏

内存泄漏: 不再使用的对象没有被及时回收,积攒过多导致程序奔溃。

5.System.gc()方法

GC线程不会刚发现无用对象就会回收，如果需要强制回收，则使用System.gc()方法

这个方法强制调度GC线程回收无用对象。

二、非堆-栈
类中的变量叫：成员变量；方法中的变量叫：局部变量

2.局部变量的生命周期

生命周期: 栈帧被创建开始-方法执行完毕栈帧被销毁结束，局部变量也随之销毁。

栈帧中存储的是: 局部变量和参数等。

2.方法只有一份，唯一性
当类的信息加载到方法区时，类中的类方法的定义也被加载在方法区中。

无论创建多少对象，所有的对象是公用方法区中一个方法的定义。