面向对象（一）类和对象

面向过程（POP）与面向对象（OOP）

二者都是一种思想，面向对象是相对于面向过程而言的。面向过程，强调的是功能行为，以函数为最小单位，考虑怎么做。面向对象，将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，如抽象、分类、继承、聚合、多态等。

面向对象学习的三条主线：

Java类及类的成员：属性、方法、构造器；代码块、内部类
面向对象的三大特征：封装性、继承性、多态性、（抽象性）
其他关键字：this、super、static、final、abstract、interface、package、import等

类和对象（面向对象的两大要素）

类（Class）和对象（Object）是面向对象的核心概念。

类是对一类事物的描述，是抽象的、概念上的定义。
对象是实际存在的该类事物的每个个体，因而也称为实例(instance)。

面向对象程序设计的重点是类的设计
设计类，就是设计类的成员。

二者之间的关系：对象是由类 new 出来的，派生出来的。

几个概念的使用说明

属性 = 成员变量 = field = 域、字段
方法 = 成员方法 = 函数 = method
创建类的对象 = 类的实例化 = 实例化类

类和对象的使用

1.创建类，设计类的成员
2.创建类的对象
3.通过对象.属性或者对象.方法调用对象的结构

类的语法格式

修饰符 class 类名 {
属性声明;
方法声明;
}
说明：修饰符public ：类可以被任意访问，类的正文要用{ }

对象的创建和使用

创建对象语法：类名对象名 = new 类名();
使用 “对象名. 对象成员 ” 的方式访问对象成员（包括属性和方法）

类的访问机制

在一个类中的访问机制：类中的方法可以直接访问类中的成员变量。
（例外：static 方法访问非 static，编译不通过）
在不同类中的访问机制：先创建要访问类的对象，再用对象访问类中定义的成员。

扫描二维码关注公众号，回复： 11626692 查看本文章

对象的分析

内存解析

在这里插入图片描述

对象的内存解析

在这里插入图片描述

1. 成员变量（属性）与局部变量的区别

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.类中方法的声明

方法：描述应该具有的功能。
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种权限修饰符: private、 public、缺省、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.方法的使用：
方法饿使用中，可以调用当前类的属性或方法
	特殊的：方法A中有调用了方法A：递归方法。行为：对应类中的成员方法

3.return关键字

return关键字的使用：

使用范围：使用在方法中
作用：①结束方法；②针对于有返回值类型的方法，使用 “return 数据” 方法返回所要的数据。
注意：return关键字最后面不可以声明执行语句。

4.匿名对象与方法重载

匿名对象

理解：我们创建的对象，没有显示的赋给一个变量名，即为匿名对象
特征：匿名对象只能调用一次
使用

new Phone().price=1999;
new Phone().showPrice;//0.0
每次new的都是堆空间的一个新对象。

方法重载

定义：在同一个类中，允许存在一个以上同名方法，只要他们的参数个数或者参数类型不同即可。
特点：与返回值类型无关，与权限修饰符无关，与形参变量名无关，与方法体无关。
常见的：构造器重载

5.可变个数形参与变量赋值

可变个数形参

格式：Object…args
当调用可变个数形参的方式时，传入的参数个数可以是：0个，1个，2个
可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载
可变个数形参的方法与本类中，必须放到最后
可变个数形参的方法与本类中，最多只能声明一个可变形参

变量赋值

如果变量是基本数据类型：此时赋值的是变量所保存的数据值。
如果变量时引用数据类型：此时赋值的是变量所保存数据的地址值。
此时改变变量的值，相当于改变地址对应的值。

6.形参的值传递机制与递归方法

值传递机制

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

1.概念：

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

2.值传递机制：

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

递归方法

一个方法体内，自己调用自己。

/**
 * 递归方法求1-100的和
 */
public static void main(String[] args) {
    int n = 100;
    int sum = getSum(n);
    System.out.println(sum);
}

public static int getSum(int sum) {
    if (sum == 1) {
        return 1;
    } else {
        return sum + getSum(sum - 1);
    }
}
/**
 * 已知一个数列，f(0)=1,f(1)=4,f(n+2)=2*f(n+1)+f(n);
 * 其中n是大于0的整数，求f(10)。
 */
public static int getSum(int sum) {
    if (sum == 0) {
        return 1;
    } else if (sum == 1) {
        return 4;
    } else {
        return 2 * getSum(sum - 1) + getSum(sum - 2);
    }
}
/**
 * 递归方法求斐波那契数列的前n项，并输出。
 * @return
 */
public static void main(String[] args) {
    int arg=10;
    int avg=getArgs(arg);
    System.out.println(avg);
}
public static int getArgs(int args){
    if(args<=2){
        return 1;
    }
    else{
        return getArgs(args-1)+getArgs(args-2);
    }
}

面试题

public class Test{
  	//题目
	public static void main(String[] args){
		int a = 10;
		int b = 10;
		method(a,b);//需要在method方法被调用之后，进打印出a=100,b=200,请写出method方法的代码
		System.out.println("a="+a);
		System.out.println("b="+b);
	}
	
	//代码编写处
	//方式一：
	public static void method(int a,int b){
		a = a*10;
		b = b*20;
		System.out.println(a);
		System.out.println(b);
		System.exit(0);
	}
	//方式二：
	public static void method(int a,int b){
		PrintStream ps = new PrintStream(System.out){
			@Override
			public void println(String x){
				if("a=10".equals(x)){
					x = "a=100";
				}else if("b=10".equals(x)){
					x = "b=200";
				}
				super.println(x);
			}
		};
		System.setOut(ps);
	}
}

定义一个int型的数组：int[] arr = new int[]{12,3,3,34,56,77,432};
让数组的每个位置上的值去除以首位置的元素，得到的结果，作为该位置上的新值。遍历新的数组。

//正确写法1
for(int i = arr.length – 1;i >= 0;i--){
arr[i] = arr[i] / arr[0];
}

//正确写法2
int temp = arr[0];
for(int i= 0；i < arr.length;i++){
arr[i] = arr[i] / temp;
}

int[] arr = new int[]{1,2,3};
System.out.println(arr);//地址值

char[] arr1 = new char[]{'a','b','c'};
System.out.println(arr1); //abc

如果有收获！！！希望老铁们来个三连，点赞、收藏、转发。
创作不易，别忘点个赞，可以让更多的人看到这篇文章，顺便鼓励我写出更好的博客