文章目录
5.1 面向对象编程
5.1.1 面向对象编程思想概述
5.1.1.1 编程语言概述
Java是一种计算机程序设计语言,所有的计算机程序一直都是围绕着两件事在进行的(如何表示和存储数据;基于这些数据都有什么操作行为,实现什么功能),程序设计就是用某种语言编写代码来完成这两件事,所以程序设计语言又称为编程语言。
-
如何表示数据和存储数据
* 基于数据类型的变量和常量:表示和存储一个个独立的数据。 * 对象:表示和存储与某个具体事物相关的多个数据(如一个学生的姓名、年龄、性别、学号等等)。 * 数据结构:表示和存储一组数据,数据结构有数组、链表、栈、队列、散列表、树......
-
基于这些数据能实现哪些功能
* 数据的输入输出 * 数据间的赋值运算、算术运算、比较运算、逻辑运算...... * 基于一组数据的统计分析、查找元素、遍历......
5.1.1.2 程序设计方法
程序设计方法分为面向过程和面向对象两种
- 面向过程的代表语言C语言,C语言是在面向过程思想的指引下 去设计、去开发计算机程序的。
- 面向对象的代表语言Java,Java语言在面向对象思想的指引下 去设计、去开发计算机程序的。
面向过程的程序设计思想(Process-Oriented Programming),简称POP
- 面向过程的程序设计思想关注的焦点是操作数据的步骤,如果某段代码被多次使用,那么就可以将这个过程抽象为一个函数,可以简化代码,减少冗余,也便于维护。
- 代码的结构是以函数为组织单位,独立于函数之外的数据称为全局数据,在函数内部的数据称为局部数据
.面向对象的程序设计思想(Object Oriented Programming),简称OOP
- 面向对象的程序设计思想关注的焦点是类,在计算机程序设计过程中,参照现实中的事物,将事物的属性特征、行为特征抽取出来,用一个类来表示。某一个事物的具体个体称为示例或对象
- 代码结构是以类为组织单位。每种事物都具备自己的属性(属性是用来表示和存储数据的,在类中用成员变量来表示)和行为/功能(即对数据的操作,在类中用成员方法表示)
5.1.2 类和对象
5.1.2.1 类
- 类是一类具有相同特征的事物的抽象描述,是一组相关属性和行为的集合。(如拿姓名,年龄,性别就可以抽象出来一个人的类)Java中最基本的单位就是类,用来描述现实生活中的事物。
- 类的成员变量(属性)
- 描述该事物的状态信息
- 类的成员方法(行为)
- 该事物能做什么操作,有什么功能
5.1.2.2 对象(示例)
- 对象是一类事物的一个具体的个体,即一个对象的实例,必须具备该类事物的属性和行为
如对于 学生类,它的实例可以是一个名叫张三的学生、也可以是名叫李四的学生
5.1.2.3 类与对象的关系
- 类是对一类事物的描述,是抽象的
- 对象是一类事物的实例,是具体的
- 类是对象的模板,对象是类的实例
5.1.3 如何定义类
5.1.3.1 类的定义格式
关键字:class
[修饰符] class 类名 {
}
如
public class Student {
}
- 类一般由五部分组成
- 成员变量/field域
- 成员方法(method)
- 构造器
- 代码块
- 内部类
5.1.3.2 定义学生类
学生类
属性:姓名,年龄,性别
行为:学习,睡觉
public class Student { // 类名为Student
String name ; // 姓名属性
int age ; // 年龄属性
String sex ; // 性别属性
public void study() {
System.out.println(name + " 在学习.....");
}
public void sleep() {
System.out.println(name + " 在睡觉.....");
}
}
5.1.3.3 定义手机类
手机类
属性:价格,品牌,颜色
行为:打电话,玩游戏,发信息
public class Phone { // 手机类
String brand ; // 品牌属性
double price ; // 价格属性
String color ; // 颜色属性
public void call() { // 打电话行为
System.out.println("打电话......");
}
public void playGame() { // 玩游戏属性
System.out.println("玩游戏......");
}
public void sendMessage() { // 发信息行为
System.out.println("发信息.....");
}
}
5.1.4 如何使用类
- 在使用一个类时,我们必须对该类进行实例化,即创建该类的对象
创建对象的格式:类名 对象名 = new 类名();- 如何使用类中的成员变量
对象名.变量名- 如何使用类中的成员方法
对象名.方法名([参数])
5.1.4.1 使用类对象
类名 对象名 = new 类名();
案例:创建学生对象
public class StudentTest {
public static void main(String[] args) {
// 创建学生类对象
Student student = new Student();
// 调用其成员变量并赋值
student.name = "张三" ;
student.age = 21 ;
student.sex = "男" ;
// 调用成员方法
student.sleep();
student.study();
System.out.println(student);
}
}
- 我们创建对象后对其成员变量进行赋值,输出对象,得到的是类是于直接输出数组的一个字符串,由此我们可以得到,
对象名中存储的是对象的地址,对象是引用数据类型
- “
cn.pdsu.edu.Student@4554617c
”也不是对象的地址,因为Java是对程序员隐藏内存地址的,不暴露内存地址信息,所以打印对象时不直接显示内存地址,而是JVM帮你调用了对象的toString方法,将对象的基本信息转换为字符串并返回,默认toString方法返回的是“对象的运行时类型@对象的hashCode值的十六进制值
”,程序员可以自己改写toString方法的代码
- 成员变量
声明成员变量
[修饰符] 数据类型 成员变量名;
如:
String name;
int age;
String sex;
- 注意
- 位置要求:成员变量必须定义在类中,方法外
- 类型要求:可以是任何类型的,包括基本数据类型,引用数据类型
- 修饰符:如public、static、protected、private…
- 其中static将变量分为两大类:静态变量和非静态变量,其中静态变量又称为类变量,非静态变量又称为实例变量或属性。
实例变量的特点
实例变量的值是属于某个对象的
- 必须通过对象才能访问实例变量
- 每个对象的实例变量的值是独立的
实例变量有默认值(对应数据类型的默认值)
访问实例变量:对象名.实例变量
案例:
public class StudentDemo {
public static void main(String[] args) {
Student s = new Student() ;
Student s1 = new Student() ;
s.name = "张三" ;
s.age = 21 ;
s.sex = "男" ;
System.out.println("s.name = " + s.name);
System.out.println("s.age = " + s.age);
System.out.println("s.sex = " + s.sex);
System.out.println("s1.name = " + s1.name);
System.out.println("s1.age = " + s1.age);
System.out.println("s1.sex = " + s1.sex);
}
}
- Java对象保存在内存中时,由以下三部分组成:
对象头
Mark Word:记录了和当前对象有关的GC、锁等信息。
指向类的指针:每一个对象需要记录它是由哪个类创建出来的,而Java对象的类数据保存在方法区,指向类的指针就是记录创建该对象的类数据在方法区的首地址。该指针在32位JVM中的长度是32bit,在64位JVM中长度是64bit。
数组长度(只有数组对象才有)
实例数据
- 即实例变量的值
对齐填充
- 因为JVM要求Java对象占的内存大小应该是8bit的倍数,如果不满足该大小,则需要补齐至8bit的倍数,没有特别的功能。
5.1.4.3 如何调用实例方法
方法调用的语法格式:对象.非静态方法([实参列表])
方法的特殊参数
形参是类类型(引用数据类型)
举例:
class TestStudent {
public static void main(String[] args) {
Student student = new Student();
student.name = "张三" ;
student.age = 15 ;
print(student);
}
public static void print(Student s) {
System.out.println(s.name);
System.out.println(s.age);
s.study();
}
}
public class Student { // 类名为Student
String name ; // 姓名属性
int age ; // 年龄属性
public void study() {
System.out.println(name + " 在学习.....");
}
public void sleep() {
System.out.println(name + " 在睡觉.....");
}
}
形参是可变参数
在JDK1.5之后,在定义一个方法时,形参的类型需要确定,但是形参的个数可以是不确定的,可以考虑使用可变参数 可变参数的格式:参数类型… 参数名
可变参数的特点和要求:
- 一个方法最多只能有一个可变参数
- 如果一个方法包含可变参数,那么可变参数必须是形参列表的最后一个,前面传的参数默认给对应的参数赋值
- 在声明它的方法中,可变参数当成数组使用,个数范围从0到无穷大
- 举例:
- 先定义一个方法print(int[] arr) 参数列表是int数组,
- 再定义一个方法print(int… arr) 参数列表为可变参数 会报错,不是方法的重载,而是同一个方法,可变参数等同于数组
案例:
public class Demo1 {
public static void main(String[] args) {
int[] arr = {11 , 22 , 33 , 44 , 55} ;
print(100 , arr);
print(arr);
}
public static void print(int j , int... arr) {
System.out.println("j = " + j);
for (int i = 0 ; i < arr.length ; i ++) {
System.out.println(arr[i]);
}
}
public static void print(int... arr) {
for (int i = 0 ; i < arr.length ; i ++) {
System.out.println(arr[i]);
}
}
}
参数类型为命令行参数
通过命令行给main方法的形参传递的实参称为命令行参数
public class Demo2 {
public static void main(String[] args) {
System.out.println(args);
System.out.println(args.length);
for (int i = 0 ; i < args.length ; i ++) {
System.out.println("第" + (i+1) + "个参数的值是:" + args[i]);
}
}
}
在IDEA中配置运行参数
配置参数后再次运行
- 方法的参数传递机制
- 方法的形参是基本数据类型时,形参值的改变不会影响实参
public class Demo3 {
public static void main(String[] args) {
int a = 4 ;
int b = 8 ;
System.out.println("交换前a = " + a + " , b = " + b);
swap(a , b);
System.out.println("交换后a = " + a + " , b = " + b);
}
public static void swap(int a , int b) {
int temp = a ;
a = b ;
b = temp ;
System.out.println("方法内 :交换后a = " + a + " , b = " + b);
}
}
可以看到,即使在调用过交换方法后,再输出a、b仍为交换前的顺序。这是因为实参a、b是基本数据类型,传递给实参的是数据的"副本",在调用完后,a、b的值不会发生任何的改变
- 方法的形参是引用数据类型时,形参地址值的改变不会影响实参,但是形参地址值里面的数据的改变会影响实参。
案例:
public class Demo4 {
public static void main(String[] args) {
int[] arr1 = {1 , 2 , 3} ;
int[] arr2 = {3 , 2 , 1} ;
System.out.println("交换前的arr1=" + arr1 + " , 交换前的arr2=" + arr2);
swap(arr1 , arr2);
System.out.println("交换后的arr1=" + arr1 + " , 交换后的arr2=" + arr2);
}
public static void swap(int[] arr1 , int[] arr2) {
int[] temp = arr1 ;
arr1 = arr2 ;
arr2 = temp ;
System.out.println("方法内:交换后的arr1=" + arr1 + " , 交换后的arr2=" + arr2);
}
}
public class Demo4 {
public static void main(String[] args) {
int[] arr1 = {1 , 2 , 3} ;
int[] arr2 = {3 , 2 , 1} ;
System.out.print("arr1 : ");
for (int i = 0 ; i < arr1.length ; i ++) {
System.out.print(arr1[i] + " , ");
}
System.out.print("arr2 : ");
for (int i = 0 ; i < arr2.length ; i ++) {
System.out.print(arr1[i] + " , ");
}
System.out.println();
swap(arr1 , arr2);
System.out.print("arr1 : ");
for (int i = 0 ; i < arr1.length ; i ++) {
System.out.print(arr1[i] + " , ");
}
System.out.print("arr2 : ");
for (int i = 0 ; i < arr2.length ; i ++) {
System.out.print(arr1[i] + " , ");
}
}
public static void swap(int[] arr1 , int[] arr2) {
arr1[1] = 100 ;
arr2[1] = 50 ;
System.out.print("方法内arr1 : ");
for (int i = 0 ; i < arr1.length ; i ++) {
System.out.print(arr1[i] + " , ");
}
System.out.print("方法内arr2 : ");
for (int i = 0 ; i < arr2.length ; i ++) {
System.out.print(arr1[i] + " , ");
}
System.out.println();
}
}
5.1.5 对象的内存图
5.1.5.1 一个对象的内存图
案例:
public class Car {
/**
* 车名
*/
String name ;
/**
* 车的颜色
*/
String color ;
public void run() {
System.out.println(name + "在路上跑...");
}
}
class CarTest {
public static void main(String[] args) {
Car car = new Car();
car.name = "比亚迪" ;
car.color = "黑色" ;
car.run();
}
}
5.1.5.2 两个对象的内存图
public class Car {
/**
* 车名
*/
String name ;
/**
* 车的颜色
*/
String color ;
public void run() {
System.out.println(name + "在路上跑...");
}
}
class CarTest {
public static void main(String[] args) {
Car car1 = new Car();
Car car2 = new Car();
car1.name = "比亚迪" ;
car1.color = "黑色" ;
car1.run();
}
}
5.1.5.3 三个引用两个对象的内存图
5.1.6 实例初始化
5.1.6.1 构造器
对于对象,每次创建后,所有成员变量都是默认值,如果我们需要对其进行赋值操作,需要挨个进行,太麻烦了。我们能不能在创建对象时,直接为当前对象的某个或所有成员变量直接赋值呢。
- 构造器的作用
- 构造本类对象,对类的属性值(成员变量)进行初始化(赋值)
- 构造器的语法格式
- 构造器又叫构造方法,格式和方法类似但又不同
[修饰符] class 类名 {
[修饰符] 构造器名() {
}
[修饰符] 构造器名(参数列表) {
}
}
- 注意事项
- 构造器在每次创建对象时都会执行
- 构造器的名字必须和它所在类的类名相同
- 构造器没有返回值,不需要返回值类型,也不需要void
- 如果在定义类时没有提供构造器,系统会默认给一个无参构造器,并且该构造器的修饰符默认与类的修饰符相同。但是如果在定义类时提供了有参构造器,那么系统将不再提供无参构造器,如果要使用需要自己定义。
- 构造器是可以重载的,可以是无参、一参、两参、多参
- 构造器的修饰符只能是权限修饰符
案例:
public class Teacher {
String name ;
int age ;
String sex ;
public Teacher() {
}
public Teacher(String name, int age, String sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
public void getInfo() {
System.out.println("姓名:" + this.name + ", 年龄:" + this.age + ", 性别:" + this.sex);
}
}
class TeacherTest {
public static void main(String[] args) {
Teacher t1 = new Teacher();
Teacher t2 = new Teacher("张三" , 30 , "男");
t1.getInfo();
t2.getInfo();
}
}
5.1.7 实例变量与局部变量的区别
-
声明位置和方式
- 实例变量声明在类中,方法外
- 局部变量声明在方法体中,或方法的形参、代码块中
-
在内存中存储的位置不同
- 实例变量在堆中存储(实例变量属于对象,对象进堆内存)
- 局部变量在栈中存储(局部变量属于方法,方法进栈内存)
-
生命周期
- 实例变量:和对象的生命周期一样,随着对象的创建而存在,随着对象被GC回收而消亡,而且每一个对象的实例变量是独立的。
- 局部变量:和方法调用的生命周期一样,每一次方法被调用而在存在,随着方法执行的结束而消亡,而且每一次方法调用都是独立。
-
作用域
- 实例变量除了可以在类中使用,还可以通过对象调用
- 只能在方法中使用
-
修饰符
- 实例变量:public、protected、private、final、…
- 局部变量:final
-
默认值
- 实例变量有默认值
- 局部变量没有默认值,需要手动初始化
5.1.8 匿名对象的概述和应用
5.1.7.1 匿名对象的概述
没有名字的对象即为匿名对象
5.1.7.2 匿名对象的应用场景
调用方法,仅仅只调用一次的时候
匿名对象可以作为实际参数传递
5.1.7.3 匿名对象的好处
节省代码
匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。
案例:
public class User {
String name ;
int age ;
public User() {
}
public User(String name, int age) {
this.name = name;
this.age = age;
}
public void getInfo() {
System.out.println("User{" +
"name='" + name + '\'' +
", age=" + age +
'}');
}
}
class TestUser {
public static void main(String[] args) {
User user = new User("张三" , 25);
method(new User("李四" , 20)); // 匿名内部类
method(user);
}
public static void method(User user) {
user.getInfo() ;
}
}
5.1.9 对象数组
对象数组,首先要创建数组对象本身,确定数组的长度,然后再创建每一个元素对象,如果不创建,数组元素的默认值就是null
,容易出现空指针异常NullPointerException
。
案例:
public class Person {
String name ;
int age ;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public void sleep() {
System.out.println(name + "在睡觉......");
}
public void eat() {
System.out.println(name + "在吃东西......");
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
class PersonTest {
public static void main(String[] args) {
Person[] pArr = new Person[3] ;
Person p1 = new Person("张三" , 20);
Person p2 = new Person("李四" , 21);
Person p3 = new Person("王五" , 22);
pArr[0] = p1 ;
pArr[1] = p2 ;
pArr[2] = p3 ;
for (int i = 0 ; i < pArr.length ; i ++) {
System.out.println(pArr[i]);
}
}
}
5.1.10 包(Package)
5.1.10.1 包的作用
-
避免了的重名,将类创建在包里,类的全路径名称为包名.类名
-
控制某些类型或成员的可见范围
- 如果某个类型或者成员的修饰符缺省的话,那么就仅限于本包使用
-
分类组织管理不同类型的类
- 例如:
java.lang----包含一些Java语言的核心类,如String、Math、Integer、 System和Thread等,提供常用功能
java.net----包含执行与网络相关的操作的类和接口。
java.io ----包含能提供多种输入/输出功能的类。
java.util----包含一些实用工具类,如集合框架类、日期时间、数组工具类Arrays,文本扫描仪Scanner,随机值产生工具Random。
5.1.10.2 声明包
关键字:package
package 包名;
注意:
- 包的声明必须在源文件的代码首行
- 一个源文件只能有一个声明包的package语句
包的命名规范和习惯:
- 所有单词都小写,每个单词之间使用 . 分割
- 习惯用公司的域名倒置开头
5.1.10.3 如何跨包实用类
注意:只有public的类才能被跨包使用
- 使用类的全路径名称
如:java.util.Scanner sc = new java.util.Scanner(System.in) ;
-
使用import语句导包后可简化书写
-
import语句语法格式
import 包名.类名;
import 包名.*;
使用java.lang
包下的类,不需要import语句,就直接可以使用简名称
import语句必须在package下面,class的上面
当使用两个不同包的同名类时,例如:java.util.Date和java.sql.Date
。一个使用全名称,一个使用简名称
举例:
package cn.pdsu.edu;
import java.util.Date;
import java.util.Scanner;
public class Demo1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in) ;
Student student = new Student() ; // 同一个包下的类
Date date = new Date() ;
java.sql.Date date1 = new java.sql.Date(1) ;
}
}