面向对象（基础）

hawk_of_IT

已于 2023-12-08 21:02:13 修改

阅读量33

点赞数

文章标签： java 开发语言

于 2023-12-08 18:35:52 首次发布

本文链接：https://blog.csdn.net/hawk_of_IT/article/details/134742285

版权

个人资料总结，学习来源----B站韩顺平

类与对象

类是一个抽象概念，对象是将这个抽象概念具体化：

小可和小爱在公园散步，突然，小明大喊：“看，有个猫（类）在跑！”，小爱问：“这个猫（类，泛指一类事物，比较抽象）长啥样呀”？。小明拉着小爱去寻找这个小猫，最后在树底下发现小猫在卧着，小爱两眼发光“这个小猫好可爱，‘红色的，短毛，好像是有3岁了，腿好像瘸了一只’（具体化到对象，） ”

注意：从类到对象，有几种不同说法。1.创建一个对象 2. 实例化一个对象 3. 把类实例化



public class Object01{
	public static  void main(String[] args){
		//实例化一个猫类对象（创建一个猫类对象）
		// 1. new cat() 创建一只猫
		// 2. cat cat1 = new cat();  把创建的猫赋给 cat1
		cat cat1 = new cat();
		//创建第二只猫，并赋给cat2
		cat cat2 = new cat();
		cat1.name = "小白";
		cat1.age = 3;
		cat1.color = "white";
		System.out.println("猫1叫" + cat1.name + " " + cat1.age + "  " + cat1.color);
	}
}
//定义一个cat类
class cat{
	//属性
	int age;
	String name;
	String color;
}

对象在jvm内存存在形式

属性

基本介绍：

1. 属性 = 成员变量 = field（字段）

2. 属性是类的一个组成部分，一般是基本数据类型或引用类型（数组、对象）

注意细节：

1. 属性如果不赋值，有默认值（默认的值同数组：0/0.0/false/null）

创建对象

1. 先声明再创建：

Cat cat1; // 先声明

cat1 = new Cat(); // 在创建

2. 直接创建

Cat cat2 = new Cat();

创建机制：

方法入门

方法就是对象的一系列行为

定义：

public 返回数据类型方法名（形参列表）{

语句；

return返回值；

}

看代码，方法的使用

public class Method{
	public static void main(String[] args){
		//使用方法
		//先创建对象，然后调用方法
		person p1 = new person();
		p1.speak();
		p1.cal(5);
		int res = p1.getSum(100,  200);
		System.out.println("res = " + res);
	}
}
class person{
	int age;
	String name;
	//方法（成员方法）
	 // 1.public 表示方法是公开
	// 2, void : 表示方法没有返回值
	// 3.speak() : speak是方法名，，（）形参
	public void speak(){
		System.out.println("我是一个人");
	}
	
	//添加一个方法，计算1+2+...+n并输出
	public void cal(int n){
		int sum = 0;
		for (int i = 1; i <= n; i++){
			sum += i;
		}
		System.out.println("总和为 " + sum);
	}
	
	//添加getSum方法，可以计算两个数的和
	//int表示执行方法后，返回一个 int 值
	public int getSum(int num1, int num2){
		int res = num1 + num2;
		return res;
	}
}

方法调用机制

方法调用细节

1. 同类中的方法调用：直接调用即可。

class A {
    public void A1(){
        A2();
        System.out.println("继续执行A1（）");
    }
    
    public void A2(){
        System.out.println("调用了A2（）方法");
    }
}

2. 不同类中的方法调用：须通过创建对象来调用。

class A{
    public void A1(){
    B myB = new B();
    num = myB.B1();
    System.out.println(num);    
    }
}
class B{
    public int B1(){
        int b = 10;
        return b;
    }
}

方法传参机制

1. 基本数据类型，传递的是值（值拷贝），形参的任何改变不影响实参！

2.引用类型传递的是地址（传递也是值，只是值是地址），可通过影响形参来改变实参，下面传递一个对象来测试一下

//引用类型传递
public class Method03{
	public static void main(String[] args){
		//创建一个Person()对象，并给属性赋值
		Person men = new Person();
		men.age = 10;
		men.name = "tiga";
		// 创建一个 P() 对象
		P myP = new P();
		//调用test()方法，并将对象作实参传递
		myP.test(men);
		System.out.println("men's age = " + men.age);
		
	}
}
class Person{
	int age;
	String name;
}

class P{
	public void test(Person men){
		men.age = 10000;
	}
}

方法重载

方法重载（OverLoad）:java允许同一个类中，多个同名方法的存在，但要求他们的形参列表必须不同！常用的System.out.println(); 就是运用了方法重载。

使用要求：

1. 方法名：必须相同

2. 参数列表：必须不同（参数类型 / 个数 / 顺序，至少有一样不同）

3. 返回类型无要求。

// 方法重载
public class OverLoad{
	//定义一个main方法
	public static void main(String[] args){
		MyCalculate cal = new MyCalculate();
		cal.calculate(1, 3, 5);
	}
}

class MyCalculate{
	//方法
	public void calculate(int n1, int n2){
		System.out.println(n1 + n2);
	}
	
	public void calculate(int n1, double n2){
		System.out.println(n1 + n2);
	}

	public void calculate(double n1, int n2){
		System.out.println(n1 + n2);
	}

	public void calculate(int n1, int n2, int n3){
		System.out.println(n1 + n2 + n3);
	}
}

可变参数

Java允许将同一个类中多个同名同功能但参数不同的方法，封装成一个方法。

基本语法：
访问修饰符返回类型方法名（数据类型... 形参名）{

}

个人理解：就是在传递参数的同视初始化了一个数组

细节：

1. 可变参数的实参可以为0个或多个；

2. 可变参数的实参可以为数组（其实可变参数的本质就是数组）

3. 可变参数的可以和普通类型的参数放在一起，但可变参数必须在最后一个

4. 一个形参列表只能有一个可变参数

// 方法重载
public class VarParameter{
	//定义一个main方法
	public static void main(String[] args){
		MyCalculate cal = new MyCalculate();
		System.out.println(cal.calculate(1,2,3));
        		cal.core("谜语人", 100, 100);

	}
}

class MyCalculate{
	//方法
	// 参数是可变参数，使用方法同数组
	public int calculate(int... nums){
		int count = 0;
		for (int i = 0; i < nums.length; i++){
			count += nums[i];
		}
		return count;
	}
    	public void core(String str, int... core){
       	 	int count = 0;
        		for(int i = 0; i < core.length; i++){
	       	 count += core[i];
       		 }
       		 System.out.println("姓名：" + str + "总分：" + count);
   	} 
	
}

构造器

作用：完成对新对象的初始化

基本语法：

[修饰符] 方法名（形参列表）{

方法体；

}

细节：

1.方法名要和类名相同

2. 没有返回值，（不需要void）

3.创建对象时，系统自动调用构造器来完成对象的初始化

4. 一个类可以有多个构造器，即构造器重载

5. 若没有显性的定义构造器，系统会自动，默认生成一个无参构造器，一旦自己定义了构造器，便会覆盖那个默认的无参构造器。

// 构造器入门
public class Constructor01{
	public static void main(String[] args){
		Person Ultramen = new Person("Tiga", 11111);
		System.out.println("Ultramen的信息如下：");
		System.out.println("name = " + Ultramen.name);
		System.out.println("age = " + Ultramen.age);
		
		Person Ultramen2 = new Person("Nexs");
		System.out.println("Ultramen2的信息如下：");
		System.out.println("name = " + Ultramen2.name);
		System.out.println("age = " + Ultramen2.age);
	}
}

class Person{
	// 类
	String name;
	int age;
	public Person(String pName, int pAge){
		//构造器
		name = pName;
		age = pAge;
		System.out.println("构造器成功被调用，完成对象 的属性初始化");
	}

	public Person(String pName){
		//第二个构造器（构造器重载）
		// 只初始化了name
		name = pName;
		
		System.out.println("构造器二成功被调用，完成对象 的属性初始化");
	}
}

对象的创建流程

this

this代表当前对象，是Java虚拟机给每个对象所分配的

// This入门
public class This01{
	public static void main(String[] args){
		Person Ultramen = new Person("Tiga", 11111);
		System.out.println("Ultramen的信息如下：");
		System.out.println("name = " + Ultramen.name);
		System.out.println("age = " + Ultramen.age);
		System.out.println("Ultramen的hashCode值 = " + Ultramen.hashCode());
		
		Person Ultramen2 = new Person("Nexs");
		System.out.println("Ultramen2的信息如下：");
		System.out.println("name = " + Ultramen2.name);
		System.out.println("age = " + Ultramen2.age);
	}
}

class Person{
	// 类
	String name;
	int age;
	public Person(String name, int age){
		//构造器
		// name、age 指的是附近的形参
		// this.name  this.age 指的是此对象的name和age属性
		this.name = name;
		this.age = age;
		System.out.println("构造器成功被调用，完成对象 的属性初始化");

		//hashCode()可以表示地址，但它并不是地址
		System.out.println("this.hashCode() = " + this.hashCode());
	}

	public Person(String pName){
		//第二个构造器（构造器重载）
		// 只初始化了name
		name = pName;
		
		System.out.println("构造器二成功被调用，完成对象 的属性初始化");
	}
}

注意：

1. this关键字可以访问本类的属性、方法、构造器

2. this可以区分当前类的属性和局部变量

3. 访问成员方法的语法：this.方法名（参数列表）

4. 访问构造器方法：this.（参数列表）；注意只能在构造器中使用（即只能在构造器中访问另一个构造器，且必须放在第一条语句）

5.this不能在类定义外的外部使用，只能在类定义的方法中使用