Java大数据-Week2-Day1 面向对象基础

本文详细介绍了Java中的面向对象编程基础,包括类与对象的创建、方法的使用、对象创建的内存管理、构造方法的重载以及方法的重载。通过实例展示了如何创建和操作对象,以及如何通过构造方法初始化对象属性。此外,还探讨了匿名对象的概念和应用,强调了编程规范的重要性。
摘要由CSDN通过智能技术生成

第三章第二节 面向对象基础


前言

面向对象基础

类与对象的创建

package day01;
/**
 * class 类名{
 * 	成员属性;
 * 	成员方法;
 * 
 * }
 * 
 * 类必须编写在.java文件中,
 * 一个.java文件中,	可以存在N个类,	但是只能存在一个public修饰的类.
 * .java文件的文件名称	必须与public修饰的类名	完全一致.
 * @author jiajun.lin
 *
 */

public class Demo1 {
	
	public static void main(String[] args){
		//创建对象的格式:
		//类型 对象名 = new 类名();
		//类的对象的方法使用
		Person p = new Person();
		// 给对象属性赋值
		//格式:	对象名.属性名 = 值;
		p.name = "张三";
		p.age = 18;
		p.sex = '男';
		p.say();

	}
}
/**
 * 类就像是图纸
 * 对象:未来图纸包含的
 * @author jiajun.lin
 *
 */
//类定义
class Person{
	//属性	- 特征
	String name;
	int age;
	char sex;
	//方法	- 行为
	/**
	 * void 表示灭有返回值
	 * 定义方法的格式
	 * 返回值类型 方法名称(形式参数列表){
	 * 	方法体
	 * 	return 返回值;
	 * }
	 * 方法的调用格式
	 * 某对象的某行为
	 * 对象名.方法名称(实际参数列表);
	 */
	//类的方法定义
	void say() {
		System.out.println("自我介绍: 我是"+name+", 我的年龄: "+age+", 我的性别: "+sex);
	}
	
}

在这里插入图片描述

方法的补充

package day01;
/**
 * class 类名{
 * 	成员属性;
 * 	成员方法;
 * 
 * }
 * 
 * 类必须编写在.java文件中,
 * 一个.java文件中,	可以存在N个类,	但是只能存在一个public修饰的类.
 * .java文件的文件名称	必须与public修饰的类名	完全一致.
 * @author jiajun.lin
 *
 */

public class Demo1 {
	
	public static void main(String[] args){
		//创建对象的格式:
		//类型 对象名 = new 类名();
		//类的对象的方法使用
		Person p = new Person();
		// 给对象属性赋值
		//格式:	对象名.属性名 = 值;
		p.name = "张三";
		p.age = 18;
		p.sex = '男';
		p.say();

		//sum 调用方法并传递参数的返回值
		int s = p.sum(100, 200);
		System.out.println(s);
	}
}
/**
 * 类就像是图纸
 * 对象:未来图纸包含的
 * @author jiajun.lin
 *
 */
//类定义
class Person{
	//属性	- 特征
	String name;
	int age;
	char sex;
	//方法	- 行为
	/**
	 * void 表示灭有返回值
	 * 定义方法的格式
	 * 返回值类型 方法名称(形式参数列表){
	 * 	方法体
	 * 	return 返回值;
	 * }
	 * 方法的调用格式
	 * 某对象的某行为
	 * 对象名.方法名称(实际参数列表);
	 */
	//类的方法定义
	void say() {
		System.out.println("自我介绍: 我是"+name+", 我的年龄: "+age+", 我的性别: "+sex);
	}
	//方法的补充
	int sum(int x,int y) {
		int z = x+y;
		return z;
	}
	/*
	void xxx() {
		if(true) {
			return;//return表示我们方法执行完成后产生的结果
		}
		System.out.println("哈哈");
	}
	*/
}

在这里插入图片描述

对象创建补充

package day01;

public class Demo1 {
	
	public static void main(String[] args){
		//两本书b1,b2
		Book b1 = new Book();
		Book b2 = new Book();
		b1.name = "金苹果";
		b1.info = "讲述了果农种植金色苹果的辛勤路程. ";
		
		b2.say();
		
	}
}

class Book{
	String name;
	String info;
	
	void say() {
		System.out.println("书名: "+name+" , 简介: "+info);
	}
}

在这里插入图片描述

package day01;

public class Demo1 {
	
	public static void main(String[] args){
		//两本书b1,b2
		Book b1 = new Book();
		Book b2 = new Book();
		b1.name = "金苹果";
		b1.info = "讲述了果农种植金色苹果的辛勤路程. ";
		
		b2.name = "银苹果";
		b2.info = "讲述了果农终止银色苹果的辛勤路程. ";
		//两个对象的情况不同,	输出的结果也不同
		b1.say();
		b2.say();
		
	}
}

class Book{
	String name;
	String info;
	
	void say() {
		System.out.println("书名: "+name+" , 简介: "+info);
	}
}

在这里插入图片描述

对象创建内存01

package day01;
/**
 * 对象创建的内存细节
 * @author jiajun.lin
 *
 */
public class Demo1 {
	
	public static void main(String[] args){
		Book b1 = new Book();
		b1.name = "金苹果";
		b1.info = "讲述了果农终止金色苹果的辛勤路程";
		b1.say();
		
		//b1,b2就是个名称,b1和b2都是同个,两个名字指向同一个内存
		//结果两个都改了
		Book b2 = b1;//复制?其实不是
		b2.name = "嘿嘿嘿";
		//两个结果都输出,本来是想要只输出b1的
		b1.say();
		
	}
}

class Book{
	String name;
	String info;
	
	void say() {
		System.out.println("书名: "+name+" , 简介: "+info);
	}
}


在这里插入图片描述

重点是:栈和堆

对象创建内存02

JAVA中一个线程就有一个栈

很多事情要去做,可以分为多个

栈:先进后出的方式

创建空间和释放空间的速度非常快


堆:引用数据类型的对象,占用空间是不固定的

package day01;

public class Demo1 {
	
	public static void main(String[] args){
		Book b1 = new Book();
		b1.name = "金苹果";
		b1.info = "讲述了果农终止金色苹果的辛勤路程";
		b1.say();
		
		Book b2 = b1;
		b2.name = "嘿嘿嘿";
		
		b1.say();
		
	}
}

class Book{
	String name;
	String info;
	
	void say() {
		System.out.println("书名: "+name+" , 简介: "+info);
	}
}


在这里插入图片描述

1.方法区

2.栈内存:对象的名称以及基本数据类型的值

一开始Book b1 为null

3.堆内存:new Book()得到0x1234内存地址

后 Book b1 为0x1234

Book b1 = new Book();

在这里插入图片描述

b1.name = “金苹果”;

b1.info = “讲述了果农种植金色苹果的辛勤路程.”;
在这里插入图片描述

Book b2 = b1;

b2.name = “嘿嘿嘿”;

b1.say();

在这里插入图片描述

}表示走完了,就要释放->b2->b1

在这里插入图片描述

GC的垃圾回收

对象创建内存03

package day01;
/**
 * 对象创建的内存细节
 * @author jiajun.lin
 *
 */
public class Demo1 {
	
	public static void main(String[] args){
		Book b1 = new Book();
		b1.name = "金苹果";
		b1.info = "讲述了果农终止金色苹果的辛勤路程";
		b1.say();
		
		Book b2 = new Book();
		b2.name = "银苹果";
		b2.info = "讲述了果农辛勤种植银苹果的过程. ";
		
		b2 = b1;
		b2.name = "铜苹果";
		b1.say();
		
	}
}

class Book{
	String name;
	String info;
	
	void say() {
		System.out.println("书名: "+name+" , 简介: "+info);
	}
}


在这里插入图片描述

描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

GC垃圾回收就是不存在对象引用

在这里插入图片描述

在这里插入图片描述

构造方法

构造器:至少一个构造方法,没有明确编写会自动生成一个

Person p = new Person();

package day01;

public class Demo2 {

	public static void main(String[] args) {
	
		System.out.println("1");
		
		Person2 p1 = new Person2();
		p1.name = "张三";
		p1.age = 18;
		p1.say();
	}
}

class Person2{
	
	//构造方法不存在返回值类型的声明,方法名称与类名完全一致
	//创建对象时候就调用了该方法
	Person2(){
		System.out.println("构造方法执行了");
	}
	
	String name;
	int age;
	
	void say() {
		System.out.println("自我介绍, 我是: "+name+" , 我的年龄:"+age);
	}
}

在这里插入图片描述

项目场景:链接数据仓库

创建对象,存储

Person2(String n){}是一个有参数的构造方法,

而Person2 p1 = new Person2();相当于调用了一个有参数的构造方法;

这意味着无法自动生成一个无参数且无任何代码的构造方法,必须传递一个参数

package day01;

public class Demo2 {

	public static void main(String[] args) {
	
		System.out.println("1");
		Person2 p1 = new Person2("haha");
		System.out.println("2");
		
		p1.name = "张三";
		p1.age = 18;
		p1.say();
	}
}

class Person2{
	Person2(String n){}
	
	String name;
	int age;
	
	void say() {
		System.out.println("自我介绍, 我是: "+name+" , 我的年龄:"+age);
	}
}

在这里插入图片描述

传入该参数的意义是什么?

可能我们想给对象传递一些值

package day01;

public class Demo2 {

	public static void main(String[] args) {
	
		//System.out.println("1");
		Person2 p1 = new Person2("张三");
		//System.out.println("2");
		
		//p1.name = "张三";
		p1.age = 18;
		p1.say();
	}
}

class Person2{
	Person2(String n){
		name = n;
	}
	
	String name;
	int age;
	
	void say() {
		System.out.println("自我介绍, 我是: "+name+" , 我的年龄:"+age);
	}
}

在这里插入图片描述

不要依赖自动生成的构造方法

方法的重载

啥是方法的重载?

    1. 方法名称相同
    • 2.参数列表长度 或 参数列表的类型 或 参数顺序不同
      • 注意: 与返回值类型无关

不同参数的相同方法

方法名称不同

package day01;

public class Demo2 {

	public static void main(String[] args) {
		
		Math m = new Math();
		int num = m.sum(100, 500);
		System.out.println(num);
		
		double num2 = m.sum2(10.5, 20.6);
		System.out.println(num2);
	}
}

// 命名规范	见名知意
class Math{
	
	//这个方法用于计算int类型的
	int sum(int x,int y) {
		int z = x+y;
		return z;
	}
	
	double sum2(double x,double y) {
		double z = x+y;
		return z;
	}
}

在这里插入图片描述

方法名称相同

package day01;

public class Demo2 {

	public static void main(String[] args) {
		
		Math m = new Math();
		int num = m.sum(100, 500);
		System.out.println(num);
		
		double num2 = m.sum(10.5, 20.6);
		System.out.println(num2);
	}
}

// 命名规范	见名知意
class Math{
	/**
	 * 
	 * 一个类中定义的方法, 是允许重载	(相同的方法名称)
	 * 
	 * 1. 方法名称相同
	 * 2.参数列表长度	或	参数列表的类型	或 (参数类型顺序不同)
	 * 
	 * 注意:	与返回值类型无关
	 */
	//这个方法用于计算int类型的
	int sum(int x,int y) {
		int z = x+y;
		return z;
	}
	
	double sum(double x,double y) {
		double z = x+y;
		return z;
	}
	
}

在这里插入图片描述

package day01;

public class Demo2 {

	public static void main(String[] args) {
		
		Math m = new Math();
		int num = m.sum(100, 500);
		System.out.println(num);
		
		double num2 = m.sum(10.5, 20.6);
		System.out.println(num2);
	}
}

// 命名规范	见名知意
class Math{
	/**
	 * 
	 * 一个类中定义的方法, 是允许重载	(相同的方法名称)
	 * 
	 * 1. 方法名称相同
	 * 2.参数列表长度	或	参数列表的类型	或 (参数类型顺序不同)
	 * 
	 * 注意:	与返回值类型无关
	 */
	//这个方法用于计算int类型的
	int sum(int x,int y) {
		int z = x+y;
		return z;
	}
	
	double sum(double x,double y) {
		double z = x+y;
		return z;
	}
	//参数类型顺序不同
	double sum(int x , double y) {
		double z = x+y;
		return z;
	}
	double sum(double y, int x) {
		double z = x+y;
		return z;
	}
}

方法重载:是根据传入的参数类型去调用方法

构造方法重载

package day01;
/**
 * 构造方法的重载:
 * 方法名称相同,参数的个数,类型不同
 * @author jiajun.lin
 *
 */

public class Demo3 {


	public static void main(String[] args) {
		
		Person3 p = new Person3("张三",18);
		p.say();
		
		Person3 p2 = new Person3("李四");
		p2.say();
	}
}

class Person3{
	
	Person3(String name2,int age2){
		name =name2;
		age = age2;
	}
	
	//构造方法重载
	Person3(String name2){
		name = name2;
	}
	
	String name;
	int age;
	
	void say() {
		System.out.println("自我介绍: 姓名: "+name+", 年龄: "+age);
	}
}

在这里插入图片描述

匿名对象

package day01;

public class Demo3 {
/**
 * 匿名:		没有名字,没有对象名,没有引用名
 * 本来程序的栈内存有名字,而堆中没有名字
 * 现在匿名就是栈内存没有名字,没有给对象取名字,就使用了一次
 * 匿名对象:num = new Math().sum(100, 200);
 * @param args
 */

	public static void main(String[] args) {
		//
		//Math2 m = new Math2();
		//int num = m.sum(100, 200);
		
		//相当于
		int num = new Math2().sum(100, 200);
		System.out.println(num);
	}
}

class Math2{
	
	int sum(int x,int y) {
		return x+y;
	}
}

在这里插入图片描述

匿名对象2

三个new,在堆内存中开辟了三个匿名对象

package day01;

public class Demo4 {

	/**
	 * 如果一个对象准备使用2次或以上,就一定要给对象创建对象名
	 * @param args
	 */
	public static void main(String[] args) {
		new Person5().name = "张三";
		new Person5().age = 18;
		new Person5().say();

	}

}

class Person5{
	String name;
	int age;
	
	void say() {
		System.out.println("自我介绍: 姓名: "+name+" ,年龄: "+age);
	}
}

在这里插入图片描述
在这里插入图片描述

编程规范

码出高效

alibaba Java 1.4.0

国内唯一参与java规则制定的公司

阿里巴巴编程规约插件

总结

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

低调的小哥哥

你的关注就是我为你服务的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值