【JavaSE：面向对象上】笔记

最新推荐文章于 2024-09-27 00:45:01 发布

frank-ppt

最新推荐文章于 2024-09-27 00:45:01 发布

阅读量63

点赞数

分类专栏： java基础专栏文章标签： java

本文链接：https://blog.csdn.net/weixin_50627619/article/details/119247649

版权

java基础专栏专栏收录该内容

1 篇文章 0 订阅

订阅专栏

Author：frank
第一篇博客，写得不对的地方，忘大佬指正

面向对象——上

1.面向对象的特征之一：封装性

封装性的通俗理解

在一个类中将类中的属性或者方法用private修饰之后，外界就不能直接调用此类中private修饰的东西，只能在此类的内部进行调用。

将一个类中的方法进行private修饰后，此方法只能在这个类中使用。对外不公布这个方法，只对内使用。

常见的封装性的体现

1. 我们将类的属性xxx私有化(private),同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值。这并不是封装性的全部，只是封装性的体现之一。
2. 不对外暴露的私有的方法 (通常这个私有的方法在这个类中完成的是某一项功能，在类中其他方法中都多次用到了这个私有功能，将这个功能封装起来，不对外公开)
3. 单例模式(将构造器私有化)
4.如果不希望类在包外被调用，可以将类设置为缺省的
......

封装性的体现，需要权限修饰符来配合

1.Java规定的4种权限（从小到大排列）：private、缺省、protected 、public 
2.4种权限可以用来修饰类及类的内部结构（属性、方法、构造器、内部类）
3.具体的，4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类。修饰类的话，只能使用：缺省、public

四种权限修饰符的大小对比

在这里插入图片描述

文件层级(由大到小)

项目(模块)>包>类

***我的理解：***

如果想要使用同一个工程的不同包下的类，此时需要导包到具体的类才能使用此类。此类只有是public修饰的才能访问，缺省的类不能访问。
一个类中不能使用不同工程下的类。想要使用的可以用第3点的方法
如果想要使用一个类被public修饰，如果想要跨工程使用的话。可以在一个工程下将此类打成一个jar包然后放在另一个工程下面才可以使用这个类。
public修饰的类可以在同一个工程下任意使用。

总结封装性

封装性的体现无处不在，用public修饰也是封装性的一种体现，只要用四种修饰符进行修饰就是封装性的体现。Java提供了4种权限修饰符来修饰类及类的内部结构，体现类及类的内部结构在被调用时的==可见性的大小==。

2.构造器

类的结构之三

构造器（或构造方法、constructor）的使用

构造器的作用

创建对象
创建对象的同时可以给对象的信息进行初始化(给构造器加入形参即可)

构造器的规定

1.如果没有显式的定义类的构造器的话，则系统默认提供一个无参的构造器
2.定义构造器的格式：权限修饰符类名(形参列表){}
3.一个类中定义的多个构造器，彼此构成重载
4.一旦我们显式的定义了有参数的类的构造器之后，系统就不再提供默认的无参构造器
5.一个类中，至少会有一个构造器。

构造器的修饰权限问题

系统默认提供的无参构造器的权限大小和所创建的类的权限大小一样。

当一个类是public，说明这个类可以在一个项目的所有包下都可以被创建对象来使用，这是因为该类的构造器只能是public修饰的，这个构造器的权限范围是最大的。当一个类是缺省，此时这个类也只能在一个包在被调用，这是因为该类的构造器只能缺省的，所以只能在同一个包在被使用

构造器可不是方法

我们所说的构造器有时候又被叫做构造方法，但是构造器(构造方法)不是一个方法，它和方法是两个不同的概念

总结构造器

构造器的作用就是给对象的信息进行初始化操作的。

3.属性赋值的先后顺序

属性赋值的顺序

默认初始化
显式初始化
构造器进行初始化
通过"对象.方法" 或 "对象.属性"的方式，赋值

***以上操作的先后顺序：***① - ② - ③ - ④ (其中①②③是在执行创建对象的过程，所以这三步只会出现一次，而④你可以对它进行多次操作)

4.this关键字

什么是this?

this就代表当前类的对象的引用，它就代表当前类的一个***对象***。

方法被谁（对象）调用，在方法内部的this就代表那个对象。

**this可以简单的理解为：**当前对象或当前正在创建的对象。当前对象(this)指的是调用这个方法的那个对象

this的用法

this可以用来调用：属性、方法、构造器

this调用方法：

我们可以使用"this.属性"或"this.方法"的方式，调用当前对象属性或方法。但是，通常情况下，我们都选择省略"this."。特殊情况下，如果方法的形参和类的属性同名时，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。
this调用方法：

我们可以使用"this.属性"或"this.方法"的方式，调用当前对象属性或方法。但是，通常情况下，我们都选择省略"this."。特殊情况下，如果方法的形参和类的属性同名时，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。
this调用构造器：
1. 我们在类的构造器中，可以显式的使用"this(形参列表)"方式，调用本类中指定的其他构造器
2. 构造器中不能通过"this(形参列表)"方式调用自己
3. 如果一个类中有n个构造器，则最多有 n - 1构造器中使用了"this(形参列表)
4. 规定："this(形参列表)"必须声明在当前构造器的首行
5. 构造器内部，最多只能声明一个"this(形参列表)"，用来调用其他的构造器

this调用构造器的应用

class Person{

	private String name;
	private int age;


	public Person(){

//		this.eat();
		String info = "Person初始化时，需要考虑如下的1,2,3,4...(共40行代码)";
		System.out.println(info);
	}

	public Person(String name){
		this();//调用当前类的无参构造器
		this.name = name;

	}

	public Person(int age){
		this();//调用当前类的无参构造器
		this.age = age;

	}

	public Person(String name,int age){
		this(age);//调用当前类的形参为age的构造器
		this.name = name;
		//this.age = age;
		//Person初始化时，需要考虑如下的1,2,3,4...(共40行代码)
	}

	public void setName(String name){
		this.name = name;
	}
	public String getName(){
		return this.name;
	}
	public void setAge(int age){
		this.age = age;
	}
	public int getAge(){
		return this.age;
	}
}

***解释：***通过构造器调用另一个构造器这种方式可以解决代码重复的情况。一个构造器内部调用另一个已经写好代码的另构造器。

this与super的使用区别

调用成员变量：

this.成员变量调用本类的成员变量
super.成员变量调用父类的成员变量
调用构造方器：

this(…) 调用本类的构造器
super(…) 调用父类的构造器
调用成员方法：

this.成员方法调用本类的成员方法
super.成员方法调用父类的成员方法

this的综合应用

public class BoyGirlTest {
	public static void main(String[] args) {

		Boy boy = new Boy("罗密欧", 21);
		boy.shout();

		Girl girl = new Girl("朱丽叶", 18);
		girl.marry(boy);

		Girl girl1 = new Girl("祝英台",19);
		int compare = girl.compare(girl1);
		if(compare > 0){
			System.out.println(girl.getName() + "大");
		}else if(compare < 0){
			System.out.println(girl1.getName() + "大");
		}else{
			System.out.println("一样大");
		}

	}
}
class Girl {

	private String name;
	private int age;

	public Girl() {

	}

	public Girl(String name, int age) {
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public void marry(Boy boy) {
		System.out.println("我想嫁给" + boy.getName());
		boy.marry(this);// this指当前对象
	}

	/**
	 * 
	 * @Description 比较两个女生对象的大小
	 * @author shkstart
	 * @date 2019年1月18日下午4:02:09
	 * @param girl
	 * @return 正数：当前对象大； 负数：当前对象小 ； 0：当前对象与形参对象相等
	 */
	public int compare(Girl girl) {
//		if(this age > girl.age){
//			return 1;
//		}else if(this.age < girl.age){
//			return -1;
//		}else{
//			return 0;
//		}

		return this.age - girl.age;// this指代的是当前对象

	}

}

class Boy {
	private String name;
	private int age;

	public Boy() {

	}

	public Boy(String name) {
		this.name = name;
	}

	public Boy(String name, int age) {
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}

	public void marry(Girl girl){
		System.out.println("我想娶" + girl.getName());
	}

	public void shout(){
		if(this.age >= 22){
			System.out.println("你可以去合法登记结婚了！");
		}else{
			System.out.println("先多谈谈恋爱~~");
		}

	}
}

我的理解：

this出现在哪一个类中，就是这个类中的一个对象。

this == 当前对象 == 调用这个方法的那个对象

5.Package关键字

package关键字的使用

1.为了更好的实现项目中类的管理，提供包的概念
2.使用package声明类或接口所属的包，声明在源文件的首行
3.包，属于标识符，遵循标识符的命名规则、规范(xxxyyyzzz)、“见名知意”
4.每"."一次，就代表一层文件目录。

补充：

同一个包下，不能命名同名的接口、类。

不同的包下，可以命名同名的接口、类。

6.import关键字

import关键字的使用

在源文件中显式的使用import结构导入指定包下的类、接口
声明在包的声明和类的声明之间
如果需要导入多个结构，则并列写出即可
可以使用"xxx.*"的方式，表示可以导入xxx包下的所有结构
如果使用的类或接口是java.lang包下定义的，则可以省略import结构。其他包下的类或者接口不会省略。
如果使用的类或接口是本包下定义的，则可以省略import结构
如果在源文件中，使用了不同包下的同名的类，则必须至少有一个类需要以全类名的方式显示。
使用"xxx.*"方式表明可以调用xxx包下的所有结构。但是如果使用的是xxx子包下的结构，则仍需要显式导入。
import的落脚点最后都是一个类或者接口

package com.atguigu.java2;

import static java.lang.Math.round;
import static java.lang.System.out;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.Scanner;

import com.atguigu.exer4.Account;
import com.atguigu.exer4.Bank;


/*
以下三点不需要掌握，了解一下即可

1. import static:导入指定类或接口中的静态结构:属性或方法。 (import static最终的落脚点是类中的静态结构，而不是类)
2. import static java.lang.System.*;//表示导入的是lang包下的System类中的所有静态的结构
3. import static java.lang.System.out;//具体到某一个静态结构
*/
public class PackageImportTest {
	public static void main(String[] args) {

		String info = Arrays.toString(new int[] { 1, 2, 3 });

		Bank bank = new Bank();

		ArrayList list = new ArrayList();
		HashMap map = new HashMap();

		Scanner s = null;

		System.out.println("hello!");

		Person p = new Person();

		Account acct = new Account(1000);

		// 全类名的方式显示
		com.atguigu.exer3.Account acct1 = new com.atguigu.exer3.Account(1000, 2000, 0.0123);

		// 比如说Date这个类在util和sql包下都有，那么在调用的时候两个的时候，有一个需要全类名显示
		Date date = new Date();
		java.sql.Date date1 = new java.sql.Date(5243523532535L);

		Field field = null;// Field这个类在java.lang.reflect下。虽然看上去是lang包里面的，其实这个包和lang包是平行关系，各自都是独立的包。

		// 使用的是import static的方式(了解)
		out.println("hello");
		long num = round(123.434);
	}
}