java 面向对象之二：
Ⅰ、对象的创建和使用：
1、对象的内存解析：
其一、描述：
* 一、理解“万事万物皆对象”
*
* 1.在 Java 语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构
* >Scanner,String等
* >文件：File
* >网络资源：URL
*
* 2.涉及到 Java 语言与前端 Html、后端的数据库交互时，前后端的结构在 Java 层面交互时，都体现为类、对象。
*
*
* 二、内存解析的说明
*
* 1.引用类型的变量，只可能存储两类值：null 或 地址值（含变量的类型）
其二、内存解析代码1为：
class UserTest{
main(){
User user1 = new User();
user1.age = 10;
User user2 = new User();
sysout(user2.age);//0
}
}
class User{
//属性（或成员变量）
String name;
int age ;
}
其三、内存解析截图1为：
其四、内存解析代码2为：
class Person{//人类
//1.属性
String name;//姓名
int age = 1;//年龄
boolean isMale;//是否是男性
}
class PersonTest{
main(){
Person p = new Person();
Person p1 = new Person();
p1.name = “Tom”;
Person p2 = p1;
}
}
其五、内存解析截图2为：
2、匿名对象的使用：
其一、描述：
* 三、匿名对象的使用
* 1.理解：我们创建的对象，没有显式的赋给一个变量名。即为匿名对象
* 2.特征：匿名对象只能调用一次。
* 3.使用：如下
其二、代码为：
package com.atguigu.java;
public class InstanceTest {
public static void main(String[] args) {
Phone p = new Phone();
// p = null;
//若设 p=null; 那么此时输出 p 就为 null; 若设 Phone p = new Phone(); 那么此时输出 p 就为带类型的地址值;
//即：引用类型的变量，只可能存储两类值：null 或 地址值（含变量的类型）;
System.out.println(p);//com.atguigu.java.Phone@15db9742(即：带类型的地址值)
//非匿名对象，名字为:p;
//此时调用 sendEmail() 和 playGame() 方法的是同一个对象 p;
p.sendEmail();//发送邮件
p.playGame();//玩游戏
//匿名对象
//此时调用 sendEmail() 和 playGame() 方法的是不同的匿名对象(因为：每次 new Phone() 操作后都是一个新的对象);
// new Phone().sendEmail();//发送邮件
// new Phone().playGame();//玩游戏
new Phone().price = 1999;
new Phone().showPrice();//0.0(说明：每次 new Phone() 操作后都是一个新的匿名对象)
//**********************************
PhoneMall mall = new PhoneMall();
// mall.show(p);
//匿名对象的使用
mall.show(new Phone());
}
}
class PhoneMall{
//此时的形参 phone 是一个栈中的地址，此时也可以称之为名字为 phone(即：此时就可以调用 phone 实例中的属性或方法);
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、自定义数组的工具类：
其一、描述：
在 ArrayUtil.java 中定义数组的工具类：
求数组的最大值、求数组的最小值、求数组的总和、求数组的平均值、复制数组、数组排序、遍历数组、查找指定元素;
在 ArrayUtilTest.java 中调用数组的工具类方法;
其二、代码为：
A、ArrayUtil.java 与 ArrayUtilTest.java 在 java 工程中的目录：
B、ArrayUtil.java 中的代码为：
package com.atguigu.java;
/*
* 自定义数组的工具类
*
*/
public class ArrayUtil {
// 求数组的最大值
public int getMax(int[] arr) {
int maxValue = arr[0];
for (int i = 1; i < arr.length; i++) {
if (maxValue < arr[i]) {
maxValue = arr[i];
}
}
return maxValue;
}
// 求数组的最小值
public int getMin(int[] arr) {
int minValue = arr[0];
for (int i = 1; i < arr.length; i++) {
if (minValue > arr[i]) {
minValue = arr[i];
}
}
return minValue;
}
// 求数组的总和
public int getSum(int[] arr) {
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
return sum;
}
// 求数组的平均值
public int getAvg(int[] arr) {
return getSum(arr) / arr.length;
}
//如下的两个同名方法构成了重载
// 反转数组
public void reverse(int[] arr) {
for (int i = 0; i < arr.length / 2; i++) {
int temp = arr[i];
arr[i] = arr[arr.length - i - 1];
arr[arr.length - i - 1] = temp;
}
}
public void reverse(String[] arr){
}
// 复制数组
public int[] copy(int[] arr) {
int[] arr1 = new int[arr.length];
for (int i = 0; i < arr1.length; i++) {
arr1[i] = arr[i];
}
return arr1;
}
// 数组排序
public void sort(int[] arr) {
// 冒泡排序
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
// int temp = arr[j];
// arr[j] = arr[j + 1];
// arr[j + 1] = temp;
//错误的：只是在 swap() 中进行了交换操作，没有返回值，而数组元素是根本没变化;
// swap(arr[j],arr[j + 1]);
//正确的：
swap(arr,j,j + 1);
}
}
}
}
//错误的：交换数组中指定两个位置元素的值(因为只是在 swap() 函数中实现了实参值的交换，而在 arr 数组中数组元素值并没有变化)
// public void swap(int i,int j){
// int temp = i;
// i = j;
// j = temp;
// }
//正确的：交换数组中指定两个位置元素的值
public void swap(int[] arr,int i,int j){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
// 遍历数组
public void print(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
System.out.println();
}
// 查找指定元素
public int getIndex(int[] arr, int dest) {
// 线性查找：
for (int i = 0; i < arr.length; i++) {
if (dest == arr[i]) {
return i;
}
}
return -1;//返回一个负数，表示没有找到
}
}
C、ArrayUtilTest.java 中的代码为：
package com.atguigu.java;
public class ArrayUtilTest {
public static void main(String[] args) {
ArrayUtil util = new ArrayUtil();
int[] arr = new int[]{32,34,32,5,3,54,654,-98,0,-53,5};
int max = util.getMax(arr);
System.out.println("最大值为：" + max);//最大值为：654
System.out.println("排序前：");//排序前：
util.print(arr);//32 34 32 5 3 54 654 -98 0 -53 5
util.sort(arr);
System.out.println("排序后：");//排序后：
util.print(arr);//-98 -53 0 3 5 5 32 32 34 54 654
// System.out.println("查找：");//查找：
// int index = util.getIndex(arr, 5);
// if(index >= 0){
// System.out.println("找到了，索引地址为：" + index);//找到了，索引地址为：3
// }else{
// System.out.println("未找到");
// }
// util.reverse(arr);
}
}
其三、截图为：
Ⅱ、再谈方法(method)：
1、方法的重载(overload)：
其一、描述：
* 方法的重载（overload） loading...
*
*
* 1.定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
* 而将该同类中同名方法之间的关系就称之为重载的关系；
*
* "两同一不同":同一个类、相同方法名
* 参数列表不同：参数个数不同，参数类型不同
*
*
* 2. 举例：
* Arrays类中重载的sort() / binarySearch()方法;
*
*
* 3.判断是否是重载：
* 跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系！
*
*
* 4. 在通过对象调用方法时，如何确定某一个指定的方法：
* 方法名 ---> 参数列表
其二、代码为：
package com.atguigu.java1;
public class OverLoadTest {
public static void main(String[] args) {
OverLoadTest test = new OverLoadTest();
test.getSum(1,2);
//存在自动类型提升的情况：getSum(1,2) 中因为有确定两个 int 型参数的方法，就直接调用； 而若在 OverLoadTest 类中没有匹配 int 型参数的方法，
//因为可以类型提升，就需要寻找是否存在同名的重载方法，因此就匹配并调用了 getSum(double d1,double d2) 方法;
}
//如下的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){
//
// }
}
其三、截图为：
2、方法的重载2：重载方法调用
其一、描述：
1.编写程序，定义三个重载方法并调用。方法名为mOL。
三个方法分别接收一个int参数、两个int参数、一个字符串参数。
分别执行平方运算并输出结果，相乘并输出结果，输出字符串信息。
在主类的main ()方法中分别用参数区别调用三个方法。
2.定义三个重载方法max()，
第一个方法求两个int值中的最大值，
第二个方法求两个double值中的最大值，
第三个方法求三个double值中的最大值，
并分别调用三个方法。
其二、代码为：
package com.atguigu.exer;
public class OverloadExer {
//1. 如下的三个方法构成重载
public void mOL(int i){
System.out.println(i * i);
}
public void mOL(int i,int j){
System.out.println(i * j);
}
public void mOL(String s){
System.out.println(s);
}
//2.如下的三个方法构成重载
public int max(int i,int j){
return (i > j)? i : j;
}
public double max(double d1,double d2){
return (d1 > d2)? d1 : d2;
}
public double max(double d1,double d2,double d3){
double max = (d1 > d2)? d1 : d2;
return (max > d3)? max : d3;
}
}
3、可变个数的形参：
其一、描述：
* 可变个数形参的方法
*
* 1.jdk 5.0新增的内容
*
* 2.具体使用：
* 2.1 可变个数形参的格式：(数据类型 ... 变量名)
* 2.2 当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个,2个，。。。
* 2.3 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
* 2.4 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。
* 2.5 可变个数形参在方法的形参中，必须声明在末尾(即: 正确的格式为 show(int i,String ...strs))
* 2.6 可变个数形参在方法的形参中，最多只能声明一个可变形参。
其二、代码为：
package com.atguigu.java1;
public class MethodArgsTest {
public static void main(String[] args) {
MethodArgsTest test = new MethodArgsTest();
test.show(12);
// test.show("hello");//show(String)/show(String ... strs) (即:取决于待调用的 show(String s) 函数是否存在)
// test.show("hello","world");//show(String ... strs)
// test.show();//show(String ... strs)
test.show("AA","BB","CC");//AA BB CC
test.show(new String[]{"DD","EE","FF"});//DD EE FF
}
public void show(int i){
}
public void show(String s){
System.out.println("show(String)");
}
// 此时 (String ... strs) 中的 String ... strs 表示：可变个数的形参;
public void show(String ... strs){
System.out.println("show(String ... strs)");
//遍历的话，可以将 strs 参数看成数组来遍历;
for(int i = 0;i < strs.length;i++){
System.out.println(strs[i]);
}
}
//不能与上一个方法同时存在(原因：历史原因，由于 jdk 5.0 之前用 String[] strs 来定义不确定参数的个数的形参)
// public void show(String[] strs){
//
// }
//The variable argument type String of the method
//show must be the last parameter
// public void show(String ...strs,int i){
//
// }
}
其三、截图为：
4、关于变量的赋值：
其一、描述：
* 关于变量的赋值：
*
* 如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
* 如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。
*
其二、代码为：
package com.atguigu.java1;
public class ValueTransferTest {
public static void main(String[] args) {
System.out.println("***********基本数据类型：****************");
int m = 10;
int n = m;
System.out.println("m = " + m + ", n = " + n);//m = 10, n = 10
n = 20;
System.out.println("m = " + m + ", n = " + n);//m = 10, n = 20
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);//o1.orderId = 1001,o2.orderId = 1001
o2.orderId = 1002;
System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);//o1.orderId = 1002,o2.orderId = 1002
}
}
class Order{
int orderId;
}
其三、截图为：
5、方法参数的值传递机制：案例1
其一、描述：
* 方法的形参的传递机制：值传递
*
* 1.形参：方法定义时，声明的小括号内的参数
* 实参：方法调用时，实际传递给形参的数据
*
* 2.值传递机制：
* 如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。
* 如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值。
其二、代码为：
package com.atguigu.java1;
public class ValueTransferTest1 {
public static void main(String[] args) {
int m = 10;
int n = 20;
System.out.println("m = " + m + ", n = " + n);//m = 10, n = 20
//交换两个变量的值的操作
// int temp = m ;
// m = n;
// n = temp;
ValueTransferTest1 test = new ValueTransferTest1();
test.swap(m, n);
System.out.println("m = " + m + ", n = " + n);//m = 10, n = 20
//虽然调用了 swap() 方法，但是没有返回值，此时在 swap() 方法里定义的栈里的变量已经被释放了，因此此时输出的 m,n 是 main 方法里的变量;
}
//交换两个变量值的方法：
public void swap(int m,int n){
int temp = m ;
m = n;
n = temp;
}
}
其三、截图为：
6、方法参数的值传递机制：案例2
其一、描述：
* 方法的形参的传递机制：值传递
*
* 1.形参：方法定义时，声明的小括号内的参数
* 实参：方法调用时，实际传递给形参的数据
*
* 2.值传递机制：
* 如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。
* 如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值。
其二、代码为：
package com.atguigu.java1;
public class ValueTransferTest2 {
public static void main(String[] args) {
Data data = new Data();
data.m = 10;
data.n = 20;
System.out.println("m = " + data.m + ", n = " + data.n);//m = 10, n = 20
//交换m和n的值
// int temp = data.m;
// data.m = data.n;
// data.n = temp;
ValueTransferTest2 test = new ValueTransferTest2();
//此时传实参传的是：地址;
test.swap(data);
System.out.println("m = " + data.m + ", n = " + data.n);//m = 20, n = 10
}
public void swap(Data data){
int temp = data.m;
data.m = data.n;
data.n = temp;
}
}
class Data{
int m;
int n;
}
其三、截图为：
7、方法参数的值传递机制：案例3(char[] 的特殊情况)
其一、代码为：
package com.atguigu.java1;
public class ArrayPrintTest {
public static void main(String[] args) {
int[] arr = new int[]{1,2,3};
System.out.println(arr);//[I@15db9742(即：地址值)
char[] arr1 = new char[]{'a','b','c'};
System.out.println(arr1); //abc(即：此时就调用了 println(char[]) 方法，并自动遍历输出值，因此输出为 abc)
}
}
其二、截图为：
8、方法参数的值传递机制：案例4(求圆面积)
其一、描述：
* 考查参数的值传递
*
* 定义一个类 PassObject，在类中定义一个方法 printAreas()，
* 该方法的定义如下：public void printAreas(Circle c, int time)
* 在 printAreas 方法中打印输出 1 到 time 之间的每个整数半径值，以及对应的面积。
* 例如，time 为 5，则输出半径 1，2，3，4，5，以及对应的圆面积。
*
* 在 main 方法中调用 printAreas() 方法，调用完毕后输出当前半径值。程序运行结果如图所示。
其二、代码为：
A、Circle.java 和 PassObject.java 在 java 工程中的目录：
B、Circle.java 中的代码为：
/*
* 定义一个Circle类，包含一个double型的radius属性代表圆的半径，
* 一个findArea()方法返回圆的面积。
*
*/
package com.atguigu.exer1;
public class Circle {
double radius;//半径
//求圆的面积
public double findArea(){
return Math.PI * radius * radius;
}
}
C、PassObject.java 中的代码为：
package com.atguigu.exer1;
public class PassObject {
public static void main(String[] args) {
PassObject test = new PassObject();
Circle c = new Circle();
test.printAreas(c, 5);
System.out.println("now radius is " + c.radius);
}
public void printAreas(Circle c, int time){
System.out.println("Radius\t\tArea");
int i = 1;
for(;i <= time;i++){
//设置圆的半径
c.radius = i;
double area = c.findArea();
System.out.println(c.radius + "\t\t" + area);
}
//
// c.radius = time + 1;
c.radius = i;
}
}
其三、截图为：
9、方法参数的值传递机制：案例5(String 的特殊情况)
其一、代码为：
package com.atguigu.java;
public class ValueTransferTest {
public static void main(String[] args) {
String s1 = "hello";
ValueTransferTest test = new ValueTransferTest();
test.change(s1);
System.out.println(s1);//hello
//因为 String 引用类型比较特别，String s1 = "hello" 中的'hello' 会被放在字符串常量池中(即：不是放在栈中，也不是放在堆中)，'hello' 字符
//串底层是存于 char[] 中, 且地址赋值给 s1, 而此时 change(String s) 方法中的 s 也是地址指向 'hello'字符串的 char[] 中;
//而此时的 s = "hi~~"; 操作,对于 char[] 比较特殊，其会直接新建一个 char[] 来存放 'hi~~' 字符，因此此时 s 的地址指向 'hi~~'字符串的
//char[], 而此时的 s1 的地址依旧是指向 'hello' 字符串的 char[];
}
public void change(String s){
s = "hi~~";
}
}
其二、截图为：
10、递归方法：
其一、描述：
* 递归方法的使用（了解）
* 1.递归方法：一个方法体内调用它自身(即：自己调自己)。
* 2. 方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
* 递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。
其二、代码为：
public class RecursionTest {
public static void main(String[] args) {
// 例1：计算1-100之间所有自然数的和
// 方式一：
int sum = 0;
for (int i = 1; i <= 100; i++) {
sum += i;
}
System.out.println(sum);//5050
// 方式二：
RecursionTest test = new RecursionTest();
int sum1 = test.getSum(100);
System.out.println(sum1);//5050
System.out.println("*****************");
int value = test.f(10);
System.out.println(value);//10497
}
// 例1：计算1-n之间所有自然数的和
public int getSum(int n) {// 3
if (n == 1) {
return 1;
} else {
return n + getSum(n - 1);
}
}
// 例2：计算1-n之间所有自然数的乘积: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 f(n + 2) - 2 * f(n + 1);
return 2*f(n - 1) + f(n - 2);
}
}
//例4：斐波那契数列
//例5：汉诺塔问题
//例6：快排
}
其三、截图为：
Ⅲ、小结：
其一、哪里有不对或不合适的地方，还请大佬们多多指点和交流！
其二、若有转发或引用本文章内容，请注明本博客地址(直接点击下面 url 跳转) https://blog.csdn.net/weixin_43405300,创作不易，且行且珍惜！
2497
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
