Java基础4.面向对象（上）_不构成重载-CSDN博客

1.面向过程
*
* ①把冰箱门打开
* ②抬起大象，塞进冰箱
* ③把冰箱门关闭
*
* 2.面向对象
* 人{
*        打开（冰箱）{
*            冰箱.开开（）;
*        }
*        抬起（大象{
*            大象.进入（冰箱;
*        }
*
*        关闭（冰箱{
*            冰箱.(闭合)
*        }
* }
* 冰箱{
*        开开（）{}
*        闭合（{}
*
* }
* 大象{
*        进入（冰箱{}
* }

什么是面向对象？

面向对象是一种直观的程序结构简单的程序设计方式。面向对象将问题拆分成由若干个不同的对象组成，通过对象的属性和行为控制进行开发

2.

3.面向对象的核心概念：；类：概念模型；对象：实例

4

5面向对象的三大特性：封装继承多态（抽象）

6.

7.类：概念模型，具有相同属性和方法的一组对象的集合（抽象概念）

8类就是没有具体值的概念或模型，对象就是有明确值的类，所谓类的实例化；

9.对象：实例，是用来描述客观事物的实体（具体概念）

10

11.面向对象的开发的过程是一个抽象的过程，分三步：

>发现类

>发现类的静态特征：属性

>发现类的静态特征：方法

12

13定义类的语法：

> 类的访问修饰符 class 类名称{

>

> }

类名称要求大写；

类的访问修饰符只能是public、缺省|（默认）

14.定义属性的语法：

属性的访问修饰符数据类型属性名称【=初始值】；【】：中的可以先不写；

15

16.定义方法的语法

方法的访问修饰符返回值类型方法名称([参数列表]）{

方法体，方法的具体实现

        }

返回值：方法产生的结果，若果方法没有返回值，写成void；如果方法有返回值，需要在方法体内部通过return返回对应数据类型的值；

17

18.参数：在方法中实际调用传递的辅助的数据；辅助方法体来具体实现的；

语法：参数数据类型参数名称，参数数据类型参数名称2.......

19

20声明对象的语法：

类名称对象名 = new 类名称（）；

对象名.属性名 = 值；

对象名.方法名（【实参】）；

21

22.构造方法：构造方法是用来初始化属性的，new 类名称（）:new是来创建对象的，构造方法只是其中的一部分

语法：public 类名（【参数列表】）{

方法体

                }

通过有参构造方法可以在声明对象的同时给对象的属性赋值

如果没有编写自定义的构造方法，则java会自动添加默认构造方法没有参数

如果自定义了一个或多个构造方法，则Java不会添加默认的构造方法

注：一个类中可以生成多个构造方法，具体问题具体分析，以后不一定需要给所有属性直接赋值，需要几个就给几个赋值，生成含有几个变量的的构造方法。

23

24方法的重载：在同一个类中，同名不同参的一组方法称为方法的重载

怎么为不同参：参数数量参数类型 ---->不一样

3.完成一个项目（或功能）的思路：

>根据问题需要，选择问题所针对的现实世界中的实体。
>从实体中寻找解决问题相关的属性和功能，这些属性和功能就形成了概念世界中的类。
>把抽象的实体用计算机语言进行描述，形成计算机世界中类的定义。即借助某种程序
语言，把类构造成计算机能够识别和处理的数据结构。
>将类实例化成计算机世界中的对象。对象是计算机世界中解决问题的最终工具。

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

面向对象的两要素：类(Class)和对象(Object)。
类：类是对一类事物的描述，是抽象的、概念上的定义。
对象：对象是实际存在的该类事物的每个个体，因而也称为实例(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(p);
//匿名对象的使用
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的）加载在堆空间中
>方法区：类的加载信息、常量池、静态区

二、类的结构之一：属性

2.类的设计中，两个重要结构之一：属性

1.对比：属性（成员变量) vs 局部变量

1.1.相同点：

*        1.1定义变量的格式：数据类型变量名 = 变量值
*        1.2先声明，后使用
*        1.3变量都其相对应的作用域

1.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
*        局部变量：加载到栈空间

2.补充：回顾变量的分类：

2.1方式一：按照数据类型：

2.2方式二：按照声名的位置不同

三、类的结构之二：方法

3.类的设计中，两个重要结构之二：方法

1.类中方法的声明和使用

1.1方法

方法：描述类应该具的功能。
比如：Math类：sqrt()\random()\ ....
Scanner类，nextXxx() ....
Arrays类，sort() \ binarySearch() \toString() \ equals() ...

1.2举例

public void eat() {}//void：指没返回值的
public void sleep(int hour){} //（）内为形参
public String getName(){}//返回值，返回值的类型是String型
public String getNation(String nation){}

2方法的声明

方法的声明：权限修饰符返回值类型方法名（形参列表）{
方法体
}

static、 final、abstract 为关键字，来修饰的方法。

3声名方法的说明

3.1关于权限修饰符

关于权限修饰符：默认方法的权限修饰符先都是用public
Java规定的4种权限修饰符：private(权限点小：私的，在调用时会报错)、public（权限最大）、缺省、protected

3.2返回值类型

1.返回值 vs 没返回值

          如果方法有返回值，则必须在方法声明时指定返回值的类型。同时，方法中，需要使用return关键字来返回指定类型的变量或常量。
       如果方法没有返回值，则方法声明时，使用void来表示。通常，没返回值的方法中，就不需要使用return。但是，如果使用的话，只能“return;”表示结束此方法的意思。
2.我们定义方法该不该返回值？
               ① 题目要求：定义一个方法用来计算圆的面积，返回面积
               ② 凭经验：具体问题具体分析；random（，Scanner()需要返回值

3.3方法名

方法名：属于标识符，遵循标识符的规则和规范，“见名知意”

3.4 形参列表

形参列表：方法可以声名0个，1个，或多个形参。
   1.格式：数据类型1 形参1，数据类型2 形参2，数据类型3 形参3,.......

2.我们定义方法时，该不该定义形参？
               ① 题目要求
               ② 具体问题具体分析

3.5方法体

方法体：方法功能的实现。

4方法的使用

方法的使用：可以调用当前类的属性或方法。

特殊的：方法A中又调用了方法A：递归方法
方法中，不可以定义方法

5.return关键字

5.1使用范围

使用范围：使用在方法体中

5.2作用

作用：
① 结束方法
② 针对于返回值类型的方法，使用“return 数据”方法返回所需要的数据

5.3注意点

注意点：return关键字后不可以声名执行语句。

6.方法的重载

6.1方法的重载的概念

定义：在同一个类中，允许存在一个以上的同名方法，只要他们的参数个数或者参数类型不同即可。
总结：“两同一不同”：同一类，相同的方法名
参数列表不同：①参数个数不同，②参数类型不同

6.2构成重载的举例

举例一：Arrays类中重载sort()/binary Search()；PrintStream中的println()
举例二：

//如下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");
   }
不构成重载的举例：
//如下的3个方法不能与上述4个方法构成重载
//   public int getSum(int i,int j) {
//       return 0;
//   }
//
//   public void getSum(int m,int n) {
//
//   }
//
//   public void getSum(int i;int j) {
//
//   }

6.3 如何判断是否构成方法的重载？

严格按照定义判断：两同一不同。
跟方法的权限修饰符、返回值类型、形参变量名、方法体都没关系。

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

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

拓展：

面试题：方法的重载与重写的区别？
throws\throw
String\StringBuffer\StringBuilder
Collection\Collections
final\finally\finalize
...

抽象类、接口
sleep()/wait()

7.可变个数形参的方法

7.1使用说明

1.jdk 5.0新增的内容
2.具体使用：
       2.1 可变个数形参的格式：数据类型 ... 变量名
       2.2 当调用可变个数形参的方法时，传入的参数个数可以是0个、1个、2个、...多个
       2.3 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载。
       2.4 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存
       2.5 可变个数形参在方法形参中，必须声名在末尾
       2.6 可变个数形参在方法的形参中，最多只能声名一个可变形参。

注：在方法调用时，方法与可变形参方法构成重载，在调用时实参个数确定，且符合重载的方法，则优先调用重载的方法，可变形参方法优先级靠后。
举例（为了方便了解什么情况下会用到可变个数形参：如数据库中，select *** where _ ,_ ,_
学生表，查找一个学生的基本信息，学生只有一个，基本信息会有很多就会用到可变个数参数的这种结构

7.2举例说明

举例说明：

package com.atguigu.java1;
/*
 * 可变参数的方法
 */
public class MethodArgsTest {
	
	public static void main(String[] args) {
		
		MethodArgsTest test = new MethodArgsTest();
		test.show(12);
		test.show("aa","bb","cc","dd","ee");//show(String ... strs)
		test.show(18);
		test.show("hello");//show(String s)
		//test.show("hello","word");
		//test.show();
	
		//test.show(new String[]{"AA","BB","cc"});//show(String[] strs)
		test.show(new String[]{"AA","BB","cc"});
		
	}
	public void show(int i) {
		System.out.println("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]);
		}
	}
	//jdk5.0以前的版本使用以下结构来表示，可变个数形参的方法，不构成重载。
	//不能与上一个方法同时共存
	//public void show(String[] strs) {
		
	//}
	
	public void show(int i,String ... strs) {//2.5
		
		}
	//错误：The variable argument type String of the method 
	//show must be the last parameter
	//public void show(String ... strs,int i) {
		
	//}
	
}

调用时：


    MethodArgsTest test = new MethodArgsTest();
		test.show(12);
		//test.show("hello");
		//test.show("hello","word");
		//test.show();
		
		//test.show(new String[]{"AA","BB","cc"});//show(String[] strs)
		test.show(new String[]{"AA","BB","cc"});

8.Java的值传递机制

8.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);

规则：如果变量是基本数据类型，此时赋值的是变量所部保存的数据值。
如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。

8.2针对于方法的参数概念

形参：形参：方法定义时，声名的小括号内的参数
实参：实参：方法调用时，实际传递给形参的数据

8.3java中参数传递机制：值传递

规则：
如果参数是基本数据类型，此时实参赋给形参的是，实参真实存储的数据值。
如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值

推广：
如果变量是基本数据类型，此时赋值的是变量所部保存的数据值。
如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。

8.4典型例题与内存解析

9.递归方法

9.1定义

递归方法：一个方法体内调用它自身。

9.2如何理解递归方法？

>方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
>递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。

9.3举例

    //例1：计算1~100之间所自然数的和
		public int getSum(int n) {
			
			if(n == 1) {//递归终止
				return 1;
			}else {
				return n + getSum(n-1);
			}
			
		}	
		
		//例2：计算1~n之间所自然数的乘积：n！
		public int getProduct(int n) {
					
			if(n == 1) {//递归终止
				return 1;
			}else {
				return n * getSum(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 f(n+2)-2*f(n+1);
				return 2*f(n-1) + f(n-2);
			}
		}
		
		//例4：斐波那契数列(Fibonacc)
		//500阶台阶问走完这些台阶一共有几种方法
		public int fibonacc(int n) {
			if(n == 1) {
				return 1;
			}else if(n == 2) {
				return 1;
			}else {
				return fibonacc(n - 1)+fibonacc(n - 2);
			}
		}
		
		//例5：汉诺塔问题
		
		//例6：快排（快速排序

四、面向对象的特征一：封装性

面向对象的特征：封装与隐藏

1.为什么要引入封装性？

2.问题引入

当我们常见一个类的对象以后，我们可以通过“对象.属性”的方式，对对象的属性进行赋值。这里，赋值操作受到属性的数据类型和存储范围的制约。除此之外，没其他制约条件。但是，在实际问题中，我们需要给属性赋值加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。（比如：setLegs()同时，我们需要避免用户在使用“对象.属性”的方式对属性进行赋值。则需要将属性声明为私有的(private)
-->此时，针对于属性就体现了封装性

3.封装性思想具体的代码体现

注：封装性思想具体的代码体现：不等同于封装性，这只是封装性的一个点

体现一：我们将类的属性私化（private同时，提供公共(public)的方法来获取(getXxx)和设置(setXxx)此属性的值

eg:private double radius;
public void setRadius(double radius){
this.radius = radius;
}
public double getRadius(){
return radius;
}

体现二：不对外暴露的私的方法

体现三：单例模式(将构造器私有化)

体现四：如果不希望类在包外被调用，可以将类设置为缺省的

4.Java规定的四种权限修饰符

4.1 权限大小

权限从小到大顺序：private(私有的) < 缺省(default：不写) < protected(受保护的) < public(公共的)

4.2 具体的修饰范围

4.3 权限修饰符可用来修饰的结构说明：

具体的，4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类
修饰类的话，只能使用：缺省、public

5.总结封装性

总结封装性：Java提供了4种权限修饰符来修饰类及类的内部结构，体现类及类的内部结构在被调用时的可见性的大小。

五.类的结构之三：构造器

1.构造器（构造方法）：Constructor

1.1构造器的作用：

1.创建对象
2.初始化对象的属性（初始化对象的信息)
注：只要我们造对象，就得用构造器（√）

2.使用说明：(使用中哪些注意点?)

1.如果没显示的定义类的构造器的话，则系统默认提供一个空参的构造器。
2.定义构造器的格式：权限修饰符类名 ( 形参列表 ) { }
3.一个类中定义的多个构造器，彼此构成重载。
4.一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器。
5.一个类中，至少会有一个构造器。一直都√
注：默认的构造器类型的权限与类相同
eg:public class A{ class A{
默认的构造器：默认构造器：
public A(){}//public A(){}//缺省
} }

3.举例

//构造器
public Person() {
		System.out.println("Person()......");
	}
	
	public Person(String n) {
		name = n;
	}
	public Person(String n,int a) {
		name = n;
		age = a;
	}

4.属性赋值顺序

总结：属性赋值的先后顺序

    生成对象之前：
       ①默认初始化值
        ②显式初始化
      ③构造器中初始化(另一种称呼:构造器中赋值)
生成对象之后：
        ④通过“对象.方法”或"对象.属性"，赋值

    以上操作的先后顺序：① - ② - ③ - ④ //① - ③ - ② - ④
       最终值为：最后一个操作的赋值

5.JavaBean的概念

JavaBean是一种Java语言写成的可重用组件。

所谓JavaBean，是指符合如下标准的Java类：
>类是公共的
>一个无参的公共的构造器
>属性，且对应的get、set方法
如下的类，为一个JavaBean:

public class Customer {//customer:客户,Customer类就是一个JavaBean
	//属性
	private int id;
	private String name;
	
	//构造器：无参的构造器
	public Customer() {
		
	}
	
	//方法
	public void setId(int i) {
		id = i;
	}
	public int getId() {
		return id;
	}
	
	public void setName(String n) {
		name = n;
	}
	public String getName() {
		return name;
	}	
}

六、关键字this

1.作用

可以调用的结构：属性、方法;构造器

2.this调用属性、方法

this理解为：当前对象或当前正在创建的对象

2.1在类的方法中调用属性，方法

在类的方法中，我们可以使用“this.属性”或“this.方法”的方式，调用当前对象的属性或方法。但是通常情况下，我们都择省略“this.”。特殊情况下，如果方法的形参和类的属性同名时，我们必须显式的使用“this.变量”的方式，表明此变量是属性，而非形参。

2.2在构造器中调用属性，方法

在类的构造器中，我们可以使用“this.属性”或“this.方法”的方式。调用当前正在创建的对象的属性或方法。但是，通常情况下，我们都择省略“this.”。特殊情况下，如果构造器的形参和类的属性同名时，我们必须显式的使用“this.变量”的方式，表明此变量是属性，而非形参。

3.this调用构造器

① 我们在类的构造器中，可以显式的使用“this(形参列表)”方式，调用本类中指定的其他构造器
② 构造器中不能通过“this(形参列表)”方式调用自己。
③ 如果一个类中有n个构造器，则最多有n-1构造器中使用了“this(形参列表)”
④ 规定：“this(形参列表)”必须声名在当前构造器的首行。
⑤ 构造器内部，最多只能声名一个“this（形参列表)”，用来调用其他的构造器。（只能调用一个其他的构造器）

七、关键字：package/import

1. package的使用

1.1 使用说明

1.为了更好的实现项目中类的管理，提供包的概念
2.使用package声名类或接口所属的包，声名在源文件的首行
3.包，属于标识符，遵循标识符的命名规则、规范（xxxyyyzzz、“见名知意”
4.每“.”一次，就代表一层文件目录。

1.2 举例

举例一：

JavaBean：在domain包下
视图：在GUI包中
举例二：MVC设计模式

1.3 JDK中的主要包介绍

2. import的使用

import:导入
* 1.在源文件中显示的使用import结构导入指定包下的类、接口
* 2.声名在包的声名和类的声名之见（package; import; 类名
* 3.如果需要导入多个结构，则并列写出即可
* 4.可以用“xxx.*”的方式，表示可以导入xxx包下的所结构
* 5.如果使用的类或接口是java.lang包下定义的，则可以省略import结构
* 6.如果使用的类或接口是本包下定义的，则可以省略import结构
* 7.如果在源文件中使用了不同包下的同名的类，则必须至少一个类需要以全类名的方式显示。
* 8.使用“xxx.*”的方式表明可以调用xxx包下的所结构，但是如果使用的是xxx子包下的结构，则仍需要显式导入。
*
* 9.import static:导入指定类或接口中的静态结构：属性、方法。