Java语言学习笔记-【07面向对象、类与对象、成员方法、作用域、this等详解(下)】

于 2025-03-20 19:26:54 发布
阅读量681 收藏 20
点赞数 16
分类专栏： Java基础【第一阶段】 笔记 文章标签： java 学习 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_67947670/article/details/146403957
版权

在这里插入图片描述
在B站跟着一位很厉害的老师学完了javaSE的内容，现开始进行复盘总结知识点，希望可以给java基础薄弱的友友提供一点参考，一起学习Java初级知识，共同进步，打好底层逻辑基础，爱上Java编程❤️❤️❤️
（本文章中知识点如有不同的见解，欢迎评论区留言）

第7章 面向对象编程基础【下】

4、Overload(方法重载)

基本介绍
java中允许同一个类中，多个同名方法的存在，但要求形参列表不一致！
比如：System.out.println(); out是printstream(输出流) 类型

  • 重载的好处
    • 减轻了起名的麻烦
    • 减轻了记名的麻烦


方法名一样,参数不同 , 与返回值无关

4.1、快速入门案例

OverLoad01.java

案例：类：MyCalculator 方法：calculate

  1. calculate(int n1, int n2) //两个整数的和

  2. calculate(int n1, double n2) //一个整数，一个 double 的和

  3. calculate(double n2, int n1)//一个 double ,一个 Int 和

  4. calculate(int n1, int n2,int n3)//三个 int 的和

代码实现 : 

public class OverLoad01 {
    //编写一个 main 方法
    public static void main(String[] args) {
        // System.out.println(100);
        // System.out.println("hello,world");
        // System.out.println('h');
        // System.out.println(1.1);
        // System.out.println(true);

        MyCalculator mc = new MyCalculator();
        System.out.println(mc.calculate(1, 2));
        System.out.println(mc.calculate(1.1, 2));
        System.out.println(mc.calculate(1, 2.1));
    }
}

class MyCalculator {
    //下面的四个 calculate 方法构成了重载
    //两个整数的和
    public int calculate(int n1, int n2) {
        System.out.println("calculate(int n1, int n2) 被调用");
        return n1 + n2;
    }

    //没有构成方法重载, 仍然是错误的，因为是方法的重复定义
    // public void calculate(int n1, int n2) {
    // System.out.println("calculate(int n1, int n2) 被调用");
    // int res = n1 + n2;
    // }

    //看看下面是否构成重载, 没有构成，而是方法的重复定义,就错了
    // public int calculate(int a1, int a2) {
    // System.out.println("calculate(int n1, int n2) 被调用");
    // return a1 + a2;
    // }
    //一个整数，一个 double 的和
    public double calculate(int n1, double n2) {
        return n1 + n2;
    }

    //一个 double ,一个 Int 和
    public double calculate(double n1, int n2) {
        System.out.println("calculate(double n1, int n2) 被调用..");
        return n1 + n2;
    }

    //三个 int 的和
    public int calculate(int n1, int n2, int n3) {
        return n1 + n2 + n2;
    }
}

4.2、Overload细节Detail

注意事项和使用细节
1)方法名：必须相同
2)参数列表：必须不同（参数类型或个数或顺序，至少有一样不同，参数名无要求）
3)返回类型：无要求

4.3、OverLoad课堂练习题

4.3.1、判断题

答案 : b , c , d , e

4.3.2、题2

这里提供一个Math的pow()方法，用于计算一个数的n次方
如：Math.pow(3,2); -------即，3的2次方

//OverLoadExercise02
public class OverLoadExercise02 {
//编写一个 main 方法
public static void main(String[] args) {
    Method method = new Method();
    method.m(10);//100
    method.m(10,20);//200
    method.m("小洪爱编程");

    }
}
class Method{
    //分析
    //1、方法名 m
    //2、形参 (int)
    //3、void
    public void m(int m){
        System.out.println("平方 = " + (m * m));
    }

    public void m(int n1 ,int n2){
        System.out.println("相乘 = " + (n1 * n2));
    }

    public void m(String str){
        System.out.println("传入的String = " + str);
    }
}

在这里插入图片描述

4.3.3、重载方法练习

//OverLoadExercise02
public class OverLoadExercise02 {
//编写一个 main 方法
public static void main(String[] args) {
    Method method = new Method();
    method.m(10);//100
    method.m(10,20);//200
    method.m("小洪爱编程");


    //测试
    System.out.println(method.max(10,24));
    System.out.println(method.max(10,24.2));
    System.out.println(method.max(10,24.5,1.5));

    }
}
class Method{
    //分析
    //1、方法名max
    //2、形参(int , int)
    //3、int
    public int max(int n1,int n2) {
        return n1 > n2 ? n1 : n2;
    }
    //分析
    //1、方法名max
    //2、形参(double , double)
    //3、double
    public double max(double n1,double n2) {
        return n1 > n2 ? n1 : n2;
    }
    //分析
    //1、方法名max
    //2、形参(double , double,double)
    //3、double
    public double max(double n1,double n2,double n3) {
        double max = n1 > n2 ? n1 : n2;
        return n3 > max ? n3 : max;
    }



    //分析
    //1、方法名 m
    //2、形参 (int)
    //3、void
    public void m(int m){
        System.out.println("平方 = " + (m * m));
    }

    public void m(int n1 ,int n2){
        System.out.println("相乘 = " + (n1 * n2));
    }

    public void m(String str){
        System.out.println("传入的String = " + str);
    }
}

5、可变参数

5.1、初步认识

1、方法：test(int... nums)
int…可变参数类型 重点要加上三个点(…)

5.1.1、快速入门案例

代码实现 :

//VarParameter01
public class VarParameter01 {
//编写一个 main 方法
public static void main(String[] args) {
    Method m = new Method();
    m.sum(1,5,100);
    }
}
class Method{
    //1. int... 表示接受的是可变参数，类型是 int ,即可以接收多个 int(0-多)
    //2. 使用可变参数时，可以当做数组来使用 即 nums 可以当做数组
    //3. 遍历 nums 求和即可
    public int sum(int... nums) {
        System.out.println("接受的参数个数 = " + nums.length);
        return 0;
    }
}

5.2、可变参数细节Detail

可变参数的实参可以是数组

//VarParameterDetail
public class VarParameterDetail {
//编写一个 main 方法
public static void main(String[] args) {
    //细节: 可变参数的实参可以为数组
    int[] arr = {1,2,3};
    T t1 = new T();
    t1.f1(arr);
    }
}
class T{
    
    public void f1(int... nums){
        System.out.println("长度=" + nums.length);
    }
    //细节 : 可变参数可以和普通类型的参数一起放在形参列表 , 但必须保证可变参数在最后
    public void f2(String str,double... nums) {

    }

    //一个方法只能有一个可变参数
    // public void f3(int... nums1,int... nums1){//错误写法

    // }
}

5.1.2.1、可变参数练习

//VarParameterExercise
public class VarParameterExercise{
	public static void main(String[] args){
			HspMethod Scores = new HspMethod();
			String sumScores = Scores.showScore("Lisa" , 11.5 , 12.2);
			String sumScores2 = Scores.showScore("terry" , 11.5 ,15.2 ,14.6 , 12.2);
			System.out.println(sumScores);
			System.out.println(sumScores2);
	}
}

	/*
	有三个方法，分别实现返回姓名和两门课成绩(总分)，
	返回姓名和三门课成绩(总分)，返回姓名和五门课成绩（总分）。
	封装成一个可变参数的方法
	*/
class HspMethod{
	//分析   1. 方法名 showScore 2. 形参(String ,double... ) 
	//		3. 返回 String
	//听课小伙伴，老师要求必须自己动手写
	public String showScore(String name , double... cores){
		double sumScores = 0;
		for (int i = 0; i < cores.length ;i++ ) {
			sumScores += cores[i];
		}
		return name + " 有 " + cores.length + "门成绩的总分为=" + sumScores;
	}
}

在这里插入图片描述

6、作用域

基本使用

6.1、Scope快速入门

细节1 :

局部变量必须赋值后, 才能使用, 因为没有默认值(*)

//VarScope
public class VarScope{
	public static void main(String[] args){
			HspMethod Scores = new HspMethod();
			String sumScores = Scores.showScore("Lisa" , 11.5 , 12.2);
			String sumScores2 = Scores.showScore("terry" , 11.5 ,15.2 ,14.6 , 12.2);
			System.out.println(sumScores);
			System.out.println(sumScores2);
	}
}

class Cat{

	//全局变量：也就是属性，作用域为整个类体 Cat 类：cry eat 等方法使用属性
	//属性在定义时，可以直接赋值
	int age = 20;

	//全局变量(属性)可以不赋值，直接使用，因为有默认值，
	double weight;//默认值:0.0

	public void hi(){
		//局部变量必须赋值后, 才能使用, 因为没有默认值
		// int num;//错误声明, 未初始化
		int num = 1;
		String address = "北京的猫";
		System.out.println("num=" + num);
		System.out.println("address=" + address);
		System.out.println("weight=" + weight);
	}
	public void cry(){
	//1、全局变量; 也就是属性, 作用域为整个类体 Cat类: cry eat等方法使用属性
	//2、n 和 name 就是局部变量
	//3、n 和 name的作用域在 cry方法中	
		int n = 10;
		{
			int number = 10;
		}
		String name = "jack";
		System.out.println("在cry中使用属性 age=" + age);
	}
	public void eat() {
		System.out.println("在eat中使用属性 age=" + age);
		// System.out.println("在eat中使用属性 cry的变量 name=" + name);//错误使用方法,调用的局部变量,不可用name
	}
}

6.2、作用域(Scope)细节(Detail)

代码演示 :

//VarScopeDetail01
public class VarScopeDetail01{
	public static void main(String[] args){
			Person p1 = new Person();
			T t = new T();
			t.test();//第一种跨类访问对象属性的方式
			t.test2(p1);//第二种跨类访问对象属性的方式
	}
}

class T {
	public void test(){
		Person p1 = new Person();
		System.out.println(p1.name);//jack
	}
	public void test2(Person p) {
		System.out.println(p.name);//jack
	}
}
class Person{
	//细节: 属性可以加修饰符(public protected private...)
	//		局部变量不能加修饰符
	public int age = 20;
	String name = "jack";

	public void say() {
		//细节 属性和局部变量可以重名
		String name = "king";//此时打印的是局部变量的值
		System.out.println("say() name = " + name);
	}
}

细节2

//VarScopeDetail01
public class VarScopeDetail01{
	public static void main(String[] args){
			Person p1 = new Person();
			T t = new T();
			t.test();//第一种跨类访问对象属性的方式
			t.test2(p1);//第二种跨类访问对象属性的方式
	}
}

class T {
	public void test(){
		Person p1 = new Person();
		System.out.println(p1.name);//jack
	}
	public void test2(Person p) {
		System.out.println(p.name);//jack
	}
}
class Person{
	//细节: 属性可以加修饰符(public protected private...)
	//		局部变量不能加修饰符
	public int age = 20;
	String name = "jack";

	public void say() {
		//细节 属性和局部有变量可以重名
		String name = "king";//此时打印的是局部变量的值
		System.out.println("say() name = " + name);
	}
}

7、构造器(*)

javap的使用方式

如果给类定义构造器 , 那么原来的构造器就作废了,即T t1 = new T();报错,构造器声明后:

class Dog {

public Dog(int age){ }//覆盖了默认构造器–》public Dog() { }

}

Person p = new Person();

p是一个对象的引用

对象创建的流程分析:

  • 流程分析(面试题)
    • 加载Person类信息(Person.class),只会加载一次
    • 在堆中分配空间(地址)
    • 完成对象初始化
      • 3.1默认初始化 age = 0 name = null
      • 3.2显示初始化(age = 90,name=null,
      • 3.3构造器的初始化age = 20,name = 小倩
    • 把对象在堆中的地址, 发回给p(p是对象名,也可以理解成对象的引用)

8、This 用法

8.1、什么是This?

代码实现 :

//This01
public class This01 {
//编写一个 main 方法
public static void main(String[] args) {
    Dog dog1 = new Dog("萨摩" ,3);
    dog1.info();
 }
}
class Dog{ // 类
    String name;
    int age;
    // public Dog(String dName,int dAge) {//构造器
    //     name = dName;
    //     age = dAge;
    // }
    //如果我们构造器的形象 , 能够直接写成属性名,就更好了
    //但是出现了一个问题,根据变量的作用域原则
    //构造器的name 就是局部变量, 而不是属性
    //构造器的age  就是局部变量, 而不是属性
    //---》引出this关键字来解决
    public Dog(String name,int age) {//构造器
        // name = name;
        // age = age;//出现问题
        
        // name = this.name;
        // age = this.age;//也为初始值

        this.name = name;
        this.age = age;
    }
    public void info() {
        System.out.println(name + "\t" + age +"\t");
    }
   
}

在这里插入图片描述

8.2、This在JVM内存图

this是堆中对象,可以表示对象本身

HashCode简单可以理解为地址,但不是地址 (不那么精准)

代码实现

Dog dog1 = new Dog("萨摩" ,3);
    System.out.println("dog1的hashcode = " + dog1.hashCode());

 public Dog(String name,int age) {//构造器
        // name = name;
        // age = age;//出现问题
        
        // name = this.name;
        // age = this.age;//也为初始值

        this.name = name;
        this.age = age;
        System.out.println("this的hashcode" + this.hashCode());
    }


dog1是一个hashCode值,dog2是一个hashCode,他们两个不相同

8.3、This使用细节Detail

代码实现 :

//ThisDetail
public class ThisDetail {
//编写一个 main 方法
public static void main(String[] args) {
    T t1 = new T();
    t1.f2();
 }
}
class T{ // 类
    //细节: 访问成员方法的语法: this.方法名(参数列表);

    public void f1() {
        System.out.println("f1() 方法...");
    }
    public void f2() {
        System.out.println("f2() 方法...");
        //调用本类的 f1
        //第一种方式
        f1();
        //第二种方式
        this.f1();
    }
    
   
}

this(形参列表);————> 调用构造器方法,必须放置第一条

如果在 构造器中访问 另一个构造器 ,只能将语句放在第一条语句(用this访问)

//ThisDetail
public class ThisDetail {
//编写一个 main 方法
public static void main(String[] args) {
  
    T t2 = new T();
 }
}
class T{ // 类

    /*
    细节: 访问构造器语法 : this(参数列表);
    注意只能在构造器中使用(即只能在构造器中访问另一个构造器)
    */
    public T(){
        this("jack" ,100);//访问另一个构造器,让this放在第一条语句
        System.out.println("T() 构造器");
        //这里去访问 T(String name,int age);
    }
    public T(String name , int age){
        System.out.println("T(String name , int age) 构造器");

    }
    
   
}

8.4、This课堂案例

代码实现 :

//TestPerson
public class TestPerson {
//编写一个 main 方法
public static void main(String[] args) {
    Person p1 = new Person("marry" ,20);
    // Person p2 = new Person("smith" ,30);
    Person p2 = new Person("marry" ,20);

    System.out.println(p1.compare(p2));//p2.name = smith 返回false

 }
}

    /**
    * 在前面定义的 Person 类中添加两个构造器:
    * 第一个无参构造器：利用构造器设置所有人的 age 属性初始值都为 18
    * 第二个带 pName 和 pAge 两个参数的构造器：
    * 使得每次创建 Person 对象的同时初始化对象的 age 属性值和 name 属性值。
    * 分别使用不同的构造器，创建对象. */
class Person{ // 类
    String name;
    int age;
    //构造器
    public Person(String name ,int age){
            this.name = name;
            this.age = age;
    }
    //compareTo比较方法
    public boolean compare(Person p){
        // if(this.name == p.name && this.age == p.age){
        //     return true;
        // }else{
        //     return false;
        // }
        //简化
        return (this.name.equals(p.name) && (this.age == p.age));
    }
}

9、本章作业

1、检索最大值max

**代码实现 : **

//Homework01
public class Homework01 {
//编写一个 main 方法
public static void main(String[] args) {
    A01 a = new A01();
    System.out.println(a.max(3.2,5.5));

 }
}

class A01{ // 类
    public double max(double d1,double d2) {
        return (d1 >= d2 ? d1 : d2);
    }
}

2、查找匹配find

//Homework02
public class Homework02 {
//编写一个 main 方法
public static void main(String[] args) {
    A02 a = new A02();
    System.out.println(a.find("Lisa"));
 }
}

class A02{ // 类
    public int find(String str) {
        String[] strs = {"Lisa","Luhu","Dahua"};
        for (int i = 0;i < strs.length ;i++ ) {
            if(str.equals(strs[i])){
                return i;
            }
        }
        return -1;
    }
}

3、Book对象判断条件

//Homework03
public class Homework03 {
//编写一个 main 方法
public static void main(String[] args) {
    Book a = new Book(105.5);
    System.out.println("修改后的price:" + a.price);

 }
}

class Book{ // 类
    double price;
    public Book(double price){
        this.price = price;
        updatePrice(this.price);
    }
    public double updatePrice(double price) {
       if(price > 150){
        this.price = 150;
       }else if(price > 100){
            this.price = 100;
            System.out.println("price 》 100");
       }
       return this.price;
    }
}

4、copyArr复制数组内容

//Homework04
public class Homework04 {
//编写一个 main 方法
public static void main(String[] args) {
    int[] arr =  {3,4,5,6};
    A03 a = new A03();
    int[] newArr =  new int[arr.length];
    newArr = a.copyArr(arr);
    
    System.out.println("arr的hashCode" + arr.hashCode());
    System.out.println("newArr的hashCode" + newArr.hashCode());

    System.out.println("新数组:");
    for (int i = 0;i <newArr.length ;i++ ) {
        System.out.print(newArr[i] + " ");
    }

 }
}

class A03{ // 类
    public int[] copyArr(int[] arr){
        int[] newArr = new int[arr.length];
        for (int i = 0; i < arr.length ;i++ ) {
            newArr[i] = arr[i];
        }
        return newArr;
    }
}

5、计算Circle面积

//Homework05
public class Homework05 {
//编写一个 main 方法
public static void main(String[] args) {
    Circle cir = new Circle();
    double longth = cir.zhouChang(3);
    double area = cir.area(3);
    System.out.println("周长:" + longth);
    System.out.println("面积:" + area);

 }
}

class Circle{ // 类
    double radius;
   
    public double zhouChang(double radius){
        double longth = radius * 2 * 3.14;
        return longth;
    }
    public double area(double radius){
        double area = radius * radius * 3.14;
        return area;
    }
}

6、Cale练习加、减、乘、除方法

package com.fhsedu.chapter07;

public class Homework01{
    //编写一个 main 方法
    public static void main(String[] args) {
        //6.编程创建一个Cale计算类，在其中定义2个变量表示两个操作数，
        //   定义四个方法实现求和，差，乘，商（要求除数为0的话，要提示）
        //     并创建两个对象，分别测试
        //Homework01.java

        Cale cale1 = new Cale();
        cale1.num1 = 30;
        cale1.num2 = 5;
        System.out.println(cale1.sumNums(cale1.num1,cale1.num2));
        System.out.println(cale1.subNums(cale1.num1,cale1.num2));
        System.out.println(cale1.mulNums(cale1.num1,cale1.num2));
        System.out.println(cale1.ridNums(cale1.num1,cale1.num2));

        System.out.println();
        
        Cale cale2 = new Cale();
        cale2.num1 = 10;
        cale2.num2 = 5;
        System.out.println(cale2.sumNums(cale2.num1,cale2.num2));
        System.out.println(cale2.subNums(cale2.num1,cale2.num2));
        System.out.println(cale2.mulNums(cale2.num1,cale2.num2));
        System.out.println(cale2.ridNums(cale2.num1,cale2.num2));
    }
}
class Cale{
    double num1;
    double num2;
    //进行 加 操作
    public double sumNums(double num1,double num2){
        return num1 + num2;
    }
    //进行 减 操作
    public double subNums(double num1,double num2){
        return num1 - num2;
    }
    //进行 乘 操作
    public double mulNums(double num1,double num2){
        return num1 * num2;
    }
    //进行 除 操作
    public double ridNums(double num1,double num2){
        if (num2 == 0){
            System.out.println("除数不能为0");
            return -1;
        }
        return num1 / num2;
    }
}

在这里插入图片描述

评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Debug 熊猫

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值