一、面向对象学习内容
package com.atguigu.java; /* * 一、Java面向对象学习的三条主线：（第4-6章） * 1.Java类及类的成员：属性、方法、构造器；代码块、内部类 * * 2.面向对象的三大特征：封装性、继承性、多态性、(抽象性) * * 3.其它关键字：this、super、static、final、abstract、interface、package、import等 * * “大处着眼，小处着手” * * * 二、“人把大象装进冰箱” * * 1.面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做。 * * ① 把冰箱门打开 * ② 抬起大象，塞进冰箱 * ② 把冰箱门关闭 * * 2.面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。 * * 人{ * 打开(冰箱){ * 冰箱.开开(); * } * * 抬起(大象){ * 大象.进入(冰箱); * } * * 关闭(冰箱){ * 冰箱.闭合(); * } * * } * * * 冰箱{ * 开开(){} * 闭合(){} * } * * 大象{ * 进入(冰箱){ * } * } * * 三、面向对象的两个要素： * 类：对一类事物的描述，是抽象的、概念上的定义 * 对象：是实际存在的该类事物的每个个体，因而也称为实例(instance) * >面向对象程序设计的重点是类的设计 * >设计类，就是设计类的成员。 * */ public class OOPTest { }
二、类的设计
package com.atguigu.java; /* * 一、设计类，其实就是设计类的成员 * * 属性 = 成员变量 = field = 域、字段 * 方法 = 成员方法 = 函数 = method * * 创建类的对象 = 类的实例化 = 实例化类 * * 二、类和对象的使用（面向对象思想落地的实现）： * 1.创建类，设计类的成员 * 2.创建类的对象 * 3.通过“对象.属性”或“对象.方法”调用对象的结构 * * 三、如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。（非static的） * 意味着：如果我们修改一个对象的属性a，则不影响另外一个对象属性a的值。 * * 四、对象的内存解析 */ //测试类 public class PersonTest { public static void main(String[] args) { //2. 创建Person类的对象 Person p1 = new Person(); //Scanner scanner = new Scanner(System.in); //调用对象的结构：属性、方法 //调用属性：“对象.属性” p1.name = "Tom"; p1.isMale = true; System.out.println(p1.name); //调用方法：“对象.方法” p1.eat(); p1.sleep(); p1.talk("Chinese"); //******************************* Person p2 = new Person(); System.out.println(p2.name);//null System.out.println(p2.isMale); //******************************* //将p1变量保存的对象地址值赋给p3,导致p1和p3指向了堆空间中的同一个对象实体。 Person p3 = p1; System.out.println(p3.name);//Tom p3.age = 10; System.out.println(p1.age);//10 } } //1.创建类，设计类的成员 class Person{ //属性 String name; int age = 1; boolean isMale; //方法 public void eat(){ System.out.println("人可以吃饭"); } public void sleep(){ System.out.println("人可以睡觉"); } public void talk(String language){ System.out.println("人可以说话,使用的是：" + language); } }
三、类中属性的使用
package com.atguigu.java; /* * 类中属性的使用 * * 属性（成员变量） 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） * 局部变量：加载到栈空间 * */ public class UserTest { public static void main(String[] args) { User u1 = new User(); System.out.println(u1.name); System.out.println(u1.age); System.out.println(u1.isMale); u1.talk("韩语"); u1.eat(); } } class User{ //属性（或成员变量） String name; public int age; boolean isMale; public void talk(String language){//language:形参，也是局部变量 System.out.println("我们使用" + language + "进行交流"); } public void eat(){ String food = "烙饼";//局部变量 System.out.println("北方人喜欢吃：" + food); } }
四、类中方法的声明和使用
package com.atguigu.java; /* * 类中方法的声明和使用 * * 方法：描述类应该具有的功能。 * 比如：Math类：sqrt() andom() ... * Scanner类：nextXxx() ... * Arrays类：sort() binarySearch() toString() equals() ... * * 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.return关键字的使用： * 1.使用范围：使用在方法体中 * 2.作用：① 结束方法 * ② 针对于有返回值类型的方法，使用"return 数据"方法返回所要的数据。 * 3.注意点：return关键字后面不可以声明执行语句。 * * 5. 方法的使用中，可以调用当前类的属性或方法 * 特殊的：方法A中又调用了方法A:递归方法。 * 方法中，不可以定义方法。 */ public class CustomerTest { public static void main(String[] args) { Customer cust1 = new Customer(); cust1.eat(); //测试形参是否需要设置的问题 // int[] arr = new int[]{3,4,5,2,5}; // cust1.sort(); cust1.sleep(8); } } //客户类 class Customer{ //属性 String name; int age; boolean isMale; //方法 public void eat(){ System.out.println("客户吃饭"); return; //return后不可以声明表达式 // System.out.println("hello"); } public void sleep(int hour){ System.out.println("休息了" + hour + "个小时"); eat(); // sleep(10); } public String getName(){ if(age > 18){ return name; }else{ return "Tom"; } } public String getNation(String nation){ String info = "我的国籍是：" + nation; return info; } //体会形参是否需要设置的问题 // public void sort(int[] arr){ // // } // public void sort(){ // int[] arr = new int[]{3,4,5,2,5,63,2,5}; // //。。。。 // } public void info(){ //错误的 // public void swim(){ // // } } }
五、再谈方法
（一）方法的重载（overload）
package com.atguigu.java1; /* * 方法的重载（overload） loading... * * 1.定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。 * * "两同一不同":同一个类、相同方法名 * 参数列表不同：参数个数不同，参数类型不同 * * 2. 举例： * Arrays类中重载的sort() / binarySearch() * * 3.判断是否是重载： * 跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系！ * * 4. 在通过对象调用方法时，如何确定某一个指定的方法： * 方法名 ---> 参数列表 */ public class OverLoadTest { public static void main(String[] args) { OverLoadTest test = new OverLoadTest(); test.getSum(1,2); } //如下的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){ // // } }
（二）可变个数形参的方法
package com.atguigu.java1; /* * 可变个数形参的方法 * * 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){ // // } //The variable argument type String of the method //show must be the last parameter // public void show(String ...strs,int i){ // // } }
（三）方法参数的值传递机制
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); 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; }
package com.atguigu.java1; /* * 方法的形参的传递机制：值传递 * * 1.形参：方法定义时，声明的小括号内的参数 * 实参：方法调用时，实际传递给形参的数据 * * 2.值传递机制： * 如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。 * 如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值。 * */ public class ValueTransferTest1 { public static void main(String[] args) { int m = 10; int n = 20; System.out.println("m = " + m + ", n = " + n); //交换两个变量的值的操作 // int temp = m ; // m = n; // n = temp; ValueTransferTest1 test = new ValueTransferTest1(); test.swap(m, n); System.out.println("m = " + m + ", n = " + n); } public void swap(int m,int n){ int temp = m ; m = n; n = temp; } }
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和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); } public void swap(Data data){ int temp = data.m; data.m = data.n; data.n = temp; } } class Data{ int m; int n; }
（四）递归方法
递归方法：一个方法体内调用它自身。
方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环
//计算1-100之间所有自然数的和 public int sum(int num){ if(num == 1){ return 1; }else{ return num + sum(num - 1); } }