java 面向对象编程——简介

目录

第一章、对象和类

一、面向对象的程序设计

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;
   }
             

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

1. 整型(byte short int long): 默认值为0
2. 浮点型(float double): 默认为0.0
3. 字符型(char):默认为空字符
4. 布尔型(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;
        //构造方法
    /*
    1.方法的名字与类名相同 2.不写返回值类型
     */
    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("编程语言:"); 
          } 
     }