Java SE_面向对象、方法的定义、方法的调用、类与对象的创建、构造器、创建对象内存分析、简单小结类与对象

已于 2023-05-05 10:45:00 修改
阅读量134 收藏
点赞数
文章标签： java
于 2021-04-20 19:24:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/So_Hollow/article/details/115795980
版权
面向过程&面向对象
  • 面向过程思想（线性思维）
    • 步骤清晰简单，第一步做什么，第二步做什么……
    • 面对过程适合处理一些较为简单的问题。
  • 面向对象思想
    • 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
    • 面向对象适合处理复杂的问题，适合处理需要多人协作的问题。
  • 对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。
  • 记录：
    • 面向对象（oo）
    • 面向对象编程（oop）
    • Java的核心思想就是oop
    • 属性+方法就是一个类
什么是面向对象
  • 面向对象编程(Object Oriented Programming)—OOP
  • 面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据。
  • 核心思想
    • 抽象
      • 举例理解：学生管理系统，对于学生来说只需要了解班级、学号、成绩等信息，我们可以把学生的共同点剥离抽取出来，变成一个类。可以理解为抽取像的部分、共同点。（抽像）
    • 三大特征
      • 封装
        • 举例理解：给数据封装包装起来。对外提供一个口子，提供访问。
      • 继承
        • 举例理解：子类继续父类，A继承B，A就拥有了B的所有信息。
      • 多态
        • 举例理解：小红和小明都会去学习，成绩可能各有所好坏，学出来的东西完全不一样。（同一个事物，会有多种形态）
  • 从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象。
  • 从代码运行角度考虑是先有类后有对象。类是对象的模板。
回顾方法及加深
方法的定义

package com.landray.object;

public class Demo01 {

	public static void main(String[] args) {

	}

	/*
	 * 修饰符 返回值类型 方法名（...）{ 
	 * 	//方法体 
	 * 	return 返回值; 
	 * }
	 */
	public String sayHello() {
		return "Hello,World";
	}

	// 注意
	public void hello() {
		return;// 可以默认不写，如果要写的话可以直接return空就行了。
	}

	// 比较大小
	public int max(int a, int b) {
		return a > b ? a : b;// 三元运算符
	}

	// break 和 return 的区别
	// break：跳出switch，结束循环。
	// return：代表方法结束，返回一个结果。（在return后不能再写其他代码或者输出语句。会报错-无法访问的代码）

	// 方法名：注意规范 驼峰命名 见名知意

	// 参数列表：（参数类型 参数名称）
}
方法的调用
  • 静态方法和非静态方法

package com.landray.object;

//学生类
public class Student {

	// 非静态方法
	public void say() {
		System.out.println("非静态方法");
	}

	// 静态方法
	public static void talk() {
		System.out.println("静态方法");
	}
}



package com.landray.object;

public class Demo02 {

	public static void main(String[] args) {
		// 非静态方法 实例化这个类-new
		Student student = new Student();
		student.say();
		// 静态方法 static可以通过类名.方法名访问
		Student.talk();
	}

	// 都是非静态方法；a方法可以直接调用b方法
	public void a() {
		b();
	}

	public void b() {

	}

	// 都是静态方法；c方法可以直接调用d方法
	public static void c() {
		d();
	}

	public static void d() {

	}

	// e是静态方法，f是非静态方法；e方法无法调用f方法
	// 为什么：
	// static和类一起加载的，类存在的时候static的方法就存在了。
	public static void e() {
		// f();
	}

	// 跟对象有关的，对象创建之后才存在。（类实例化之后才存在）
	public void f() {

	}

}
  • 形参和实参
    • 实际参数和形式参数的类型要对应。
  • 值传递和引用传递
    • Java中都是值传递

package com.landray.object;

//值传递
public class Demo03 {

	public static void main(String[] args) {
		// Java中都是值传递
		int a = 1;
		System.out.println(a);// 输出 1
		Demo03.change(a);
		System.out.println(a);// 输出 1
	}

	// 返回值为空
	public static void change(int a) {
		a = 10;
	}
}



package com.landray.object;

//引用传递：一般是传递对象，本质还是值传递。
//对象 内存
public class Demo04 {

	public static void main(String[] args) {
		Person person = new Person();
		System.out.println(person.name);// null
		Demo04.change(person);
		System.out.println(person.name);// 盖伦
	}

	public static void change(Person person) {
		// 修改的是Person类中的name值
		// Person是一个对象：指向的是Person类（Person person = new Person();）
		// 这是一个具体的人，可以改变属性
		person.name = "盖伦";
	}
}

//一个类中只能有一个 public class，但是可以有多个class。
//定义了一个Person类，有一个属性：name
class Person {
	String name;// null
}
类与对象的关系

  • 类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物。

    • 动物、植物、手机、电脑…
    • Person类、Pet类、Car类等，这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为

  • 对象是抽象概念的具体实例

    • 张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例。
    • 能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念。
创建与初始化对象
  • 使用new关键字创建对象。
  • 使用new关键字创建的时候，除了分配内存空间之外，还会给 创建好的对象 进行默认的初始化以及对类中构造器的调用。
  • 类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：
    • 1.必须和类的名字相同。
    • 2.必须没有返回类型，也不能写void。

package com.landray.object;

//学生类
//一个类中只可能存在属性和方法，不会有其他的。
public class Student {

	// 属性：字段
	String name;// 默认的初始化值 null
	int age;// 默认的初始化值 0

	// 方法
	public void study() {
		// 因为学习的人名字不固定，所以这里用this.name指代
		// this代表当前这个类
		System.out.println(this.name + "在学习");
	}

}



package com.landray.object;

//一个项目应该只存在一个main方法
public class Demo05 {

	public static void main(String[] args) {
		// 类是抽象的一个模板，不能给模板赋值，不然就都是一样的值了。
		// 类是抽象的，对象是一个具体的实例。
		// 理解：类是一些拥有共同特征的事物归类的一个模板，比如说桌子类，他们都拥有共同的特征桌脚和桌面。
		// 我们把这类共同的事物归为桌子类，当这个桌子类去实例化的时候，可以是餐桌、书桌、麻将桌、办公桌等。
		// 类是抽象的，需要实例化。
		// 把类实例化成为一个对象。
		// new 之后对象就被实例化了。
		// 类实例化后会返回一个自己的对象。
		// student对象就是一个Student类的具体实例。
		Student student = new Student();
		// 学生类实例，这个人可以是“xiaohong”也可以是“xiaoming”。他们都是属于学生一类。
		// 同一个类下面可以产生不同的对象。
		// 但是这些人都拥有共同的特性，都具有“name”、“age”、“study()”
		Student xiaoming = new Student();
		Student xiaohong = new Student();

		// 使用new关键字创建的时候，除了分配内存空间之外，还会给 创建好的对象 进行默认的初始化。所以会输出以下的默认值：
		System.out.println(xiaoming.name);// 输出 null
		System.out.println(xiaoming.age);// 输出 0

		// 赋值后重新输出
		xiaoming.name = "小明";
		xiaoming.age = 18;
		System.out.println(xiaoming.name);// 输出 小明
		System.out.println(xiaoming.age);// 输出 18

		// 给小红赋值
		xiaohong.name = "小红";
		xiaohong.age = 18;
	}

}
构造器详解
  • 创建一个名为Person的类：

package com.landray.object;

public class Person {

}
  • 这个Person类中什么都不存在，但是在main方法中也能去new实例化：
  • 这是为什么？

package com.landray.object;

public class Application {

	public static void main(String[] args) {

		// new 实例化了一个对象
		Person persion = new Person();

	}

}
  • 查看Person类生成的class文件：
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package com.landray.object;

public class Person {
    public Person() {
    }
}
  • 得出：
    • 编译后的class文件默认的增加了一个Person()的方法。并且这个方法的名称和类的名字相同；没有返回值。
  • 构造器事项：

package com.landray.object;

public class Person {
	// 一个类即使什么都不写，它也会存在一个方法（构造方法）

	// 显示的定义构造器：
	// 1.必须和类的名字相同
	// 2.必须没有返回类型，也不能写void
	// 作用：
	// 1.使用new关键字（必须要有构造器），本质是在调用构造器
	// 2.用来初始化对象的值
	// 注意点：
	// 定义了有参构造之后，如果想要使用无参构造，显示的定义一个无参的构造
	String name;

	// 无参构造方法
	public Person() {
		// this.name = "盖伦";
	}

	// 有参构造方法
	// 一旦定义了有参构造之后，无参构造就必须显示定义。
	public Person(String name) {
		this.name = name;
	}

	/*
	 * public static void main(String[] args) {
	 * 
	 * new 实例化了一个对象
	 * Person persion = new Person();
	 * System.out.println(persion.name); 
	 * Person persion1 = new Person("德玛西亚");
	 * System.out.println(persion.name); 
	 * 根据是否有无参数来调用上面对应的重载方法
	 * 
	 * }
	 */
}
创建对象内存分析
  • 创建一个Pet类（拥有“姓名”、“年龄”属性以及“呼喊”的行为），在main方法中进行实例化赋值的过程。在内存中的过程分析。

package com.landray.object;

public class Pet {
	public String name;
	public int age;

	// 无参构造（默认隐藏）
	public void shout() {
		System.out.println("叫了一声");
	}
}



package com.landray.object;

public class Application {

	public static void main(String[] args) {

		Pet dog = new Pet();
		dog.name = "旺财";
		dog.age = 3;
		dog.shout();
		System.out.println(dog.name);
		System.out.println(dog.age);

		Pet cat = new Pet();
	}

}

在这里插入图片描述

  • 说明：
    • 第一步加载Application类代码信息，加载类中的main方法以及存在的常量池（字符串）
    • 第二步在栈的最下面会执行main方法
    • 第三步在main方法中Pet dog = new Pet()的操作，会加载我们的Pet类。加载对象的模板，模板中的信息都为默认值name = null;age = 0;
    • 第四步加载模板生成具体的dog()对象，会在栈中生成一个dog变量，栈中的dog变量会引用指向堆中的对象。拥有属性 name = null;age = 0;并且已经能输出“System.out.println(“叫了一声”);”这个字符串。
    • 第五步执行dog.name = “旺财”;dog.age = 3;赋值操作。拿到常量池中的“旺财”进行赋值。
    • 第二个对象开始Pet cat = new Pet();又会在栈中生成一个cat变量，栈中的cat变量会引用指向堆中的具体对象…
    • 静态方法区：
      • 和类一起加载，方便大家调用的操作会放在这里，和类一起加载的作用就是所有的对象都会掉到它。
      • 方法区也属于堆。
简单小结类与对象
  • 类与对象
    • 类是一个模板，是抽象的
    • 对象是一个具体实例
  • 方法
    • 方法的定义与调用
  • 对象的引用
    • 基本类型：八大基本类型
    • 引用类型：除了基本类型以外，其他都是引用类型
    • 对象是通过引用来操作的（指向堆中的对象地址）。引用是指栈中的变量指向的是堆中的地址（栈->堆）
  • 属性（字段、成员变量）
    • 会默认初始化
      • 数字默认值：0/0.0（浮点）
      • char默认值：u0000
      • boolean默认值：false
      • 引用类型：null
    • 属性定义
      • 修饰符 属性类型 属性名 = 属性值
  • 对象的创建和使用
    • 必须使用new关键字创造对象，还需要有构造器。
    • Person person = new Person();
    • 对象的属性调用：person.name
    • 对象的方法调用：person.sleep()
  • 一个类中只具有两种东西
    • 静态的属性（属性）
    • 动态的行为（方法）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值