面向对象（上）_面向对象上-CSDN博客

1. 学习三条主线

1.1 Java类及类的成员

（属性、方法、构造器、代码块、内部类）

1.2 面向对象的三大特征

（封装性、继承性、多态性、（抽象性））

1.3 其他关键字

（this、super、static、final、abstract、interface、package、import）

2. 面向过程与面向对象区别

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

面向对象，将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

3. 面向对象（上）

3.1 对象数组的内存解析

3.2 匿名对象

3.2.1 理解

我们创建的对象，没有显式的赋值给一个变量名，即为匿名对象。

3.2.2 特征

匿名对象只能调用一次。

3.2.3 使用

public class InstanceTest {
	public static void main(String[] args) {
		Phone p = new Phone();
//		p = null;
		System.out.println(p);
		
		p.sendEmail();
		p.playGame();
		
		
		//匿名对象
//		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();
	}
	
}


class Phone{
	double price;//价格
	
	public void sendEmail(){
		System.out.println("发送邮件");
	}
	
	public void playGame(){
		System.out.println("玩游戏");
	}
	
	public void showPrice(){
		System.out.println("手机价格为：" + price);
	}
	
}

3.3 方法

3.3.1 方法的重载（overload）

“两同一不同”:

同一个类、相同方法名

参数列表不同：参数个数不同，参数类型不同

	//如下的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){//形参变量名
//		
//	}
	
//	private void getSum(int i,int j){//权限修饰符
//		
//	}

判断是否重载：与方法的权限修饰符、返回值类型、形参变量名、方法体无关！

3.3.2 可变形参数的方法

可变个数形参的方法

1.jdk 5.0新增的内容

2.具体使用：

2.1 可变个数形参的格式：数据类型 … 变量名

2.2 当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个,2个，。。。

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

2.4 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。

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

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

public class MethodArgsTest {
	
	public static void main(String[] args) {
		
		MethodArgsTest test = new MethodArgsTest();
		test.show(12);
//		test.show("hello");
//		test.show("hello","world");
//		test.show();
		
		test.show(new String[]{"AA","BB","CC"});
		
	}
	
	
	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.4
//		
//	}
	
	//The variable argument type String of the method 
	//show must be the last parameter
//	public void show(String ...strs,int i){		//2.5
//		
//	}
    
    //	public void show(int i，String ...strs){		//可行
//		
//	}
 
}

3.3.3 方法参数的值传递机制（重）

Java里方法的参数传递方式只有一种：值传递。即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。

形参是基本数据类型：将实参基本数据类型变量的“数据值”传递给形参
形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参

public class TransferTest3 {
	public static void main(String args[]) {
		TransferTest3 test = new TransferTest3();
		test.first();
	}
	public void first() {
		int i = 5;
		Value v = new Value();
		v.i = 25;
		second(v, i);
		System.out.println(v.i);
	}
	public void second(Value v, int i) {
		i = 0;
		v.i = 20;
		Value val = new Value();
		v = val;
		System.out.println(v.i + " " + i);
	}
}
class Value {
	int i = 15;
}

输出：

15 0
20

内存解析：

回收：

——>变量⑨val、⑦i、⑥v出栈

——>堆结构0x8899无指针指向被回收

——>变量③v、②i出栈

——>堆结构0x5566无指针指向被回收

——>变量①test出栈

——>堆结构①无指针指向被回收

内存结构：栈（局部变量）、堆（new出来的结构：对象（非static成员变量）、数组）

变量：成员变量 VS 局部变量（方法内、方法形参、构造器内、构造器形参、代码块内）

		int[] arr=new int[] {1,2,3};
		System.out.println(arr);//地址值	Object
		
		char[] arr1=new char[] {'a','b','c'};//特殊
		System.out.println(arr1);//abc	char
		
		String[] arr2=new String[] {"asd","asd","sjhd"};
		System.out.println(arr2);//地址值		Object

3.3.4 递归方法

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

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

//计算1-100之间所有自然数的和
public int sum(int num){
	if(num == 1){
		return 1;
	}else{
		return num + sum(num - 1);
	} 
}

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

我们程序设计追求“高内聚，低耦合”。
- 高内聚：类的内部数据操作细节自己完成，不允许外部干涉；
- 低耦合：仅对外暴露少量的方法用于使用。
隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

一、问题的引入：

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

二、封装性的体现：

我们将类的属性xxx私有化(private),同时，提供公共的(public)方法来获取(getXxx) 和设置(setXxx) 此属性的值。

自动生成get和set函数

(alt+s)source->generate Getters and Setters…->✔->Generate
拓展：封装性的体现：① 如上 ② 不对外暴露的私有的方法（内部方法调用） ③ 单例模式 …

三、封装性的体现，需要权限修饰符来配合。

1.Java规定的4种权限（从小到大排列）：private、缺省(default)、protected 、public
2.4种权限可以用来修饰类及类的内部结构：属性、方法、构造器、内部类
3.具体的，4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类
修饰类的话，只能使用：缺省、public
总结封装性：Java提供了4种权限修饰符来修饰类及类的内部结构，体现类及类的内部结构在被调用时的可见性的大小。

3.5 类的成员之三：构造器（或构造方法）

构造器（或构造方法、constructor）的使用

construct：建设、建造。 construction:CCB constructor:建设者

默认构造器的权限与类相同

一、构造器的作用：

1.创建对象

2.初始化对象的信息

二、说明：

1.如果没有显式的定义类的构造器的话，则系统默认提供一个空参的构造器

2.定义构造器的格式：权限修饰符类名(形参列表){}

3.一个类中定义的多个构造器，彼此构成重载

4.一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器

5.一个类中，至少会有一个构造器。

public class PersonTest {
	public static void main(String[] args) {
		//创建类的对象:new + 构造器
		Person p = new Person();
		
		p.eat();
		
		Person p1 = new Person("Tom");
		
		System.out.println(p1.name);
		
	}
}

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

	
	//方法
	public void eat(){
		System.out.println("人吃饭");
	}
	
	public void study(){
		System.out.println("人可以学习");
	}
	
}

自动生成构造器

(alt+s)source->generate Constructor using Fields…->取消✔->Generate

3.6 属性赋值的先后顺序

① 默认初始化

② 显式初始化

③ 构造器中初始化 //①②③只执行一次

④ 通过"对象.方法" 或 "对象.属性"的方式，赋值

以上操作的先后顺序：① - ② - ③ - ④

public class UserTest {
	public static void main(String[] args) {
		User u = new User();
		
		System.out.println(u.age);
		
		User u1 = new User(2);
		
		u1.setAge(3);
		u1.setAge(5);
		
		System.out.println(u1.age);
	}
}

class User{
	String name;
	int age = 1;
	
	public User(){
		
	}
	
	public User(int a){
		age = a;
	}
	
	public void setAge(int a){
		age = a;
	}
	
}

3.7 JavaBean

所谓javaBean，是指符合如下标准的Java类：

类是公共的
有一个无参的公共的构造器
有属性，且有对应的get、set方法

public class Customer {
	
	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;
	}
	
}

3.8 UML类图

3.9 关键字：This的使用

this关键字的使用：

1.this可以用来修饰、调用：属性、方法、构造器

2.this修饰属性和方法：

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

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

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

this调用构造器

① 我们在类的构造器中，可以显式的使用"this(形参列表)"方式，调用本类中指定的其他构造器

② 构造器中**不能**通过"this(形参列表)"方式调用自己

③ 如果一个类中有n个构造器，则最多有 n - 1构造器中使用了"this(形参列表)"

④ 规定："this(形参列表)"必须声明在当前构造器的首行

⑤ 构造器内部，最多只能声明一个"this(形参列表)"，用来调用其他的构造器

public class PersonTest {
	public static void main(String[] args) {
		
		Person p1 = new Person();
		
		p1.setAge(1);
		System.out.println(p1.getAge());
		
		p1.eat();
		
		System.out.println();
		
		Person p2 = new Person("Jerry",20);
		System.out.println(p2.getAge());
		
	}
}

class Person{
	//属性
	private String name;
	private int age;
	
	//构造器
	public Person(){
		
//		this.eat();
		String info = "Person初始化时，需要考虑如下的1,2,3,4...(共40行代码)";
		System.out.println(info);
	}
	
	public Person(String name){
		this();
		this.name = name;
		
	}
	
	public Person(int age){
		this();
		this.age = age;
		
	}
	
	public Person(String name,int age){
		this(age);
		this.name = name;
		//this.age = age;
		//Person初始化时，需要考虑如下的1,2,3,4...(共40行代码)
	}
	
    //方法
	public void setName(String name){
		this.name = name;
	}
	public String getName(){
		return this.name;
	}
	public void setAge(int age){
		this.age = age;
	}
	public int getAge(){
		return this.age;
	}
	
	public void eat(){
		System.out.println("人吃饭");
		this.study();
	}
	public void study(){
		System.out.println("人学习");
	}
	
}

3.10 关键字：package、import的使用

一、package关键字的使用

1.为了更好的实现项目中类的管理，提供包的概念

2.使用package声明类或接口所属的包，声明在源文件的首行

3.包，属于标识符，遵循标识符的命名规则、规范(xxxyyyzzz)、“见名知意”

4.每"."一次，就代表一层文件目录。

补充：同一个包下，不能命名同名的接口、类。

不同的包下，可以命名同名的接口、类。

二、import关键字的使用

import:导入

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

package com.atguigu.java2;

import java.lang.reflect.Field;
import java.util.*;

import com.atguigu.exer4.Account;
import com.atguigu.exer4.Bank;
import com.atguigu.java2.java3.Dog;

import static java.lang.System.*;
import static java.lang.Math.*;

public class PackageImportTest {
	public static void main(String[] args) {
		
		String info = Arrays.toString(new int[]{1,2,3});
		
		Bank bank = new Bank();
		
		ArrayList list = new ArrayList();
		HashMap map = new HashMap();
		
		Scanner s = null;
		
		System.out.println("hello!");
		
		Person p = new Person();
		
		Account acct = new Account(1000);
		//全类名的方式显示
		com.atguigu.exer3.Account acct1 = new com.atguigu.exer3.Account(1000,2000,0.0123);
		
		Date date = new Date();
		java.sql.Date date1 = new java.sql.Date(5243523532535L);
		
		Dog dog = new Dog();
		
		Field field = null;
		
		out.println("hello");
		
		long num = round(123.434);
	}
}