目录
第一章、对象和类
一、面向对象的程序设计
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;
//构造方法
/*
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("编程语言:");
}
}