尚硅谷Java入门视频教程第四章——面向对象编程（上）
第4章：面向对象编程（上）
- Java面向对象学习的三条主线：（第4-6章）
- Java类及类的成员：属性、方法、构造器；代码块、内部类
- 面向对象的三大特征：封装性、继承性、多态性、(抽象性)
- 其它关键字：this、super、static、final、abstract、interface、package、import等
4.1 面向过程与面向对象
- 面向过程(POP) 与 面向对象(OOP)
- 面向对象：Object Oriented Programming
面向过程：Procedure Oriented Programming - 二者都是一种思想，面向对象是相对于面向过程而言的。面向过程，强调的是功能行为，以函数为最小单位，考虑怎么做。面向对象，将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
- 面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，如抽象、分类、继承、聚合、多态等。
- 面向对象：Object Oriented Programming
- 面向对象的三大特征
- 封装 (Encapsulation)
- 继承 (Inheritance)
- 多态 (Polymorphism)
- 面向对象的思想概述
- 程序员从面向过程的执行者转化成了面向对象的指挥者
- 面向对象分析方法分析问题的思路和步骤：
- 根据问题需要，选择问题所针对的现实世界中的实体。
- 从实体中寻找解决问题相关的属性和功能，这些属性和功能就形成了概念世界中的类。
- 把抽象的实体用计算机语言进行描述，形成计算机世界中类的定义。即借助某种程序语言，把类构造成计算机能够识别和处理的数据结构。
- 将类实例化成计算机世界中的对象。对象是计算机世界中解决问题的最终工具。
4.2 Java语言的基本元素：类和对象
- 类(Class)和对象(Object)是面向对象的核心概念。
- 类：对一类事物的描述，是抽象的、概念上的定义
- 对象：实际存在的该类事物的每个个体，因而也称为实例(instance)。
可以理解为：类 = 抽象概念的人；对象 = 实实在在的某个人 - 面向对象程序设计的重点是类的设计
- 类的设计，其实就是类的成员的设计
- Java类的成员构成
4.3 对象和创建和使用
- 设计类，其实就是设计类的成员
属性 = 成员变量 = field = 域、字段
方法 = 成员方法 = 函数 = method
创建类的对象 = 类的实例化 = 实例化类 - 类和对象的使用（面向对象思想落地的实现）：
- 创建类，设计类的成员
- 创建类的对象
- 通过“对象.属性”或“对象.方法”调用对象的结构
- 如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。（非static的）
意味着：如果我们修改一个对象的属性a，则不影响另外一个对象属性a的值。
public class PersonTest {
public static void main(String[] args) {
//创建Person类的对象
Person p1 = new Person();
//Scanner scan = 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);//false
//*******************************
//将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);
}
}
- 内存解析
内存解析：
4.4 类的成员之一：属性(field)
- 属性（成员变量） VS 局部变量
- 相同点：
- 定义变量的格式：数据类型 变量名 = 变量值
- 先声明，后使用
- 变量都有其对应的作用域
- 不同点：
- 在类中声明的位置的不同
- 属性：直接定义在类的一对{}内
- 局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
- 关于权限修饰符的不同
- 属性：可以在声明属性时，指明其权限，使用权限修饰符。
常用的权限修饰符：private、public、缺省、protected —>封装性
目前，大家声明属性时，都使用缺省就可以了。 - 局部变量：不可以使用权限修饰符。
- 属性：可以在声明属性时，指明其权限，使用权限修饰符。
- 默认初始化值的情况
- 属性：类的属性，根据其类型，都有默认初始化值。
整型（byte、short、int、long）：0
浮点型（float、double）：0.0
字符型（char）：0 （或’\u0000’）
布尔型（boolean）：false
引用数据类型（类、数组、接口）：null - 局部变量：没有默认初始化值。
意味着，我们在调用局部变量之前，一定要显式赋值。
特别地：形参在调用时，我们赋值即可。
- 属性：类的属性，根据其类型，都有默认初始化值。
- 在内存中加载的位置
- 属性：加载到堆空间中 （非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);
}
}
4.5 类的成员之二：方法（method）
- 类中方法的声明和使用
方法：描述类应该具有的功能。
比如：Math类：sqrt()\random() …
Scanner类：nextXxx() …
Arrays类：sort() \ binarySearch() \ toString() \ equals() \ …
-
举例：
public void eat(){}
public void sleep(int hour){}
public String getName(){}
public String getNation(String nation){} -
方法的声明：
权限修饰符 返回值类型 方法名(形参列表){
方法体
}
注意：static、final、abstract 来修饰的方法，后面再讲。 -
说明：
-
关于权限修饰符：默认方法的权限修饰符先都使用public
Java规定的4种权限修饰符：private、public、缺省、protected -->封装性再细说 -
返回值类型： 有返回值 vs 没有返回值
-
如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用
return关键字来返回指定类型的变量或常量：“return 数据”。
如果方法没有返回值，则方法声明时，使用void来表示。通常，没有返回值的方法中，就不需要
使用return.但是，如果使用的话，只能“return;”表示结束此方法的意思。 -
我们定义方法该不该有返回值？
① 题目要求
② 凭经验：具体问题具体分析
-
-
方法名：属于标识符，遵循标识符的规则和规范，“见名知意”
-
形参列表： 方法可以声明0个，1个，或多个形参。
3.4.1 格式：数据类型1 形参1,数据类型2 形参2,…3.4.2 我们定义方法时，该不该定义形参？
① 题目要求
② 凭经验：具体问题具体分析 -
方法体：方法功能的体现。
-
-
return关键字的使用：
- 使用范围：使用在方法体中
- 作用：① 结束方法
② 针对于有返回值类型的方法，使用"return 数据"方法返回所要的数据。 - 注意点：return关键字后面不可以声明执行语句。
-
方法的使用中，可以调用当前类的属性或方法
特殊的：方法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(){
//
// }
}
}
- 练习
-
利用面向对象的编程方法，设计类Circle计算圆的面积。
//测试类 public class CircleTest { public static void main(String[] args) { Circle c1 = new Circle(); c1.radius = 2.1; //对应方式一： // double area = c1.findArea(); // System.out.println(area); //对应方式二： c1.findArea(); //错误的调用 // double area = c1.findArea(3.4); // System.out.println(area); } } //圆 class Circle{ //属性 double radius; //求圆的面积 //方式一： // public double findArea(){ // double area = Math.PI * radius * radius; // return area; // } //方式二： public void findArea(){ double area = Math.PI * radius * radius; System.out.println("面积为：" + area); } //错误情况： // public double findArea(double r){ // double area = 3.14 * r * r; // return area; // } // } -
对象数组题目：
定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩score(int)。 创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。
问题一：打印出3年级(state值为3）的学生信息。
问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
提示：
① 生成随机数：Math.random()，返回值类型double;
② 四舍五入取整：Math.round(double d)，返回值类型long。//测试类 public class StudentTest1 { public static void main(String[] args) { //声明Student类型的数组 Student1[] stus = new Student1[20]; for(int i = 0; i < stus.length;i++) { //数组元素赋值 stus[i] = new Student1(); //数组元素的属性赋值（Student对象的属性赋值） stus[i].number = i + 1; //年级：[1, 6] stus[i].state = (int)(Math.random() * (6 - 1 + 1) + 1); //成绩：[0, 100] stus[i].score = (int)(Math.random() * (100 - 0 + 1) + 0); } StudentTest1 test = new StudentTest1(); //遍历Students1数组 test.print(stus); System.out.println("*****************************"); //问题一：打印出3年级(state值为3）的学生信息。 test.searchState(stus, 3); System.out.println("*****************************"); //问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息 test.sort(stus); test.print(stus); } /** * * @Description 遍历Student1[]数组的操作 * @author WenYi * @date 2022年4月6日下午8:05:02 * @param stus */ public void print(Student1[] stus) { for(int i = 0;i < stus.length;i++) { System.out.println(stus[i].info()); } } /** * * @Description 查找Stduent数组中指定年级的学生信息 * @author WenYi * @date 2022年4月6日下午8:05:24 * @param stus 要查找的数组 * @param state 要查找的年级 */ public void searchState(Student1[] stus, int state) { for(int i = 0;i < stus.length;i++) { if(stus[i].state == state) { System.out.println(stus[i].info()); } } } /** * * @Description 给Student1数组排序 * @author WenYi * @date 2022年4月6日下午8:05:47 * @param stus */ public void sort(Student1[] stus) { for(int i = 0;i < stus.length - 1;i++) { for(int j = 0;j < stus.length - 1 - i;j++) { if(stus[j].score > stus[j+1].score) { //如果需要换序，交换的是数组的元素：Student对象！！！不是数组对象的属性 Student1 temp = stus[j]; stus[j] = stus[j+1]; stus[j+1] = temp; } } } } } class Student1{ int number;//学号 int state;//年级 int score;//成绩 public String info() { return "学号：" + number + ",年级：" + state + ",成绩：" + score; } }对象数组的内存解析：引用类型的变量，只可能存储两类值：null 或 地址值（含变量的类型）
-
理解“万事万物皆对象”
“万事万物皆对象”的理解：
- 在Java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构
- Scanner,String等
- 文件：File
- 网络资源：URL
- 涉及到Java语言与前端Html、后端的数据库交互时，前后端的结构在Java层面交互时，都体现为类、对象。
匿名对象
- 理解：我们创建的对象，没有显式的赋给一个变量名。即为匿名对象
- 特征：匿名对象只能调用一次。
- 使用：
public class InstanceTest {
public static void main(String[] args) {
Phone p = new Phone();
System.out.println(p);
//同一对象的多次调用
p.sendEmail();
p.playGame();
// 匿名对象：每次调用都是new一个新对象，对象之间不相关
// new Phone().sendEmail();
// new Phone().playGame();
new Phone().price = 1999;
new Phone().showPrice();// 0.0
// **********************************
PhoneMall mall = new PhoneMall();
// mall.show(p);
// 匿名对象的使用：直接作为方法的参数——相当于new一个对象后赋值给一个局部变量，可多次调用
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);
}
}
4.6 再谈方法
4.6.1 方法的重载
-
重载的概念：
在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。与方法返回值类型、参数名等无关。
“两同一不同” ：
同一个类、相同方法名
参数列表不同：参数个数不同，参数类型不同 -
重载的特点：
与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类型)。调用时，根据方法参数列表的不同来区别。 -
重载示例：
//返回两个整数的和
int add(int x,int y){return x+y;}
//返回三个整数的和
int add(int x,int y,int z){return x+y+z;}
//返回两个小数的和
double add(double x,double y){return x+y;}Arrays类中重载的sort() / binarySearch()
-
判断是否是重载：
跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系！ -
在通过对象调用方法时，如何确定某一个指定的方法：
方法名 —> 参数列表
public class OverLoadTest {
public static void main(String[] args) {
OverLoadTest test = new OverLoadTest();
test.getSum(1,2);//当第一个getSum方法不存在时，会输出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){
//
// }
}
4.6.2 可变形参的方法
- 定义：
JavaSE 5.0 中提供了Varargs(variable number of arguments)机制，允许直接定义能和多个实参相匹配的形参。从而，可以用一种更简单的方式，来传递个数可变的实参。= - 说明：
- jdk 5.0新增的内容
- 具体使用：
- 可变个数形参的格式：数据类型 … 变量名
- 当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个,2个，…
- 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
- 可变个数形参的方法与本类中方法名相同且形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。
- 可变个数形参在方法的形参中，必须声明在末尾。
- 可变个数形参在方法的形参中,最多只能声明一个可变形参。
- 遇到方法重载的情况怎么办呢？会优先匹配固定参数还是可变参数的方法呢？
答案是会优先匹配固定参数的方法，因为固定参数的方法匹配度更高。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){ // // } }
4.6.3 方法参数的值传递机制（重点）
-
形参：方法定义时，声明的小括号内的参数
实参：方法调用时，实际传递给形参的数据 -
关于变量的赋值：
如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。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; } -
Java里方法的参数传递方式：值传递机制
Java里方法的参数传递方式只有一种：值传递。 即将实际参数值的副本（复制品）传入方法内，而实际参数本身不受影响。
如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。
如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值。
值传递机制的理解：
- Tese Case1: 传递基本类型参数
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();//mian方法有static关键字，在其中调用类中其他方法需要先创建对象
test.swap(m, n);
System.out.println("m = " + m + ", n = " + n);//m = 10, n = 20
}
public void swap(int m,int n){
int temp = m ;
m = n;
n = temp;
}
}
执行结果：
原因分析：
在执行swap()方法后,m和n并未交换成功。
在执行main方法时，首先将main方法中定义的mn入栈，m的值为10，n的值为20。然后定义一个新的ValueTransferTest1类，名为test，test也入栈，同时在堆中产生一个新的对象。然后执行test的swap方法，此方法中将main中定义的m与n作为实参传递给swap方法的形参mn，此时，swap方法产生新的不同于main方法中的局部变量mn，同时，将main方法的mn的值传递给新的mn，main中mn为基本类型的变量，值为10与20，因此传递给swap中mn的值也为10和20。然后定义temp变量并交换swap中定义的mn的值。swap方法执行完毕后，swap方法中定义的temp、n、m依次出栈。此时，并未改变main方法中定义的m、n。
- Tese Case2: 传递引用类型参数
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();//mian方法有static关键字，在其中调用类中其他方法需要先创建对象
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;
}
执行结果：
原因分析：
在执行swap()方法后,data的属性m和n交换成功。
在执行main方法时，首先在对中创建一个Data类型的对象，其中属性mn均为初始化值0，并将其首地址值传递给main中定义的data变量。通过data对象调用属性对mn的值进行修改为10和20。然后执行swap方法，此方法中将main中定义的data作为实参传递给swap方法的形参data，此时，swap方法产生新的不同于main方法中的局部变量data，同时，将main方法的data的值传递给新的data，main中data为引用类型的变量，其值为堆中的对象的地址值，因此传递给swap方法中的data的值也是一个地址值。然后定义temp变量并通过地址交换swap中定义的data的属性mn的值。swap方法执行完毕后，swap方法中定义的temp、data依次出栈。但此时，堆中对象的mn已经通过地址被修改过，因此交换成功。
-
例题1：通过swap方法交换数组中的两个元素：
错误的 ：
swap方法的参数为基本类型，传入的实参是将arr[j]与arr[j + 1]的实际的值传递给形参，因此交换的只是swap中定义的两个变量值，对方法外的没有影响。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]) { //错误的： swap(arr[j],arr[j + 1]);//方法没有static关键字，可以直接调用其他方法，无需创建对象通过对象调用 } } } } //错误的：交换数组中指定两个位置元素的值 public void swap(int i,int j){ int temp = i; i = j; j = temp; }正确的：
swap方法的参数包含引用类型，传入的实参是将arr存储的数组的地址值以及下标j与j + 1传递给形参，因此交换时会通过地址值修改堆中的对象，可以成功交换。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]) { //正确的： swap(arr,j,j + 1);//方法没有static关键字，可以直接调用其他方法，无需创建对象通过对象调用 } } } } //正确的：交换数组中指定两个位置元素的值 public void swap(int[] arr,int i,int j){ int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } -
例题2：推测输出结果（见代码）
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);//20 } public void second(Value v, int i) { i = 0; v.i = 20; Value val = new Value(); v = val; System.out.println(v.i + " " + i);//15 0 } } class Value { int i = 15; }执行结果：
内存解析：
-
例题3：需要在method方法被调用之后，仅打印出a=100,b=200,请写出method方法的代码
直接在方法内对参数a和b的值进行修改并不会影响实际参数的值。
解法1：中途退出程序
直接在method方法内进行输出，输出完毕后直接退出程序，不再执行main方法中的两个输出。public class exer3 { 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=" + a); System.out.println("b=" + b); System.exit(0);//退出程序 } }解法2：重写打印流
import java.io.PrintStream; public class exer3 { 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) { 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); } } -
例题4：定义一个int型的数组：int[] arr = new int[]{12,3,3,34,56,77,432};
让数组的每个位置上的值去除以首位置的元素，得到的结果，作为该位置上的新值。遍历新的数组。错误写法：
public class exer4 { public static void main(String[] args) { int[] arr = new int[] {12, 3, 3, 34, 56, 77, 432}; //错误写法 for(int i= 0;i < arr.length;i++){ arr[i] = arr[i] / arr[0]; } //遍历输出 for(int i = 0;i < arr.length;i++) { System.out.print(arr[i] + "\t");//1 3 3 34 56 77 432 } } }从头到尾遍历时，第一个元素会被改变，再向后遍历时，除的数字已经改变，因此应当从后往前遍历。
正确写法1：倒序遍历public class exer4 { public static void main(String[] args) { 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]; } //遍历输出 for(int i = 0;i < arr.length;i++) { System.out.print(arr[i] + "\t");//1 0 0 2 4 6 36 } } }正确写法2：临时变量
public class exer4 { public static void main(String[] args) { int[] arr = new int[] {12, 3, 3, 34, 56, 77, 432}; //正确写法2： int temp = arr[0]; for(int i= 0;i < arr.length;i++){ arr[i] = arr[i] / temp; } //遍历输出 for(int i = 0;i < arr.length;i++) { System.out.print(arr[i] + "\t");//1 0 0 2 4 6 36 } } } -
例题5：
public class exec { public static void main(String[] args) { int[] arr = new int[] {1, 2, 3}; System.out.println(arr);//地址值：[I@3d012ddd char[] arr1 = new char[] {'a', 'b', 'c'}; System.out.println(arr1); //abc } }使用System.out.println()打印输出时，当参数为int型数组时，调用的方法为 java.io.PrintStream.println(Object x)，其功能为打印地址值；而当参数为char型数组时，调用的方法为 java.io.PrintStream.println(char[] x)，其功能会将字符数组输出。
-
例题6：
（1）定义一个Circle类，包含一个double型的radius属性代表圆的半径，一个findArea()方法返回圆的面积。
（2）定义一个类PassObject，在类中定义一个方法printAreas()，该方法的定义如下：public void printAreas(Circle c, int time)
在printAreas方法中打印输出1到time之间的每个整数半径值，以及对应的面积。例如，times为5，则输出半径1，2，3，4，5，以及对应的圆面积。
（3）在main方法中调用printAreas()方法，调用完毕后输出当前半径值。程序运行结果如图所示：
首先在同一个包下创建两个类，Circle与PassObject。
Circle类内容如下：package com.atguigu.exer1; public class Circle { double radius; public double findArea() { return Math.PI * radius * radius; } }PassObjec类内容如下：
package com.atguigu.exer1; public class PassObject { public static void main(String[] args) { Circle c = new Circle(); int time = 5; PassObject po = new PassObject(); po.printAreas(c, time); System.out.println(); System.out.println("now radius is:" + c.radius); } public void printAreas(Circle c, int time) { System.out.println("Radius\t\tArea"); for(int i = 1;i <= time;i++) { c.radius = i; System.out.println(c.radius + "\t\t" + c.findArea()); } c.radius += 1; } }最终执行结果如下：
4.6.4 递归方法
- 递归方法：一个方法体内调用它自身。
- 方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
- 递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。
- 例题1：
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);
// 方式二：
RecursionTest test = new RecursionTest();
int sum1 = test.getSum(100);
System.out.println(sum1);
System.out.println("*****************");
int value = test.f(10);
System.out.println(value);
}
// 例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 2*f(n+1) + f(n);//错误的，n+2->n,n+1->n-1,n->n-2
return 2*f(n - 1) + f(n - 2);
}
}
//例4：斐波那契数列
//例5：汉诺塔问题
//例6：快排
}
4.7 面向对象特征之一：封装与隐藏
- 程序设计追求“高内聚，低耦合”。
高内聚 ：类的内部数据操作细节自己完成，不允许外部干涉；
低耦合 ：仅对外暴露少量的方法用于使用。 - 封装性的设计思想：
隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。
3W:what? why? how?
-
问题的引入：
当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。这里，赋值操作要受到属性的数据类型和存储范围的制约。除此之外，没有其他制约条件。但是，在实际问题中，我们往往需要给属性赋值加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加，（比如：setLegs()）。同时，我们需要避免用户再使用"对象.属性"的方式对属性进行赋值。则需要将属性声明为私有的(private).
–>此时，针对于属性就体现了封装性。 -
封装性的体现一：
我们将类的属性xxx私有化(private),同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值拓展：封装性的体现：① 如上 ② 不对外暴露的私有的方法 ③ 单例模式 …
public class AnimalTest { public static void main(String[] args) { Animal a = new Animal(); a.name = "大黄"; // a.age = 1; // a.legs = 4;//The field Animal.legs is not visible a.show(); // a.legs = -4; // a.setLegs(6); a.setLegs(-6); // a.legs = -4;//The field Animal.legs is not visible a.show(); System.out.println(a.name); } } class Animal{ String name; private int age; private int legs;//腿的个数 //对属性的设置 public void setLegs(int l){ if(l >= 0 && l % 2 == 0){ legs = l; }else{ legs = 0; // 抛出一个异常（暂时没有讲） } } //对属性的获取 public int getLegs(){ return legs; } public void eat(){ System.out.println("动物进食"); } public void show(){ System.out.println("name = " + name + ",age = " + age + ",legs = " + legs); } //提供关于属性age的get和set方法 public int getAge(){ return age; } public void setAge(int a){ age = a; } }权限修饰符
- 封装性的体现，需要权限修饰符来配合。
- Java规定的4种权限（从小到大排列）：private、缺省、protected 、public
- 4种权限可以用来修饰类及类的内部结构：属性、方法、构造器、内部类
- 具体的，4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类
修饰类的话，只能使用：缺省、public
总结权限修饰符封装性：Java提供了4种权限修饰符来修饰类及类的内部结构，体现类及类的内部结构在被调用时的可见性的大小。
-
封装性的体现二：不对外暴露的私有方法
-
封装性的体现三：单例模式（将构造器私有化）
-
封装性的体现四：如果不希望类在包外被调用，可以将类设置为缺省的
4.8 类的成员之三：构造器(或构造方法)
construct：建设、建造。 construction:CCB constructor:建设者
- 构造器的作用：
- 创建对象
- 初始化对象的信息
- 说明：
- 如果没有显式的定义类的构造器的话，则系统默认提供一个空参的构造器
- 定义构造器的格式：权限修饰符 类名(形参列表){}
- 一个类中定义的多个构造器，彼此构成重载
- 一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器
- 一个类中，至少会有一个构造器。
public class PersonTest {
public static void main(String[] args) {
//创建类的对象:new + 构造器
Person p = new Person();//Person().....
p.eat();//人吃饭
Person p1 = new Person("Tom");
System.out.println(p1.name);//Tom
}
}
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("人可以学习");
}
}
- 例题：
- .编写两个类，TriAngle和TriAngleTest，其中TriAngle类中声明私有的底边长base和高height，同时声明公共方法访问私有变量。此外，提供类必要的构造器。另一个类中使用这些公共方法，计算三角形的面积。
TriAngle.java:
TaiAngleTest.javapackage com.atguigu.exer; public class Triangle { //属性 private double base; private double height; //构造器 public Triangle() { } public Triangle(double b,double h) { base = b; height = h; } //方法 public void setBase(double b) { if (b > 0) { base = b; }else { System.out.println("边长应该是正数！"); } } public double getBase() { return base; } public void setHeight(double h) { if (h > 0) { height = h; }else { System.out.println("高度应该是正数！"); } } public double getHeight() { return height; } }package com.atguigu.exer; public class TriangleTest { public static void main(String[] args) { Triangle t1 = new Triangle(); t1.setBase(2); t1.setHeight(2.4); System.out.println("base:" + t1.getBase() +", height:" + t1.getHeight()); double area1 = (t1.getBase()*t1.getHeight())/2; System.out.println("area:" + area1); Triangle t2 = new Triangle(5, 5.4); System.out.println("base:" + t2.getBase() +", height:" + t2.getHeight()); double area2 = (t2.getBase()*t2.getHeight())/2; System.out.println("area:" + area2); } }
- .编写两个类，TriAngle和TriAngleTest，其中TriAngle类中声明私有的底边长base和高height，同时声明公共方法访问私有变量。此外，提供类必要的构造器。另一个类中使用这些公共方法，计算三角形的面积。
总结：属性赋值过程
- 赋值的位置：
① 默认初始化
② 显式初始化
③ 构造器中初始化
④ 通过“对象.属性“或“对象.方法”的方式赋值 - 赋值的先后顺序：
①默认初始化 - ②显式初始化 - ③构造器中初始化 - ④通过“对象.属性“或“对象.方法”的方式赋值
扩展
- JavaBean：
- JavaBean是一种Java语言写成的可重用组件。
- 所谓javaBean，是指符合如下标准的Java类：
- 类是公共的
- 有一个无参的公共的构造器
- 有属性，且有对应的get、set方法
- 用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用Java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关心任何改变
- UML类图：
4.9 关键字：this的使用
- this关键字的使用：
-
this可以用来修饰、调用：属性、方法、构造器
-
this修饰属性和方法：
this理解为：当前对象 或 当前正在创建的对象- 在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象属性或方法。但是，通常情况下，我们都选择省略"this."。特殊情况下，如果方法的形参和类的属性同名时，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。
- 在类的构造器中，我们可以使用"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("人学习");
}
}
综合练习
Account.java
package com.atguigu.exer4;
public class Account {
private double balance;
public Account(double init_balance) {
//初始化账户余额
this.balance = init_balance;
}
public double getBalance() {
return this.balance;
}
//存钱
public void deposit(double amt) {
if(amt > 0){
balance += amt;
System.out.println("存钱成功");
}
}
//取钱
public void withdraw(double amt) {
if(balance >= amt) {
balance -= amt;
System.out.println("取钱成功");
}else {
System.out.println("余额不足");
}
}
}
Customer.java
package com.atguigu.exer4;
public class Customer {
private String firstName;
private String lastName;
private Account account;
public Customer(String f, String l) {
this.firstName = f;
this.lastName = l;
}
public Account getAccount() {
return account;
}
public void setAccount(Account account) {
this.account = account;
}
public String getFirstName() {
return firstName;
}
public String getLastName() {
return lastName;
}
}
Bank.java
package com.atguigu.exer4;
public class Bank {
private Customer[] customers;//存放多个客户的数组
private int numberOfCustomers;//记录客户的个数
public Bank(){
customers = new Customer[10];
}
//添加客户
public void addCustomer(String f, String l) {
Customer cust = new Customer(f, l);
//customers[numberOfCustomer] = cust;
//numberOfCustomer++;
customers[numberOfCustomers++] = cust;
}
//获取客户个数
public int getNumberOfCustomers() {
return numberOfCustomers;
}
//获取指定位置上的客户
public Customer getCustomer(int index) {
if(index < numberOfCustomers) {
return customers[index];
}
return null;
}
}
BankTest.java
package com.atguigu.exer4;
public class BankTest {
public static void main(String[] args) {
Bank bank = new Bank();
//创建新的客户
bank.addCustomer("Jane", "Smith");
//为此客开通账户，账户上初始余额2000
bank.getCustomer(0).setAccount(new Account(2000));
//从此客户的账户上取出500
bank.getCustomer(0).getAccount().withdraw(500);
//此客户当前账户余额
double balance = bank.getCustomer(0).getAccount().getBalance();
//打印当前客户相关信息
System.out.println("客户：" + bank.getCustomer(0).getFirstName() + "的账户余额为：" + balance);
System.out.println("***********************");
bank.addCustomer("万里", "杨");
System.out.println("银行客户的个数为：" + bank.getNumberOfCustomers());
}
}
4.10 关键字：package、import的使用
4.10.1 package关键字的使用
- package关键字的使用
- 为了更好的实现项目中类的管理，提供包的概念
- 使用package声明类或接口所属的包，声明在源文件的首行
- 包，属于标识符，遵循标识符的命名规则、规范(xxxyyyzzz)、“见名知意”
- 每"."一次，就代表一层文件目录。
- 补充：
同一个包下，不能命名同名的接口、类。
不同的包下，可以命名同名的接口、类。
- JDK中主要的包介绍:
- java.lang----包含一些Java语言的核心类，如String、Math、Integer、 System和Thread，提供常用功能
- java.net----包含执行与网络相关的操作的类和接口。
- java.io ----包含能提供多种输入/输出功能的类。
- java.util----包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日期日历相关的函数。
- java.text----包含了一些java格式化相关的类
- java.sql----包含了java进行JDBC数据库编程的相关类/接口
- java.awt----包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。 B/S C/S
MVC设计模式
4.10.2 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.Math.round;
import static java.lang.System.out;
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);
}
}
扫一扫
757
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
