扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 后端开发 > Python >java基础的详细了解第六天
  • 135

0
分享到

java基础的详细了解第六天

2024-04-02 19:04:59 135人浏览 独家记忆

Python 官方文档：入门教程 => 点击学习

摘要

目录1、this关键字1.1 “this.属性”表示本类属性1.2“this”表示调用本类方法1.3“this”表示当前对象1.4引用传递进阶分析1.5对象比较1.6引用传递实际应用

1、this关键字

首先需要提醒的是，在整个Java之中，this是最麻烦的一个关键字，只要是代码开发，几乎都离不开this。在Java中this可以完成三件事情：表示本类属性、表示本类方法、表示当前对象（只介绍概念）。

1.1 “this.属性”表示本类属性

在讲解着一操作之前首先观察如下程序：


class Person{
	private String name;
	private int age;
	public Person(String n,int a){
		name = n;
		age = a;
	}
	public String getInfo(){
		return "姓名:"+name+","+"年龄:"+age;
	}
}
public class ThisText{
	public static void main(String args[]){
		Person per = new Person("张三",20);
		System.out.println(per.getInfo());
	}
}

这个时候的构造方法的两额参数的目的是为了类中的name和age两额属性初始化，可是这个方法上的两个参数一个是字母n一个是字母a，什么意思？那么最好的做法，既然构造方法的两个参数是为了类中name和age初始化使用，那么最好将其参数名称也定义为name和age才最为直观。


public Person(String name,int age){
		name = name;
		age = age;
}

此时构造方法中参数的名称变得有意义了，但是这样一来就出现问题了，发现属性没有内容了！因为在程序之中是采用“{}”作为分界，采用就近的取用原则，所以现在为了明确指定要操作的是类中属性的话，那么应该采用“this.属性”的形式完成，代码应该变为：


public Person(String name,int age){
   	this.name = name;     //this.name   表示类中的属性name
   	this.age = age;
}

提示：在日后的所有开发过程之中，如果要调用类中属性的话，都要使用“this.属性”的方式来调用。

1.2“this”表示调用本类方法

对于一个类之中的方法分为两种：

1、普通方法：之前强调过，如果现在要调用的是本类之中的方法，则可以使用“this.方法()”调用。

2、构造方法：调用其他构造使用“this ()”调用。

例如：现在一个类之中存在了三个构造方法（无参、有一个参数、有两个参数），但是不管使用何种构造方法，都要求在实例化对象产生的时候输出一行提示信息：“欢迎光临”。


class Person{
	private String name;
	private int age;
	public Person(){
		System.out.println("-----欢迎光临-----");
	}
	public Person(String name){
		System.out.println("-----欢迎光临-----");
		this.name = name;
	}
	public Person(String name,int age){
		System.out.println("-----欢迎光临-----");
		this.name = name;
		this.age = age;
	}
	public String getInfo(){
		return "姓名:"+name+","+"年龄:"+age;
	}
}
public class ThisText1{
	public static void main(String args[]){
		Person per = new Person();
		System.out.println(per.getInfo());
	}
}

不过，遗憾的是按照之前的知识来讲，此时的程序之中会出现大量的重复代码，而这样的方法不是最优的。

这种情况下就可以利用this()来完成


class Person{
	private String name;
	private int age;
	public Person(){
		System.out.println("-----欢迎光临-----");
	}
	public Person(String name){
		this();           //调用无参构造方法
		this.name = name;
	}
	public Person(String name,int age){
		this(name);   //调用有一个参数的构造方法
		this.age = age; 
	}
	public String getInfo(){
		return "姓名:"+name+","+"年龄:"+age;
	}
    public class ThisText1{
	public static void main(String args[]){
		Person per = new Person();
		System.out.println(per.getInfo());
	}
}

使用this()就完成了构造方法之间的互相调用。

**注意：**在使用this()调用构造方法的时候有以下问题：

1、所有的构造方法实在对象实例化的时候被默认调用，而且是在调用普通方法之前调用，所以使用“this()”调用构造方法的操作，一定要放在构造方法的首行；

2、如果一个类之中存在了多种构造方法的话，并且这些构造方法都使用this()相互调用，那么至少要保证一个构造方法没有调用其他构造，以作程序的出口。

1.3“this”表示当前对象


class Dx{
	public void fun(){
			System.out.println("当前对象：" + this);
		}
}
public class Ob{
	public static void main(String args[]){
		Dx dx = new Dx();
		System.out.println(dx);
		dx.fun();
		Dx dx1 = new Dx();
		System.out.println(dx1);
		dx1.fun();
	}
}

image-20210731192229637

1.4引用传递进阶分析

程序一


class Message{
	private String num;
	public void setNum(String num){
		this.num = num;
	}
	public String getNum(){
		return num;
	}
}
public class TestDemo1{
	public static void main(String args[]){
		Message message = new Message();
		message.setNum("100");
		fun(message);
		//30
		System.out.println(message.getNum());
	}
	public static void fun(Message temp){	//引用传递
		temp.setNum("30");
	}
}

image-20210731193715762

程序二


public class TestDemo2{
	public static void main(String args[]){
		String str = "hello";
		fun(str);
		//hello
		System.out.println(str);
	}
	public static void fun(String temp){
		temp = "world";
	}
}

本程序的关键是：String的内容一旦声明则不可改变，改变的是内存的地址指向。

image-20210731200941440

1.5对象比较

对象的比较实际就是对象属性的比较。


class Person{
	private String name;
	private int age;
	public Person(String name,int age){
		this.name = name;
		this.age = age;
	}
	public void setName(String name){
		this.name = name;
	}
	public void setAge(int age){
		this.age = age;
	}
	public String getName(){
		return this.name;
	}
	public int getAge(){
		return this.age;
	}
}
public class TestDemo3{
	public static void main(String args[]){
		Person per1 = new Person("张三",20);
		Person per2 = new Person("张三",20);
		//false
		System.out.println(per1==per2);	//比较两个对象的地址
		//是同一个对象
		if(per1.getName().equals(per2.getName())&&per1.getAge() == per2.getAge()){
			System.out.println("是同一个对象");
		}
		else{
			System.out.println("不是同一个对象");
		}
	}
}

对象比较的操作一定是一个类自己本身所具备的功能，而且对象比较的操作特点：

  • 本类接收自己的引用，而后与本类当前对象（this）进行比较；
  • 为了避免NullPointerException的产生，应该增加一个null的判断；
  • 为了防止浪费性能的情况出现，可以增加地址数值的判断，相同的对象地址相同；
  • 之后与属性依次进行比较，如果属性全部相同，则返回true，否则返回false。

1.6引用传递实际应用


//电脑
class Computer{
	private View [];
	private Host;
}
//显示器
class View{
}
//主机
class Host{
	private Board;
}
//主板
class Board{
	private Cpu [];
	private Memory[];
	private Disk[];
}
//CPU
class Cpu{
}
//内存
class Memory{
}
//硬盘
class Disk{
}
public class TestDemo3{
	public static void main(String args[]){
	}
}

重点 1.7数据表与简单Java类（一对多）

利用此关系模型，表示出emp和dept的关系，使用字段：

​ **emp表：**empno、ename、job、sal、comm、mgr、deptno；

​ **dept表：**deptno、dname、loc。

第一步 编写实体类


class Emp{
	private int empno;
	private String ename;
	private String job;
	private double sal;
	private double comm;
	public Emp(int empno,String ename,String job,double sal,double comm){
		this.empno = empno;
		this.ename = ename;
		this.job = job;
		this.sal = sal;
		this.comm = comm;
	}
	public String getEmpInfo(){
		return "【Emp】 empno = " + this.empno +
				",ename = " + this.ename +
				",job； = " + this.job +
				",sal = " + this.sal +
				",comm = " + this.comm;
	}
}
class Dept{
	private int deptno;
	private String dname;
	private String loc;
	public Dept(int deptno, String dname, String loc){
			this.deptno = deptno;
			this.dname = dname;
			this.loc = loc;
	}
	public String getDept(){
		return "deptno = " + this.deptno +
				",dname = " + this.dname +
				",loc = " + this.loc;
	}
}
public class Exam1_7{
	public static void main(String args[]){
	}
}

第二步 进行关系设计

一个雇员属于一个部门，需要追加部门引用

一个雇员有一个领导，领导一定是自身关联

一个部门有一个雇员，需要一个对象数组来描述多个雇员信息


class Emp{
	private int empno;
	private String ename;
	private String job;
	private double sal;
	private double comm;
	private Emp mgr; //描述雇员的领导
	private Dept dept;	//描述雇员的部门
	public Emp(int empno,String ename,String job,double sal,double comm){
		this.empno = empno;
		this.ename = ename;
		this.job = job;
		this.sal = sal;
		this.comm = comm;
	}
	public void setMgr(Emp mgr){
		this.mgr  = mgr;
	}
	public Emp getMgr(){
		return this.mgr;
	}
	public void setDept(Dept dept){
		this.dept = dept;
	}
	public Dept getDept(){
		return this.dept;
	}
	public String getEmpInfo(){
		return "【Emp】 empno = " + this.empno +
				",ename = " + this.ename +
				",job； = " + this.job +
				",sal = " + this.sal +
				",comm = " + this.comm;
	}
}
class Dept{
	private int deptno;
	private String dname;
	private String loc;
	private Emp [] emps;	//一个部门有多个雇员
	public Dept(int deptno, String dname, String loc){
			this.deptno = deptno;
			this.dname = dname;
			this.loc = loc;
	}
	public void setEmps(Emp [] emps){
		this.emps = emps;
	}
	public Emp [] getEmps(){
		return this.emps;
	}
	public String getDept(){
		return "deptno = " + this.deptno +
				",dname = " + this.dname +
				",loc = " + this.loc;
	}
}
public class Exam1_7{
	public static void main(String args[]){
	}
}

此时基本类定义完成。

第三步 开发需求

主函数main


public class Exam1_7{
	public static void main(String args[]){
		//第一步、设置类对象的关系
		//1.分别创建各自对象实例化
		Dept dept = new Dept(10,"市场部","New York");
		Emp ea = new Emp(7345,"Rock","CLERK",800.0,0);
		Emp eb = new Emp(7567,"Joker","MANAGER",3050.0,0);
		Emp ec = new Emp(7825,"Ben","PRESIDENT",10000.0,0);
		//2.设置雇员和领导的关系
		ea.setMgr(eb);
		eb.setMgr(ec); 	//ec没有领导 自己就是最大的领导
		//3.设置雇员和部门的关系
		ea.setDept(dept);
		eb.setDept(dept);
		ec.setDept(dept);
		//4.设置部门的雇员
		dept.setEmps(new Emp[]{ea, eb, ec});
		//第二步、进行数据的取得
		//一个部门有多个雇员
		
		for(int i = 0; i <  dept.getEmps().length; i++){
			System.out.println(dept.getEmps()[i].getEmpInfo());
		}
		System.out.println();
		//一个雇员有一个领导	
		//【Emp】 empno = 7567,ename = Joker,job = MANAGER,sal = 3050.0,comm = 0.0
		System.out.println(ea.getMgr().getEmpInfo());
		//【Emp】 empno = 7825,ename = Ben,job = PRESIDENT,sal = 10000.0,comm = 0.0
		System.out.println(eb.getMgr().getEmpInfo());
		//Exception in thread "main" java.lang.NullPointerException 
		//没有设置关系 所以自己是老板 显示空指针异常
		//System.out.println(ec.getMgr().getEmpInfo());
		System.out.println();
		//一个雇员属于同个部门
		//deptno = 10,dname = 市场部,loc = New York
		System.out.println(ea.getDept().getDeptInfo());
		//deptno = 10,dname = 市场部,loc = New York
		System.out.println(eb.getDept().getDeptInfo());
		//deptno = 10,dname = 市场部,loc = New York
		System.out.println(ec.getDept().getDeptInfo());
	}
}

在上面的代码基础上进行改进


//一个部门有多个雇员,一个雇员有一个领导,一个雇员属于同个部门
		 
		for(int i = 0; i <  dept.getEmps().length; i++){
			System.out.println(dept.getEmps()[i].getEmpInfo());			
			if(dept.getEmps()[i].getMgr() != null){
				System.out.println("该雇员所属的领导" +
				dept.getEmps()[i].getMgr().getEmpInfo());
				System.out.println("该雇员所属的部门" +
				dept.getEmps()[i].getDept().getDeptInfo());
				System.out.println("------------------------------------------------------------------");
			}
			else{
				System.out.println("自己就是领导");
				System.out.println("------------------------------------------------------------------");
			}
		}

1.8数据表与简单Java类（多对多）

利用此关系模型，表示出student和course的关系，使用字段：

​ **student表：**stuid、name、age。

​ **course表：**cid、name、credit。

​ 关系表：学生编号、课程编号、成绩

要求：

可以找到一门课程，参加此次课程的所有学生信息和成绩

可以根据一个学生，找到所参加的所有课程和没门课程的一个成绩

第一步 编写实体类


class Student{
	private int stuid;
	private String name;
	private int age;
	public Student(int stuid, String name, int age){
		this.stuid = stuid;
		this.name = name;
		this.age = age;
	}
	public String getStuInfo(){
		return "【Student】stuid = " + this.stuid +
				",name = " + this.name +
				",age = " +this.age ;
	}
}
class Course{
	private int cid;
	private String name;
	private double credit;
	public Course(int cid, String name, double credit){
		this.cid = cid;
		this.name = name;
		this.credit = credit;
	}
	public String getCouInfo(){
		return "【Course】cid = " + this.cid +
				",name = " + this.name +
				",credit = " + this.credit;
	}
}
class StudentCourse{//学生选课
	private Student student;
	private Course course;
	private double score;
	public StudentCourse(Student student, Course course, double score){
		this.student =student;
		this.course = course;
		this.score = score;
	}
	public Student getStudent(){
		return this.student;
	}
	public Course getCrouse(){
		return this.course;
	}
	public double getScore(){
		return this.score;
	}
}

第二步 进行关系设计


class Student{
	private int stuid;
	private String name;
	private int age;
	private StudentCourse studentCourses [];
	public Student(int stuid, String name, int age){
		this.stuid = stuid;
		this.name = name;
		this.age = age;
	}
	public void setStudentCourses(StudentCourse []studentCourses){
		this.studentCourses = studentCourses;
	}
	public StudentCourse[] getStudentCourses(){
		return this.studentCourses;
	}
	public String getStuInfo(){
		return "【Student】stuid = " + this.stuid +
				",name = " + this.name +
				",age = " +this.age ;
	}
}
class Course{
	private int cid;
	private String name;
	private double credit;
	private StudentCourse studentCourses[];
	public Course(int cid, String name, double credit){
		this.cid = cid;
		this.name = name;
		this.credit = credit;
	}
	public void setStudentCourses(StudentCourse []studentCourses){
		this.studentCourses = studentCourses;
	}
	public StudentCourse[] getstudentCourses(){
		return this.studentCourses;
	}
	public String getCouInfo(){
		return "【Course】cid = " + this.cid +
				",name = " + this.name +
				",credit = " + this.credit;
	}
}
class StudentCourse{//学生选课
	private Student student;
	private Course course;
	private double score;
	public StudentCourse(Student student, Course course, double score){
		this.student =student;
		this.course = course;
		this.score = score;
	}
	public Student getStudent(){
		return this.student;
	}
	public Course getCrouse(){
		return this.course;
	}
	public double getScore(){
		return this.score;
	}
}

第三步 开发需求

主函数main


public class Exam1_8{
	public static void main(String args[]){
		//第一步、设置类对象的关系
		//1.分别创建各自对象实例化
		Student stu1 = new Student(107,"Rock",13);
		Student stu2 = new Student(108,"Joker",18);
		Student stu3 = new Student(109,"Perke",22);
		Course ca = new Course(1,"数据结构",4.0);
		Course cb = new Course(2,"计算机操作系统",2.0);
		Course cc = new Course(3,"SSM框架集合",3.0);
		//2.设置学生和课程的关系
		stu1.setStudentCourses(new StudentCourse[]{
			new StudentCourse(stu1,ca,78.0),
		});
		stu2.setStudentCourses(new StudentCourse[]{
			new StudentCourse(stu2,ca,87.0),
			new StudentCourse(stu2,cb,79.0)
		});
		stu3.setStudentCourses(new StudentCourse[]{
			new StudentCourse(stu3,ca,90.0),
			new StudentCourse(stu3,cb,95.0),
			new StudentCourse(stu3,cc,99.0)
		});
		//3.设置课程和学生的关系
		ca.setStudentCourses(new StudentCourse[]{
			new StudentCourse(stu1,ca,78.0),
			new StudentCourse(stu2,ca,87.0),
			new StudentCourse(stu3,ca,90.0)
		});
		cb.setStudentCourses(new StudentCourse[]{
			new StudentCourse(stu2,cb,79.0),
			new StudentCourse(stu3,ca,90.0)
		});
		cc.setStudentCourses(new StudentCourse[]{
			new StudentCourse(stu3,cc,99.0)
		});
		//第二步、进行数据的取得
		//可以找到一门课程，参加此次课程的所有学生信息和成绩
		
		System.out.println(ca.getCouInfo());
		for(int i = 0 ;i < ca.getStudentCourses().length ; i++){
			System.out.print("学生名单："+ ca.getStudentCourses()[i].getStudent().getStuInfo());
			System.out.println(",score = "+ ca.getStudentCourses()[i].getScore());	
		}
		System.out.println("--------------------------------------------------------------------");
		 //可以根据一个学生，找到所参加的所有课程和没门课程的一个成绩
		 
		 System.out.println(stu3.getStuInfo());
		for(int i = 0; i < stu3.getStudentCourses().length ; i++){
			System.out.print("选课列表：" + stu3.getStudentCourses()[i].getCourse().getCouInfo());
			System.out.println(",score = "+ stu3.getStudentCourses()[i].getScore());
		}	
	}
}

总结

本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注编程网的更多内容！

您可能感兴趣的文档:

--结束END--

本文标题: java基础的详细了解第六天

本文链接: https://lsjlt.com/news/132196.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

猜你喜欢
  • java基础的详细了解第六天
    目录1、this关键字1.1 “this.属性”表示本类属性1.2“this”表示调用本类方法1.3“this”表示当前对象1.4引用传递进阶分析1.5对象比较1.6引用传递实际应用...
    99+
    2024-04-02
  • java基础的详细了解第一天
    目录1、Java主要特点2、计算机的高级汇编语言类型：3、JVM（Java Visual Machine)4、编写第一个Java程序并运行5、CLASSPATH指的是类加载路径6、程...
    99+
    2024-04-02
  • java基础的详细了解第二天
    目录1、方法的基本定义2、方法重载3、方法的递归调用4、面向对象的前身是面向过程5、类与对象内存分析引用传递总结1、方法的基本定义 限制条件：本次所讲解的方法指的是在主类中定义，并且...
    99+
    2024-04-02
  • java基础的详细了解第三天
    目录1、private实现封装处理2、构造方法与匿名对象3、简单java类4、数组总结1、private实现封装处理 如果像想要知道封装，首先必须清楚如果没有封装会怎么样？ 没有封装...
    99+
    2024-04-02
  • java基础的详细了解第四天
    目录1、数组数组的引用传递数组的静态初始化数组与方法的调用Java对数组的支持数组的数据分析数组排序数组的转置数组的二分查找法对象数组总结1、数组 数组的引用传递 public ...
    99+
    2024-04-02
  • java基础的详细了解第五天
    目录1、String类1.1两种对象实例化方式1.2字符串比较1.3字符串常量是String的匿名对象1.4String两种实例化方式区别1、分析直接赋值方式2、构造方法赋值1.5字...
    99+
    2024-04-02
  • java基础的详细了解第七天
    目录1、static关键字1.1 使用static关键字定义属性1.2 使用static定义方法1.3 分析主方法1.4 关键字的使用2、代码块2.1 普通代码块2.2 构造块2.3...
    99+
    2024-04-02
  • java基础的详细了解第八天
    目录1、多态性1.1 向上转型1.2 向下转型2、抽象类2.1 抽象类的基本概念抽象方法为什么不能实例化对象？关于抽象类的若干中疑问？3、接口3.1 接口的基本概念3.2 接口的使用...
    99+
    2024-04-02
  • java基础的详细了解第九天
    目录1、匿名内部类2、Object类简介 2.1 取得对象信息toString()2.2 对象的比较equals()2.3 Object接口引用数据类型3、包装类3.1 装箱与拆箱3...
    99+
    2024-04-02
  • MySQL基础(六)-索引（index）详解
    目录 一、什么是索引？ 二、索引的实现原理 三、在MySQL中，主键、unique字段上会自动添加索引。 四、索引的创建与删除 创建索引： 删除索引： 五、查看SQL语句是否使用了索引 六、索引的失效 失效的第一种情况：模糊匹配当中以“%”...
    99+
    2023-09-01
    sql 数据库
  • Java面试题冲刺第一天--基础篇1
    目录面试题1：Java 中操作字符串都有哪些类？它们之间有什么区别？ 正经回答：深入追问：追问1：这三者在效率上怎么说？追问2：那StringBuffer和StringBuffer线...
    99+
    2024-04-02
  • Java面试题冲刺第五天--基础篇2
    目录面试题1：说一下抽象类和接口有哪些区别？正经回答：深入追问：追问1：说一说你对抽象类的理解吧，他到底是干啥用的追问2：用抽象类实现一个接口，和普通类实现接口会有什么不同么？追问3...
    99+
    2024-04-02
  • java基础第23天_数据库连接池\反射
    1.属性赋值-------------1.Man{50+ }Man man = new Man();man.setXxx1(...);man.setXxx2(...);...50Man copy = new...
    99+
    2024-04-02
  • Java面试题冲刺第十七天--基础篇3
    目录面试题1：JDK1.8的新特性有哪些？接口的默认和静态方法：Lambda 表达式：方法与构造函数引用：函数式接口：Annotation 注解：支持多重注解：新的日期时间 API：...
    99+
    2024-04-02
  • 【Java基础】- HttpURLConnection详解
    【Java基础】- HttpURLConnection详解 文章目录 【Java基础】- HttpURLConnection详解一、HttpURLConnection简述二、HttpURLCo...
    99+
    2023-09-09
    java servlet 开发语言 HttpURL
  • Java中的类（基础详解）
    文章目录 可以有多个类，但只能有一个public类类 = 字段+方法类的构造函数我们没写构造函数的时候如果我们自己写了构造函数构造函数中 this 的使用 类的修饰符 / 控制符第一...
    99+
    2023-09-01
    java jvm c++
  • 【Java 基础篇】Java Collection详解
    文章目录 导言一、Collection 简介二、List 接口三、Set 接口四、Map 接口总结 导言 Java的Collection框架是一组用于存储和操作对象的接口和类。它提供了...
    99+
    2023-09-14
    java 开发语言 jvm
  • 【Java 基础篇】Java Map 详解
    文章目录 导言一、Map 概述二、HashMap三、TreeMap四、LinkedHashMap总结 导言 在Java的集合框架中，Map接口用于存储键值对，提供了一种基于键进行查找和操作的数据结构。Map接口的实现类提供了...
    99+
    2023-08-30
    java 开发语言 数据结构
  • 【Java 基础篇】Java List 详解
    文章目录 导言一、List 概述二、ArrayList三、LinkedList四、Vector总结 导言 在Java的集合框架中，List接口是一个有序、可重复的集合，它扩展了Coll...
    99+
    2023-09-11
    java list 数据结构
  • 【Java 基础篇】Java Set 详解
    文章目录 导言一、Set 概述二、HashSet三、TreeSet四、LinkedHashSet总结 导言 在Java的集合框架中，Set接口是一个无序、不可重复的集合，它扩展了Col...
    99+
    2023-10-18
    java 开发语言 数据结构
软考高级职称资格查询
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作