8.面对对象编程（基础）

最新推荐文章于 2024-09-01 15:30:33 发布

MrViolett

最新推荐文章于 2024-09-01 15:30:33 发布

阅读量36

点赞数

分类专栏：萌新的java之旅文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/qq_21565101/article/details/132695763

版权

萌新的java之旅专栏收录该内容

12 篇文章 0 订阅

订阅专栏

.类与对象的关系：

package chap1;

public class Cat {
String name;
int age;
String color;
}

package chap1;

public class Object01 {

	public static void main(String[] args) {
		Cat cat1 = new Cat();
		cat1.name = "小白";
		cat1.age=3;
		cat1.color = "白色";
		Cat cat2 = new Cat();
		cat2.name = "小花";
		cat2.age=100;
		cat2.color = "花色";
		System.out.println("第1只猫信息"+cat1.name+" "+cat1.age+" "+cat1.color);
		System.out.println("第2只猫信息"+cat2.name+" "+cat2.age+" "+cat2.color);

	}

}

·类和对象的区别和联系

1)类是抽象的，概念的，代表一类事物，比如人类，猫类。。。即它是数据类型

2)对象是具体的，实际的，代表一个具体事物，即是实例

3)类是对象的模板，对象时类的一个个体，对应一个实例

二.属性/成员变量

基本介绍

1.从概念或叫法上：成员变量 = 属性 =field（字段）（即成员变量是用来表示属性的）

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

·注意事项和细节说明

1)属性的定义变量，示例：访问修饰符属性类型属性名；

2)属性的定义类型可以任意类型，也包含基本类型或引用类型

3)属性如果不赋值，有默认值，遵循数组规则

·如何创建对象

1.先声明再创建

Cat cat;

cat = new Cat();

2.直接创建

Cat cat = new Cat();

·如何访问属性

基本语法

对象名.属性名;

cat.name;

cat.age;

cat.color;

对象分配机制

·类和对象的内存分配机制

Java内存的结构分析

1.栈：一般存放基本数据类型(局部变量)

2.堆：存放对象(Cat cat，数组等)

3.方法区：常量池（常量，比如字符串）,类加载信息

√ java创建对象的流程简单分析

Person p = new Person();
p.name = "jack";
p.age=10

1.先加载Person类信息（属性和方法信息，只会加载一次）

2.在堆中分配空间，进行默认初始化（看规则）

3.把地址赋给p，p就指向对象

4.进行指定初始化，比如 p.name = "jack" p.age=10

三.成员方法

·基本介绍

在某些情况下，我们需要定义成员方法（简称方法）。

方法入门、

package chap8;

public class Person {
String name;
int age;
public void speak() {
	System.out.println("我是一个好人");
}
public int getSum(int num1,int num2) {
	int res = num1+num2;
	return res;
}
}

package chap8;

public class Method01 {

	public static void main(String[] args) {
		//方法使用
		//1.方法写好后，如果不去调用(使用)，不会输出
		//2.先创建对象，然后调用方法即可
		Person p1=new Person();
		p1.speak();
		int sum01=p1.getSum(10, 20);
		System.out.println(sum01);

	}

}

·成员方法机制

方法调用小结

1.当程序执行到方法时，就会开辟一个独立的空间（栈空间）

2.当方法执行完毕，或者执行到return语句时，就会返回

3.返回到调用方法的地方

4.返回后，继续执行方法后面的代码

·成员方法的定义

访问修饰符返回数据类型方法名（参数列表..） {

//方法体语句;

reurn 返回值;

}

1.参数列表：表示成员方法输入 cal(int n)

2.数据类型（返回类型）:表示成员方法输出，void表示没有返回值

3.方法主体：表示为了实现某一功能代码块

4.return语句不是必须的。

·注意事项和使用细节

√访问修饰符（作用是控制方法使用的范围），不写默认为default

√返回类型

1.一个方法最多有一个返回值，返回多个值可以使用数组

2.返回类型可以为任意类型，包含基本类型或引用类型（数组、对象）

3.如果方法要求有返回数据类型，则方法体中最后的执行语句必须为return 值;而且要求返回值类型必须和return的值类型一致或兼容

4.如果方法是void,则方法体中可以没有return语句,或者只写return;

√方法名

遵循驼峰命名

package chap8;

public class MethodDetail {

	public static void main(String[] args) {
		AA a=new AA();
		int[] res= a.getSumAndSub(1, 4);
		System.out.print("和="+res[0]);
		System.out.print("差="+res[1]);
	}

}
class AA{
	//1.一个方法最多有一个返回值【返回多个数值用数组】
	public int[] getSumAndSub(int n1,int n2) {
		int[] resArr = new int[2];
		resArr[0]= n1 + n2;
		resArr[1]= n1- n2;
		return resArr;
	
	}
	//2.返回类型可以为任意类型，包含基本类型或引用类型（数组、对象）
	//3.如果方法要求有返回数据类型，则方法体中最后的执行语句必须为return 值;而且要求返回值类型必须和return的值类型一致或兼容
	public int f1() {
		double d1 =1.1*3;
		int n=100;
		return n;//int -->double
		//return d1;ok? double -->int(X)
	}
	//4.如果方法是void,则方法体中可以没有return语句,或者 只写return;
	public void f2() {
		System.out.println("hello1");
		return;
	}
}

√形参列表

1.一个方法可以有0个参数，也可以有多个参数，中间用逗号隔开，比如getSum(int n1,int n2)

2.参数类型可以为任意类型，包含基本类型或引用类型，比如printArr(int[] [] map)

3.调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型的参数！

4.方法定义时的参数称为形式参数，简称形参；方法调用时的参数称为实际参数，简称实参，实参和形参的类型一致或兼容、个数、顺序必须一致

√方法体

里面写完成功能的具体的语句，可以为输入、输出、变量、运算、分支、循环、方法调用，但是里面不能再定义方法！即：方法不能嵌套定义。

√方法细节调用说明

1.同一个类中的方法调用：直接调用即可。比如print(参数);

2.跨类中的方法A类调用B类方法：需要通过对象名调用。比如对象名.方法名（参数）;

3.说明：跨类的方法调用和方法与访问修饰符相关。

·成员方法传参机制

1）基本数据类型

package chap8;

public class MethodParameter01 {

	public static void main(String[] args) {
		int a= 10;
		int b= 20;
		AA obj =new AA();
		obj.swap(a, b);
		System.out.println("a="+a+"\tb="+b);
	}
}
class AA{
	public void swap(int a,int b) {
		System.out.println("a="+a+"\tb="+b);
		int tmp =a;
		a=b;
		b=tmp;
		System.out.println("a="+a+"\tb="+b);
	}
}

2）引用数据类型

package chap8;

public class MethodParameter02 {

	public static void main(String[] args) {
		B b =new B();
		int[] arr= {1,2,3};
		b.test100(arr);
		System.out.println();
		for(int i =0;i<arr.length;i++) {
			System.out.println(arr[i]+"\t");
		}

	}

}
class B{
	public void test100(int[] arr) {
		arr[0] = 200;
		for(int i =0;i<arr.length;i++) {
			System.out.println(arr[i]+"\t");
			
		}
	}
}

克隆对象

package chap8;

public class MethodExercise02 {

	public static void main(String[] args) {
		Person p=new Person();
		p.name="milan";
		p.age = 100;
		Mytools tools = new Mytools();
        Person p2=tools.copyPerson(p);
        //到此 p和 p2 是Person对象，但是是两个独立的对象，属性相同
        System.out.println(p.name+p.age);
        System.out.println(p2.name+p2.age );
	}

}
class Person{
	String name;
	int age;
}
class Mytools{
	public Person copyPerson(Person p) {
		Person p2 =new Person();
		p2.name = p.name;//把原来对象的名字赋给p2.name
		p2.age = p.age;//把原来对象的年龄赋给p2.age
		return p2;
	}
}

·方法递归调用

基本介绍

简单的说：递归就是方法自己调用自己，每次调用时传入不同的变量。递归有助于编程者解决复杂问题，同时让代码变得简洁

打印问题

package chap8;

public class Recursion01 {

	public static void main(String[] args) {
	class T{
		public void test(int n) {
			if(n>2) {
				test(n-1);
			}
			System.out.println(n);
		}
	}
    T test= new T();
    test.test(5);
	}

}

阶乘问题

package chap8;

public class Recursion01 {

	public static void main(String[] args) {
		class T {
			public void test(int n) {
				if (n > 2) {
					test(n - 1);
				}
				System.out.println(n);
			}

			public int factorial(int n) {
				if (n == 1) {
					return 1;
				} else {
					return factorial(n - 1) * n;
				}
			}
		}
     T test=new T();
     int sum =0;
     int i;
     for(i=1;i<6;i++) {
    	 sum+=test.factorial(i);
     }
     System.out.println(sum);
     
     
    
	}

}

·递归重要规则

1.执行一个方法时，就创建一个新的受保护的独立空间（栈空间）

2.方法的局部变量是独立的，不会相互影响，比如n变量

3.如果方法中使用的是引用类型变量（比如数组，对象），就会共享该引用类型的数据

4.递归必须向退出递归的条件逼近，否则就是无限递归，出现死归了

5.当一个方法执行完毕，或者遇到return,就会返回，遵守谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕。

老鼠出迷宫

package chap8;

public class MiGong {
	//0表示可以走 1 表示障碍物 2表示可以走 3 表示走过，但是走不通是死路

	public static void main(String[] args) {
		int[][] map = new int[8][7];
		for(int i = 0;i<7;i++) {
			map[0][i] = 1; 
			map[7][i] = 1;
			
		}
		for(int i =0;i<8;i++) {
			map[i][0]=1;
			map[i][6]=1;
		}
		map[3][1]=1;
		map[3][2]=1;
		System.out.println("=====当前地图情况======");
		for(int i =0;i< map.length;i++) {
			for(int j =0;j<map[i].length;j++) {
				System.out.print(map[i][j]);
			}
			System.out.println();
		}
		T t1 = new T();
		t1.findWay(map, 1, 1);
		System.out.println("=====当前地图情况======");
		for(int i =0;i< map.length;i++) {
			for(int j =0;j<map[i].length;j++) {
				System.out.print(map[i][j]);
			}
			System.out.println();
		}
	}
	

}
class T{
	public boolean findWay(int[][] map,int i,int j) {
		if(map[6][5]==2){//说明已经找到
			return true;
		}else {
			if(map[i][j] ==0) {//当前这个位置0，说明表示可以走
				//我们假定可以走通
				map[i][j]=2;
				//使用找路策略，来确定该位置是否真的可以走通
				//下-->右-->上-->左
				if(findWay(map,i+1,j)) {//先走下
					return true;
				} else if (findWay(map,i,j+1)) {//右
					return true;
				}else if(findWay(map,i-1,j)) {//上
					return true;
				} else if(findWay(map,i,j-1)) {//左
					return true;	
				}else {
					map[i][j]=3;
					return false;
				}
				
			}else {//map[i][j] =1,2,3
				return false;
			}
		}
	}
}

汉诺塔

package chap8;

public class HanoiTower {

	public static void main(String[] args) {
		Tower tower = new Tower();
		tower.move(3, 'A', 'B', 'C');

	}

}
class Tower{
	public void move(int num,char a,char b,char c) {
		//如果只有一个盘 num =1 
		if(num == 1 ) {
			System.out.println(a+"-->"+c);
		} else {
			//如果有多个盘，可以看成两个，最下面的和上面的所有盘(num - 1)
			//(1)先移动上面所有的盘到b ,借助 c
			move(num-1,a,c,b);
			//(2)把最下面的这个盘，移动到c
			System.out.println(a+"-->"+c);
			//(3)再把 b塔的所有盘，移动到c，借助a
			move(num-1,b,a,c);
			
		}
	}
}

方法重载（OverLoad）

·基本介绍

java中允许同一个类中，多个同名方法的存在。但要求形参列表不一致

·重载的好处

1)减轻了起名的麻烦

2)减轻了记名的麻烦

package chap8;

public class OverLoad01 {

	public static void main(String[] args) {
		MyCalculator mc = new MyCalculator();
		System.out.println(mc.calculate(1, 2));
	}

}
class MyCalculator{
	public int calculate(int n1,int n2) {
		return n1 + n2;
	}
	public double calculate(int n1,double n2) {
		return n1+n2;
	}
	public double calculate(double n1, int n2) {
		return n1+n2;
	}
	public int calculate(int n1,int n2,int n3) {
		return n1+n2+n2;
	}
}

·注意事项和使用细节

1）方法名：必须相同

2）形参类型：必须不同（形参类型或个数或顺序，至少有一样不同，参数名无要求）

3）返回类型：无要求

可变参数

·基本概念

java允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。就可以通过可变参数实现

·基本语法

·访问修饰符返回类型方法名(数据类型... 形参名){

}

package chap8;

public class VarParameter01 {

	public static void main(String[] args) {
	HspMethod m	=new HspMethod();
    System.out.println(m.sum(1,5,100));
	}

}
//1.int... 表示接受的是可变参数，类型是int，既可以接受多个int(0-多)
//2.使用可变参数时，可以当做数组来使用 即 nums 可以当作数组
//3.遍历 nums 求和即可
class HspMethod{
	public int sum(int... nums) {
		System.out.println("接受的参数个数"+nums.length);
		int res=0;
		for(int i=0;i<nums.length;i++) {
			res += nums[i];
		}
		return res;
	}
}

·注意事项和注意细节

1)可变参数的实参可以为0个或任意多个。

2)可变参数的实参可以为数组。

3）可变参数的本质就是数组

4)可变参数可以和普通参数类型的参数一起放在形参列表，但必须保证可变参数在最后

5)一个形参列表中只能出现一个可变参数

package chap8;

public class VarParameterDetail {

	public static void main(String[] args) {
		//细节：可变参数的实参可以为数组
		int[] arr = {1,2,3};
		Test02 t1 = new Test02();
		t1.f1(arr);

	}

}
class Test02{
	public void f1(int... nums) {
		System.out.println(nums.length);
	}
	//细节：可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
	public void f2(String str,double... nums) {
		
	}
}

作用域

·基本使用

面向对象中，变量作用域是非常重要知识点，相对来说不是特别好理解。

1.在java编程中，主要的变量就是属性（成员变量）和局部变量

2.我们说的局部变量一般是指在成员方法中定义的变量。

3.java中作用域的分类

全局变量：也就是属性，作用域为整个类体 Cat类：cry eat等方法使用属性

局部变量：也就是除了属性之外的其他变量，作用域为定义它的代码块中！

4.全局变量（属性）可以不赋值，直接使用，因为有默认值，局部变量必须赋值后，才能使用，因为没有默认值。

·注意事项和细节使用

1.属性和局部变量可以重名，访问是遵循就近原则。

2.在同一个作用域中，比如在同一个成员方法中，两个局部变量，不能重名。

3.属性生命周期较长，伴随着对象的创建而创建，伴随着对象的死亡而死亡。局部变量，生命周期较短，伴随着它的代码块的执行而创建，伴随着代码块的结束而死亡。即在一次方法调用过程中。

4.作用域不同

全局变量：可以被本类使用，或其他类使用（通过对象调用）

局部变量：只能在本类中对应的方法中使用

5.修饰符不同

全局变量/属性可以加修饰符

局部变量不可以加修饰符

构造方法/构造器

·基本语法

[修饰符]方法名 (形参列表){

方法体;

}

说明：

1)构造器的修饰符可以默认

2)构造器没有返回值

3)方法名和类名字必须一样

4)参数列表和成员方法一样的规则

5)构造器的调用系统完成

·基本解释

构造方法又叫构造器(constructor)，是类的一种特殊的方法，它的主要作用是完成对新对象的初始化。它有几个特点：

1)方法名和类名相同

2)没有返回值

3)在创建对象时，系统会自动的调用该类的构造器完成对象的初始化

package chap8;

public class Consructor01 {

	public static void main(String[] args) {
		//当我们new 一个对象时，直接通过构造器指定名字和年龄
		Person01 p1 =new Person01("smith",80);
		System.out.println(p1.name);
		System.out.println(p1.age);

	}

}
class Person01 {
	String name;
	int age;
	//构造器
	public Person01(String pName,int pAge) {
		System.out.println("构造器被调用");
		name = pName;
	    age = pAge;
	}
}

·注意事项和使用细节

1.一个类可以定义多个不同的构造器，即构造器重载

比如：我们可以再给Person类定义一个构造器，用来创建对象的时候，只指定人名，不需要指定年龄

2.构造器名和类名要相同

3.构造器没有返回值

4.构造器是完成对象的初始化，并不是创建对象

5.在创建对象时，系统自动的调用该类的构造方法

6.如果程序员没有定义构造方法，系统会自动给类生成一个默认无参构造方法（也叫默认构造方法）比如Person（）{}，使用javap指令反编译看看

一旦定义了自己的构造器，默认的构造器就覆盖了，就不能再使用默认的无参构造器，除非显式的定义一下，即：Person（）{}

package chap8;

public class Consructor01 {

	public static void main(String[] args) {
		//当我们new 一个对象时，直接通过构造器指定名字和年龄
		Person01 p1 =new Person01("smith",80);
		System.out.println(p1.name);
		System.out.println(p1.age);
		Dog dog1=new Dog("lili");

	}

}
class Dog{
	//如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造器（也叫默认构造器）
    //使用javap指令 反编译看看
	/*
	 默认构造器
	 Dog(){
	 }
	 */
	//一旦定义了自己的构造器，默认的构造器就覆盖了，就不能再使用默认的无参构造器，
	//除非显式的定义一下，即：Dog(){}
	//
	public Dog(String dName) {
		//
	}
	Dog() {//显式的定义一下，无参构造器
		
	}
}
class Person01 {
	String name;
	int age;
	//构造器
	public Person01(String pName,int pAge) {
		System.out.println("构造器被调用");
		name = pName;
	    age = pAge;
	}
}

流程分析（面试题）

1.加载Person类信息（Person.class）,只会加载一次

2.在堆中分配空间（地址）

3.完成对象初始化 [3:1.默认初始化 age = 0 name =null 2.显式初始化 age =90,name =null 3.构造器的初始化 age = 20, name =小倩]

4.在对象在堆中的地址，返回给p（p是对象名，也可以理解成对象的引用）

this关键字

什么是this

java虚拟机会给每个对象分配this，代表当前对象。

使用this解决前面变量命名问题

具体看代码

this小结：简单地说，哪个对象调用，this就代表哪个对象。

this的注意事项和使用细节

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

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

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

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

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

package chap8;

public class ThisDetail {

	public static void main(String[] args) {
	T01 t =new T01();
    
	}

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

包

·包的三大作用

1.区分相同名字的类

2.当类很多时，可以很好的管理类[看Java API文档]

3.控制访问范围

·包基本语法

package com.hspedu;

说明：

1.package关键字，表示打包.

2.com.hspedu:表示包名

·包的本质

包的本质实际上就是创建不同的文件夹/目录来保存类文件

package com.use;

import com.xiaoming.Dog;

public class Test {

	public static void main(String[] args) {
		Dog dog= new Dog();
		System.out.println(dog);
        com.xiaoqiang.Dog dog1 =new com.xiaoqiang.Dog();
        System.out.println(dog1);
	}

}

·包的命名

√命名规则：

只能包含数字、字母、下划线、小圆点，但不能用数字开头，不能是关键字或保留字

demo.class.exec1//错误 class是关键字

demo.12a //错误 12a是数字开头

demo.ab12.oa//对

√命名规则

一般是小写字母+小圆点一般是

com.公司名.项目名.业务模块名

比如：com.hspedu.oa.model;com.hspedu.oa.controller

举例:

com.sina.crm.user //用户模块

com.sina.crm.order//订单模块

com.sina.crm.utils//工具类

·常用的包

一个包下，包含很多的类，java中常有的包有：

java.lang.* //lang包是基本包，默认引入，不需要再引入.

java.util.* //util包，系统提供的工具包，工具类，使用Scanner

java.net.* //网络包，网络开发

java.awt.* //是做java的界面开发，GUI

·如何引入包

com.hspedu.pkg : Import01.java

语法：import 包;

我们引入一个包的主要目的是要使用该包下的类

比如import java.util.* ; //表示将java.util 包所有都引入

·注意事项和使用细节

1.package的作用是声明当前类所在的包，需要放在类的最上面，一个类中最多只有一句package

2.import指令位置放在package的下面，在类定义前面，可以有很多句且没有顺序要求

访问修饰符

·基本介绍

java提供四种访问控制修饰符号，用于控制方法和属性（成员变量）的访问权限（范围）：

1.公开级别：用public修饰，对外公开

2.受保护级别：用protected修饰，对子类和同一个包中的类公开

3.默认级别：没有修饰符号，向同一个包的类公开

4.私有级别：用private修饰，只有类本身可以访问，不对外公开

·4种访问修饰符的访问范围

·使用的注意事项

1）修饰符可以用来修饰类中的属性，成员方法以及类

2）只有默认和public才能修饰类！，并且遵循上述访问权限的特点。

3）因为没有学习继承，因此关于在子类中的访问权限，我们讲完子类后，在回头讲解

4）成员方法的访问规则和属性完全一样

//com.hspedu.modifier:

MrViolett

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
8.面对对象编程（基础）

局部变量，生命周期较短，伴随着它的代码块的执行而创建，伴随着代码块的结束而死亡。5.当一个方法执行完毕，或者遇到return,就会返回，遵守谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕。方法调用时的参数称为实际参数，简称实参，实参和形参的类型一致或兼容、个数、顺序必须一致。构造方法又叫构造器(constructor)，是类的一种特殊的方法，它的主要作用是完成对新对象的初始化。4.全局变量（属性）可以不赋值，直接使用，因为有默认值，局部变量必须赋值后，才能使用，因为没有默认值。
复制链接

扫一扫