Java第六章---类与对象

最新推荐文章于 2024-05-17 13:43:01 发布

Nobody66

最新推荐文章于 2024-05-17 13:43:01 发布

阅读量111

点赞数 1

文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/m0_74631552/article/details/130394870

版权

类名首字母大写

属性和成员变量：

成员变量=属性；

属性是类的一个组成部分，一般是基本数据类型，也可使引用数据类型（对象，数组）；

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

Java内存的结构分析

1：栈：一般存放基本数据类型（局部变量）

2：栈：存放对象（Cat cat，数组等）

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

4：示意图【Cat（name，age，price）】

方法的调用

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

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

3：返回到调用方法的地方；

4：返回后继续执行方法后的代码；

方法的使用细节

1：一个方法只能有一个返回值（数组可以解决多个返回值）；

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

3：如果方法要求有返回数据类型，则方法体中最后的执行语句必须为return值；

而且要求返回值类型必须和return的值类型一致或兼容；

4：如果方法是void，则方法体中可以没有return语句，或者只写return；

方法使用步骤

1：确定方法的返回类型；

2：确定方法名；

3：方法的形参（可以是方法）；

4：方法体；

克隆对象的应用

public class exe {


public static void  main(String[] args){
		Person p=new Person();
		p.name="milan";
		p.age =100;
		//创建tools
		Mytools tools =new Mytools();
		Person p2=tools.newperson(p);
//到此p和p2都是两个person对象，都是两个独立的对象，只不过属性相同；
				System.out.println("p的age "+p.age+"p的name"+p.name+"\t");
				System.out.println("P2的age"+p2.age+"p2的name"+p2.name+"\t");
}}
class Person{//创建一个person类,可以作为一个类型写入方法

	String name;
	int age;

}
class Mytools{
		//编写方法的思路：
		//1：方法的返回类型 Person；
		//2：方法的名字newperson；
		//3：方法的形参（person p）；
		//4：方法体：创建一个新对象，并且复制属性，返回即可
	public Person newperson(Person p){
		//创建一个新对象
		Person p2=new Person();
		p2.name=p.name;//把原来对象的值付p2
		p2.age=p.age;
		return p2;
	}



}

递归的开始

public class digui {


public static void  main(String[] args){

		T t=new T();
		t.digui(4);


}}
class T{
	public void digui(int n){
		if(n>2)
			digui(n-1);
		System.out.println("n="+n);
	}

}

递归地应用---老鼠走迷宫

public class digui {


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;
		map[2][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{

	//使用递归回溯给老鼠找路
	//1.findway方法就是专门来找出迷宫的路径；
	//如果找到就返回true，否则返回false
	//3.map就是二维数组即表示迷宫；
	//4.i，j就是老鼠的位置，初始化位置为（1，1）；
	//5.找递归的出路，提前规定map数组的含义
	//6.0表示可以走1表示障碍物3表示走过但是是死路
	public boolean findway(int[][] map,int i,int j){
		if(map[6][5]==2){
			return true;
		}
		else {
					if(map[i][j]==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{
				return false;

			}
		}
	}
	
}

运行结果：

递归的应用2--汉诺塔

public class hannuo {


public static void  main(String[] args){

		Tower t=new Tower();
		t.move(5,'A','B','C');	

}}	

class Tower{


	public void move(int num ,char a,char b,char c){
			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);
				//再把b塔的所有盘移动到c，借助a；
				move(num-1,b,a,c);

			}

	
	}
}

方法重载

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

注意事项和细节：

形参列表的不同：

必须类型或个数有一者不同才可，，或者顺序不同，仅仅形参名不同不可；

返回类型无要求；

可变参数：

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

基本语法

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

}

注意事项：

可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后；
一个形参列表只能出现一个可变参数
可变参数的实参可以为0个或任意多个（可以是数组）

可变参数演示

public class kebian{


public static void main(String[] args){

 	M m=new M();
 	System.out.println(m.show("lihua",90,100.2));
	
}}

class M{
public String show(String name ,double... scores){
	double num =0;
	for (int i=0;i<scores.length ;i++ ) {
		num+=scores[i];
		
	}
	return  name +"有"+scores.length+"门课的成绩总分为"+num;



}}

作用域

Java中的作用域分类：

全局变量（属性）：也就是属性，作用域为整个类体

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

全局变量可以不赋值直接使用，因为有默认值，局部变量必须赋值之后才能使用，因为没有默认值

注意事项和细节使用：

1：属性和局部变量可以重名，访问时遵循就近原则；

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

3：属性生命周期较长，局部变量生命周期较短；

4：作用域范围不同：

全局变量/属性：可以被本类使用，或其它类使用（通过对象调用）；

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

5：修饰符不同：

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

局部变量不可以加修饰符

构造方法/构造器

基本语法：

【修饰符】方法名（形参列表）{

方法体；}

1：构造器的修饰符可以默认也可以是public protected private；

2：构造器没有返回值；

3：方法名和类名必须一样；

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

5: 构造器的调用，由系统完成；

注意事项和使用细节：

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

2：构造器名和类名要相同；

3：构造器没有返回值；

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

5：在创建对象时，系统自动的调用该类的创建方法；

6:如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造方法；

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

构造器的简单应用

public class gouzao{


public static void main(String[] args){
	person p1=new person();
	System.out.println("p1的名字="+p1.name+"p1的年龄="+p1.age);
	person p2=new person("liyujie",1000);
	System.out.println("p2的名字="+p2.name+"p2的年龄="+p2.age);


}}
//在前面定义的person类中添加两个构造器；
//在第一个无参构造器：利用构造器设置所有人的age属性初始值都为10；
//第二个带pname和page两个参数的构造器；
//使得每次创建person对象的同时初始化对象的age属性值和name属性值分别使用不同的构造器创建对象
class person{
	String name;//默认值null
	int age;//默认0
	//第一个无参构造器：利用构造器设置所有人的age属性初始值都为18；

	public person(){
		 age=10; 
	}
	//第二个带pname和page两个参数的构造器
	public person(String pname,int page){
		name=pname;
		age=page;
	}
}

创建的对象只是对象的引用并不是对象

流程分析（面试题）：

1：加载person类信息（person。class），只会加载一次；

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

3：完成对象初始化【1：默认初始化age=0 name=null 2：显式初始化age=90，name=null 3：构造器的初始化 age=20，name=小倩】

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

this

哪个对象调用，this就代表哪个对象；

注意事项和使用细节

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

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

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

4：访问构造器语法：this（参数列表）：注意只能在构造器中使用（只能在构造器中访问另外一个构造器），如果有访问构造器的语法this（参数列表）必须放在第一条语句；

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

6. this.属性直接访问属性，不访问局部变量

Nobody66

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
2
评论
Java第六章---类与对象

类和对象的内存分配机制：Java内存的结构分析1：栈：一般存放基本数据类型（局部变量）2：栈：存放对象（Cat cat，数组等）3：方法区：常量池（常量，比如字符串），类加载信息；4：示意图【Cat（name，age，price）】4：返回后继续执行方法后的代码；3：如果方法要求有返回数据类型，则方法体中最后的执行语句必须为return值；而且要求返回值类型必须和return的值类型一致或兼容；4：如果方法是void，则方法体中可以没有return语句，或者只写return；
复制链接

扫一扫