编程语言
首页 > 编程语言> > JAVA 面向对象-上 (一)

JAVA 面向对象-上 (一)

作者:互联网

JAVA 面向对象-上 (一)

类与对象

1.面向对象学习的三条主线:

①Java类及类的成员:属性、方法、构造器;代码块、内部类

②面向对象的三大特征:封装性、继承性、多态性、(抽象性)

③其他关键字:this,super,abstract,final,static,import,interface,package等

“大处着眼,小处着手”

2.面向对象与面向过程(理解)

1.面向过程:强调的是功能行为,以函数为最小单位,考虑怎么做。

2.面向对象:强调具备了功能的对象,以类/对象为最小单位,考虑谁来做。

//面向过程
 /*①把冰箱打开
 * ②抬起大象,塞进冰箱
 * ③把冰箱门关闭
 */
//面向对象
/*人{
 * 		打开(冰箱门){
 * 			冰箱.开开();
 * 		}
 * 		抬起(大象){
 * 			大象.进入(冰箱);
 * 		}
 * 		关闭(冰箱){
 * 			冰箱.闭合();
 * 		}
 * }
 * 冰箱{
 * 		开开(){}
 * 		闭合(){}
 * }
 * 
 * 大象{
 * 		进入(冰箱){
 * 
 * 		}
 * }
 */
3.完成一个项目(或功能)的思路:

根据问题需要,选择问题所针对的现实世界中的实体。

从实体中寻找解决问题相关的属性和功能,这些属性和功能就形成了概念世界中的类。

把抽象的实体用计算机语言进行描述,形成计算机世界中类的定义。即借助某种程序语言,把类构造成计算机能够识别和处理的数据结构。

将类实例化成计算机世界中的对象。对象是计算机世界中解决问题的最终工具。

4.面向对象中两个重要的概念

类:对一类事物的描述,是抽象的、概念上的定义

对象:是实际存在的该类实物的每个个体,因而也称为实例(instance)

--面向对象程序设计的重点是类的设计

--设计类,就是设计类的成员

二者的关系:

对象,是由类new出来的,派生出来的。

5.面向对象思想落地实现的规则

1.创建类,设计类的成员

2.创建类的对象

3.通过“对象.属性”或“对象.方法”调用对象的结构

补充:几个概念的使用说明

属性=成员变量=field=域、字段

方法=成员方法=函数=method

创建类的对象=类的实例化=实例化类

6.对象的创建与对象的内存解析

典型代码:

Person p1=new Person();
Person p2=new Person();

Person p3=p1;//没有新创建一个对象,共用一个堆空间中的对象实体。

说明:

如果创建了一个类的多个对象,则每个对象都独立的拥有一套类的属性。(非static的)

意味着:如果我们修改一个对象的属性a,则不影响另一个对象属性a的值

7.匿名对象:

理解:我们创建的对象,没有显式的赋给一个变量名,即为匿名对象。

特征:匿名对象只能调用一次。

举例:

//匿名对象
		new Phone().sendEmail();
		new Phone().playGame();
		
		new Phone().price=1999;
		new Phone().showPrice();//0.0

应用场景:

PhoneMall mall=new PhoneMall();
		//匿名对象的使用
		mall.show(new Phone());
//其中
class PhoneMall{
	public void show(Phone phone) {
		phone.sendEmail();
		phone.playGame();
	}
}
8.理解”万事万物皆对象“

1.在Java语言范畴中,我们都将功能、结构等封装到类中,通过类的实例化,来调用具体的功能结构

Scanner,String等

文件:File

网络资源:URL

2.涉及到Java语言与前端Html、后端的数据库交互时,前后端的结构在Java层面交互时,都体现为类、对象。

9.JVM内存结构

编译完源程序以后,生成一个或多个字节码文件。

我们使用JVM中的类的加载器和解释器对生成的字节码文件进行解释运行。意味着,需要将字节码文件对应的类加载到内存中,涉及到内存解析。

推荐书籍:《JVM规范》

虚拟机栈,即为平时提到的栈结构。我们将局部变量存储在结构中。

堆:我们将new出来的结构(比如:数组、对象)加载在空间中。补充:对象的属性(非static中)加载在堆空间中。

方法区:类的加载信息、常量池、静态域

类的结构之一:属性

类中属性的使用

属性(成员变量)VS局部变量

1.相同点:

​ 1.1定义变量的格式:数据类型 变量名=变量值

​ 1.2先声明,后使用

​ 1.3变量都有其对应的作用域

2.不同点:

​ 2.1在类中声明的位置的不同

​ 属性:直接定义在类的一对{}中

​ 局部变量:声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量

​ 2.2关于权限修饰符的不同

​ 属性:可以在声明属性时,指明其权限,使用权限修饰符

​ 常用的权限修饰符:private、public、确省、protected------>封装性

​ 局部变量:不可以使用权限修饰符

​ 2.3默认初始化值的情况:

​ 属性:类的属性,根据其类型,都有默认初始化值。

​ 整型(byte、short、int、long):0

​ 浮点型(float、double):0.0

​ 字符型(char):0(或'\u0000')

​ 布尔型(boolean):false

​ 引用数据类型(类、数组、接口):null

局部变量:没有默认初始化值

​ 意味着,我们在调用局部变量之前,一定要显式赋值。

​ 特别地:形参在调用时,我们赋值即可

2.4在内存中加载的位置

属性:加载到堆空间中(非static)

局部变量:加载到栈空间.

类的结构之二:方法

类中方法的声明和使用

方法:描述类应该具有的功能

比如:Math类:sqrt()\random()\。。。。

​ Scanner类:nextXxx().......

​ Array类:sort()\binarySearch()\toString()\quals()\。。。。。

1.举例:

public void eat(){}
public void sleep(int hour){}
public String getName(){}
public String getNation(String nation){}

2.方法的声明:权限修饰符 返回值类型 方法名(形参列表){

方法体;

}

​ 注意:static、final、abstract来修饰的方法,后面再讲

3.说明:

​ 3.1关于权限修饰符:默认方法的权限修饰符先都使用public

​ Java规定的4种权限修饰符:public、private、缺省、protected--->封装性再细说

​ 3.2返回值类型: 返回值 VS 没返回值

​ 3.2.1如果方法返回值,则必须在方法声明时,指定返回值的类型。同时,方法中,需要使用return关键字来返回指定类型的变量或常量:“return 数据”

​ 如果方法没返回值,则方法声明时,使用void来表示,通常,没返回值的方法中,就不需要使用return。但是,如果使用的话,只能“return”,表示结束此方法的意思。

​ 3.2.2我们定义方法该不该返回值?

​ ①根据题目要求

​ ②凭经验:具体问题具体分析

​ 3.3方法名:属于标识符,遵循标识符的规则和规范:“见名知意”

​ 3.4形参列表:方法可以声明0个、1个或多个形参

​ 3.4.1格式:数据类型1 形参1,数据类型2 形参2,.....

​ 3.4.2我们定义方法是,该不该定义形参?

​ ①根据题目要求

​ ②凭经验:具体问题具体分析

​ 3.5方法体:方法功能的实现

4.return关键字的使用

​ 1.适用范围:使用在方法体中

​ 2.作用:①结束方法

​ ②针对有返回值类型的方法,使用“return 数据”方法返回所要的数据

​ 3.注意点:return关键字后不可以声明执行语句。

5.方法的使用中,可以调用当前类的属性或方法。

​ 特殊的:方法A中又调用了方法A:递归方法。

​ 方法中,不可以定义方法。

方法的重载

1.方法的重载的概念

定义:在同一个类中,允许存在一个以上的同名方法,只要它们的参数个数或者参数类型不同即可。

"两同一不同":同一个类,相同方法名

​ 参数列表不同:参数个数不同,参数类型不同

2.构成重载的举例:

举例一:Arrays类中重载sort()/binarySearch();

举例二:

//如下的4个方法构成了重载
	public void getSum(int i,int j) {
		System.out.println("1");
	}
	public void getSum(double d1,double d2) {
		System.out.println("2");
	}
	public void getSum(String s,int i) {
		System.out.println("3");
	}
	public void getSum(int i,String s) {
		System.out.println("4");
	}

不构成重载的举例:

//错误重载,下列三种不能与上述4个方法构成重载
	/*
	public int getSum(int i,int j) {
		return 0;
	}
	*/
	/*public void getSum(int m,int n) {
		
	}
	*/
//	private void getSum(int i,int j) {
//		
//	}

3.如何判断是否构成方法的重载?

严格按照定义判断:两同一不同。

跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系!

4.如何确定类中某一个方法的调用

​ 方法名---->参数列表

面试题:方法的重载于重写的区别?

throws\throw

String\stringBuffer\StringBuilder

collection\collections

final \finally\finalize

............

抽象类、接口

sleep()/wait()

可变个数形参的方法

1.使用说明

1.jdk 5.0新增的内容

2.具体使用

​ 2.1可变个数形参的格式:数据类型...变量名

​ 2.2当调用可变个数形参的方法时,传入的参数个数可以是:0个,1个,2个.....

​ 2.3可变个数形参的方法与本类中方法名相同,形参不同的方法之间构成重载

​ 2.4可变个数形参的方法与本类中方法名相同,形参类型也相同的数组之间不构成重载。即,不可共存

​ 2.5可变个数形参在方法的形参中,必须声明在末尾

​ 2.6可变个数形参在方法的形参中,最多只能声明一个可变形参

2.举例说明:

public void show(int i) {
		
	}
	public void show(String s) {
		System.out.println("show(String)");
	}
	public void show(String...strs) {
		System.out.println("show(String...strs)");
		for(int i=0;i<strs.length;i++) {
			System.out.println(strs[i]);
		}
    }
	//编译不通过,不能与上一个方法同时存在
//	public void show(String[]strs) {	
//	}
	//编译不通过  说明:2.5
	//The variable argument type String of the method 
	//show must be the last 
//	public void show(String...strs,int i) {
//		
//	}

3.调用时:

test.show(12);
		test.show("hello");
		test.show("hello","world");
		test.show();//可以为0个
		test.show("aa","bb","cc");
		test.show(new String[] {"aa","bb","cc"});
Java的值传递机制

1.针对于方法内变量的赋值举例:

		System.out.println("**********基本数据类型**********");
		int m=10;
		int n=m;
		System.out.println("m="+ m + ",n="+n);
		n=20;
		System.out.println("m="+ m + ",n="+n);
		System.out.println("**********引用数据类型*********");
		
		Order o1=new Order();
		o1.orderId=1001;
		Order o2=o1;//赋值以后:o1和o2的地址值相同,都指向了堆空间中同一个对象实体
		System.out.println("o1.orderId="+o1.orderId+",o2.orderId="+o2.orderId);
		o2.orderId=1002;
		System.out.println("o1.orderId="+o1.orderId+",o2.orderId="+o2.orderId);
	}
	class Order{
	int orderId;
}

规则:

如果变量是基本数据类型,此时赋值的是变量所保存的数据值

如果变量是引用数据类型,此时赋值的是变量所保存的数据的地址值

2.针对于方法的参数概念

形参:方法定义时,声明的小括号内的参数

实参:方法调用时,实际传递给形参的数据

3.Java中参数传递机制:值传递

规则:

如果参数是基本数据类型,此时实参赋给形参的是,实参真是存储的数据值

如果变量是引用数据类型,此时赋值的是变量所保存的数据的地址值

推广:

如果变量是基本数据类型,此时赋值的是变量所保存的数据值。

如果变量是引用数据类型,此时赋值的是变量所保存的数据的地址值

4.典型例题与内存解析:

例题1:

例题2:

递归方法

1.定义

递归方法:一个方法体调用它自身

2.如何理解递归方法?

方法递归包含了一种隐式循环,它会重复执行某段代码,但这种重复执行无须循环控制。

递归一定要向已知方向递归,否则这种递归就变成了无穷递归,类似于死循环。

3.举例:

//例1:计算1-100之间所有的自然数的和
//方式一:
//		int sum=0;
//		for(int i=1;i<=100;i++) {
//			sum+=i;
//		}
		RecursionTest test=new RecursionTest()	;
		System.out.println(test.getSum(100));
		System.out.println(test.getSum1(2));
		System.out.println("***************************");
		int value=test.f(10);
		System.out.println(value);
	}
		//方式二:计算1-n之间所有自然数的和
		public int getSum(int n) {
			if(n==1) {
				return 1;
			}else {
				return n+getSum(n-1);
			}
		}
		//例2:计算1-n之间所有自然数的乘积
		public int getSum1(int n) {
			if(n==1) {
				return 1;
			}else {
				return n*getSum1(n-1);
			}
		}
		//例3:已知有一个数列:f(0)=1,f(1)=4,f(n+2)=2*f(n-1)+f(n),
		//其中n是大于0的整数,求f(10)的值。 
		public int f(int n) {
			if(n==0) {
				return 1;
			}else if(n==1) {
			return 4;
			}else {
				return 2*f(n-1)+f(n-2);
			}
		}
		//例4:输入一个数据n,计算斐波那契数列(Fibonacci)的第n个值
		
		//例5:汉诺塔问题
		
		//例6:快排

标签:JAVA,形参,int,数据类型,面向对象,对象,方法,public
来源: https://www.cnblogs.com/nebun/p/16656626.html