写在前面，Java基础系列文章都是作者基于b站尚硅谷的Java基础视频所做的笔记，没有时间的同学可以认真看看，如果有时间的同学，还是建议看看视频，毕竟笔记说到底还是自己的东西，每个人的习惯也是不一样的，所以为了自己，学就对了，加油！
也请各位同学，如果感觉对自己有帮助，可以帮忙给个一键三连，谢谢！

文章目录

1.Java面向对象学习的三条主线
2.Java语言的基本元素：类和对象
- 2.1 类和对象的创建与使用（面向对象思想落地的实现）
- 2.2 内存解析
3.类的成员之一：属性（field）
- 3.1 语法格式
- 3.2 变量的分类：成员变量与局部变量
- 3.3 成员变量（属性）和局部变量的区别？
- 3.4 成员变量与局部变量的内存位置
4.类的成员之二：方法(method)
- 4.1 对象数组的内存解析
- 4.2 匿名对象的使用
- 4.3 自定义数组的工具类
- 4.4 方法的重载
- 4.5 可变个数的形参
- 4.6 方法参数的值传递机制(重点)
- 4.7 递归
5.面向对象的特征之一：封装与隐藏
- 5.1 四种权限修饰符
6.类的成员之三：构造器(或构造方法)
- 6.1 总结：属性赋值的先后顺序
- 6.2 JavaBean的使用
- 6.3 UML 类图
7.关键字的使用
- 7.1 关键字：this 的使用
- 7.2 关键字：package 的使用
- 7.3 MVC设计模式
- 7.4 import 的使用

面向对象与面向过程的本质区别

作为面向对象的思维来说，当你拿到一个问题时，你分析这个问题不再是第一步先做什么，第二步再做什么，这是面向过程的思维，你应该分析这个问题里面有哪些类和对象，这是第一点，然后再分析这些类和对象应该具有哪些属性和方法。这是第二点。最后分析类和类之间具体有什么关系，这是第三点。

面向对象有一个非常重要的设计思维：合适的方法应该出现在合适的类里面。

1.Java面向对象学习的三条主线

/** 一、Java面向对象学习的三条主线:* 1.Java类及类的成员：属性、方法、构造器、代码块、内部类* 2.面向对象的三大特征：封装性、继承性、多态性、(如果说有四个，那就可以再增加一个抽象性)* 3.其它关键字：this、super、static、final、abstract、interface、package、import* * 二、面向过程和面向对象的理解* * 举例："人把大象装进冰箱"* 1.面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做* ①把冰箱门打开* ②抬起大象，塞进冰箱* ③把冰箱门关闭* * 2.面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。* 人{*      打开(冰箱){*            冰箱.开开();*       }* *        抬起(大象){*            大象.进入(冰箱);*         }* *        关闭(冰箱){*            冰箱.闭合();*       }* * }* * 冰箱{*      打开(){}*         闭合(){}* }* * 大象{*       进入(冰箱){*        }* }* * 三、面向对象的两个要素：* 类：类是对一类事物的描述，是抽象的、概念上的定义* 对象：对象是实际存在的该类事物的每个个体，因而也称为实例(instance)* > 面向对象程序设计的重点是类的设计* > 设计类，就是设计类的成员* */

2.Java语言的基本元素：类和对象

2.1 类和对象的创建与使用（面向对象思想落地的实现）

/** 一、设计类，其实就是设计类的成员* *   属性 = 成员变量 = field = 域、字段*    方法 = 成员方法 = 函数 = method* *   创建类的对象 = 类的实例化 = 实例化类* * 二、类和对象的使用（面向对象思想落地的实现）* 1.创建类，设计类的成员* 2.创建类的对象* 3.通过"对象.属性"或"对象.方法"调用对象的结构* * 三、如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。（非static）*         意味着：如果我们修改一个对象的属性a，则不影响另外一个对象的属性a的值* * 四、对象的内存解析*     */
//测试类
public class PersonTest {public static void main(String[] args) {//2.创建Person类的对象Person p1 = new Person();//调用对象的结构：属性、方法//调用属性："对象.属性"p1.name = "Tom";p1.isMale = true;System.out.println(p1.name);//调用方法："对象.方法"p1.eat();p1.sleep();p1.talk("C语言");//**************************************Person p2 = new Person();System.out.println(p2.name); //nullSystem.out.println(p2.isMale); //false//**************************************//将p1变量保存的对象地址值 赋给 p3，导致p1和p3指向了堆空间中的同一个对象实体Person p3 = p1;System.out.println(p3.name);//Tomp3.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);}}

2.2 内存解析

堆（Heap），此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存 。这一点在 Java 虚拟机规范中的描述是：所有的对象实例以及数组都要在堆上分配。
通常所说的栈（Stack），是指虚拟机栈。虚拟机栈用于存储局部变量等。局部变量表存放了编译期可知长度的各种基本数据类型（boolean、byte 、 char 、 short 、 int 、 float 、 long 、 double)，对象引用（ reference 类型，它不等同于对象本身，是对象在堆内存的首地址）。方法执行完，自动释放。
方法区（Method Area），用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。

案例1

Person p1= new Person();
p1.name = "Tom";
p1.isMale = true;
Person p2 = new Person();
sysout(p2.name); //null
Person p3 = p1;
p3.age = 10;

案例2

Person p1= new Person();
p1.name = "胡利民";
p1.age = 23;
Person p2 = new Person();
p2.age = 10;

3.类的成员之一：属性（field）

3.1 语法格式

/*
语法格式：
修饰符  数据类型  属性名 = 初始化值;1.说明1: 修饰符
1.1常用的权限修饰符有：private、缺省、protected、public
1.2其他修饰符：static、final (暂不考虑)
2.说明2：数据类型
2.1任何基本数据类型(如int、Boolean) 或 任何引用数据类型。
3.说明3：属性名
3.1属于标识符，符合命名规则和规范即可。
*/

3.2 变量的分类：成员变量与局部变量

在方法体外，类体内声明的变量称为成员变量。
在方法体内部声明的变量称为局部变量。

3.3 成员变量（属性）和局部变量的区别？

	成员变量	局部变量
声明的位置	直接声明在类中	方法形参或内部、代码块内、构造器内等
修饰符	private、public、static、final等	`不能用权限修饰符修饰，可以用final修饰`
初始化值	`有默认初始化值`	没有默认初始化值，`必须显式赋值`，方可使用
内存加载位置	堆空间或静态域内	栈空间

/** 类中属性的使用* * 属性（成员变量） VS 局部变量* 1.相同点：*        1.1 定义变量的格式：数据类型 变量名 = 变量值*         1.2 先声明，后使用*         1.3 变量都有其对应的作用域*        1.4 都有生命周期* * 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* *      局部变量：没有默认初始化值*           意味着我们在调用使用局部变量之前，一定要显式赋值*            特别的：形参在调用时，我们再赋值即可。例：47行，59行*       *       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.eat();u1.talk("英语");}}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);}}

练习

要求：

编写教师类和学生类，并通过测试类创建对象进行测试
Student类
属性:
name:String  age:int  major:String  interests:String
方法:say() 返回学生的个人信息Teacher类
属性:
name:String  age:int  teachAge:int  course:String
方法:say() 输出教师的个人信息

代码测试：

public class School {public static void main(String[] args) {Student stu = new Student();stu.name = "小明";stu.age = 20;Teacher tea = new Teacher();tea.name = "王老师";tea.age = 25;tea.say(stu.name,stu.age);stu.say(tea.name, tea.age);}
}class Student{String name;int age;String major;String interests;void say(String name, int age){System.out.println("这个学生是："+name+"年龄是："+age);  }
}class Teacher{String name;int age;String teachAge;String course;void say(String name, int age){System.out.println("这个老师是："+name+"年龄是："+age);}
}

3.4 成员变量与局部变量的内存位置

//人类
class Person{//1.属性 String name;  //姓名 int age = 1;  //年龄 boolean isMale;  //是否是男性public void show(String nation){ //nation:局部变量String color; //color:局部变量color = "yellow"; }}//测试类
class PersonTest {public static void main(String[] args) {Person p = new Person();p.show("USA");}
}

4.类的成员之二：方法(method)

/** 类中方法的声明和使用* * 方法：描述类应该具有的功能。* 比如：Math类：sqrt() \ random() \ ...*      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关于权限修饰符：*             Java规定的四种权限修饰符：private、public、缺省(default)、protected* *       3.2返回值类型：有返回值  VS  没有返回值*            3.2.1如果方法有返回值，则必须在方法声明时，指定返回值的类型。*                    同时，方法中需要使用return关键字来返回指定类型的变量或常量 *                如果方法没有返回值，则方法声明时，使用void来表示。*                     通常，没有返回值的方法，就不需要使用return。*                    但是如果需要使用的话，只能用"return;"，表示结束此方法的意思*         *       3.3方法名：属于标识符，遵循标识符的规则和规范，"见名知意"* *       3.4形参列表：方法可以声明0个，1个，或者多个形参*            3.4.1 格式：数据类型1 形参1，数据类型2 形参2，...*          *       3.5方法体：方法功能的体现* *    4.return关键字的使用：*             1.使用范围：使用在方法体中*          2.作用：①结束方法*                     ②针对于有返回值类型的方法，使用"return 数据"方法返回所需要的数据*          3.注意点：return关键字后面不可以再声明执行语句*     *  5.方法中：可以调用当前类的属性或方法，但是不可以定义其他方法*   特殊的：方法A中又调用了方法A：递归方法             */
public class CustomerTest {public static void main(String[] args) {Customer cust = new Customer();cust.eat();cust.sleep(8);}}class Customer{//属性String name;int age;boolean isMale;//方法public void eat() {System.out.println("客户吃饭");}public void sleep(int hour) {System.out.println("休息了" + hour + "个小时");eat();}public String getName() {if(age > 18) {return name;}else {return "Tom";}}public String getNation(String nation) {String info = "我的国籍是" + nation;return info;}}

练习

public class Person {String name;int age;/*** sex:1 表明是男性* sex:0 表明是女性*/int sex;public void study() {System.out.println("studying");}public void showAge() {System.out.println("age: " + age);}public int addAge(int i) {age += i;return age;}}

/** 要求：(1)创建Person类的对象，设置该对象的 name、age和sex属性，*      调用study方法，输出字符串 “studying”，调用showAge()方法显示age值，*      调用 addAge()方法给对象的age属性值增加2岁。*      *      (2)创建第二个对象，执行上述操作，体会同一个类的 不同对象之间的关系。*/
public class PersonTest {public static void main(String[] args) {Person p1 = new Person();p1.name = "Tom";p1.age = 18;p1.sex = 1;p1.study(); //studyingp1.showAge(); //age: 18int newAge = p1.addAge(2);System.out.println(p1.name + "的新年龄为:" + newAge); //Tom的新年龄为:20System.out.println(p1.age); //20//*****************************Person p2 = new Person();p2.showAge(); //age: 0}}

练习2

/** 2.利用面向对象的编程方法，设计类Circle计算圆的面积*///测试类
public class CircleTest {public static void main(String[] args) {Circle c1 = new Circle();c1.radius = 2;c1.findArea();}}//圆
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);}}

练习3

/** 3.1 编写程序，声明一个method方法，在方法中打印一个10*8 的*型矩形， 在main方法中调用该方法。* * 3.2 修改上一个程序，在method方法中，除打印一个10*8的*型矩形外，再* 计算该矩形的面积 ，并将其作为方法返回值 。在main方法中调用该方法 ， 接收返回的面积值并打印。* * 3.3 修改上一个程序，在method方法提供m和n两个参数，方法中打印一个 m*n的*型矩形，* 并计算该矩形的面积， 将其作为方法返回值。在main方法 中调用该方法，接收返回的面积值并打印。*/
public class Exer3Test {public static void main(String[] args) {Exer3Test e = new Exer3Test();//3.1测试e.method();//3.2测试int erea = e.method();System.out.println("面积为：" + erea);}//3.1
//  public void method() {//      for(int i = 0;i < 10;i++) {//          for(int j = 0;j < 8;j ++) {//              System.out.print("* ");
//          }
//          System.out.println();
//      }
//  }//3.2public int method() {for(int i = 0;i < 10;i++) {for(int j = 0;j < 8;j ++) {System.out.print("* ");}System.out.println();}return 10 * 8;}}

练习4

/** 定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩 score(int)。 * 创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。 * * 问题一：打印出3年级(state值为3）的学生信息。 * 问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息* * 1) 生成随机数：Math.random()，返回值类型double;* 随机数[a,b]公式：( Math.random() * (b - a + 1) + a)* * 2) 四舍五入取整：Math.round(double d)，返回值类型long*/
public class StudentTest {public static void main(String[] args) {//声明一个Student类型的数组Student[] stu = new Student[20];for(int i = 0;i <stu.length;i++){//给数组元素赋值stu[i] = new Student();//给Student对象的属性赋值stu[i].number = i + 1;//年级:[1,6]//Math.random()计算公式：[a,b] = (int)(Math.random() * (b - a + 1) + a)stu[i].state = (int)(Math.random() * (6 - 1 + 1) + 1);//成绩:[0,100]stu[i].score = (int)(Math.random() * (100 - 0 + 1));}//遍历学生数组for(int i = 0;i < stu.length;i++){//          System.out.println(stu[i].number + "," + stu[i].state
//              +  "," + stu[i].score);System.out.println(stu[i].info());}System.out.println("*********以下是问题1*********");//问题一：打印3年级(state值为3）的学生信息。for(int i = 0;i < stu.length;i++){if(stu[i].state == 3){System.out.println(stu[i].info());}}System.out.println("********以下是问题2**********");//问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息。for(int i = 0;i < stu.length - 1;i++){for(int j = 0;j <stu.length - 1 - i;j++){if(stu[j].score >stu[j+1].score){//如果需要换序，交换的是数组的元素，Student对象！！！Student temp = stu[j];stu[j] = stu[j+1];stu[j+1] = temp;}}}//遍历学生数组for(int i = 0;i < stu.length;i++){System.out.println(stu[i].info());}}
}
class Student{int number;   //学号int state;  //年级int score;  //成绩//显示学生信息的方法public String info(){return "学号:" + number + ",年级:" + state + ",成绩:" + score;}
}

练习4优化

/** 定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩 score(int)。 * 创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。 * * 问题一：打印出3年级(state值为3）的学生信息。 * 问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息* * 1) 生成随机数：Math.random()，返回值类型double;* 随机数[a,b]公式：( Math.random() * (b - a + 1) + a)* * 2) 四舍五入取整：Math.round(double d)，返回值类型long*/
public class StudentTest2 {public static void main(String[] args) {//声明一个Student类型的数组Student2[] stu = new Student2[20];for(int i = 0;i <stu.length;i++){//给数组元素赋值stu[i] = new Student2();//给Student的对象的属性赋值stu[i].number = i + 1;//年级:[1,6]stu[i].state = (int)(Math.random() * (6 - 1 + 1) + 1);//成绩:[0,100]stu[i].score = (int)(Math.random() * (100 - 0 + 1));}StudentTest2 test = new StudentTest2();//遍历学生数组test.print(stu);System.out.println("*********以下是问题1*********");//问题一：打印出3年级(state值为3）的学生信息。test.searchState(stu, 3);System.out.println("********以下是问题2**********");//问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息。test.sort(stu);//遍历学生数组for(int i = 0;i < stu.length;i++){System.out.println(stu[i].info());}}public void print(Student2[] stu){for(int i = 0;i < stu.length;i++){ System.out.println(stu[i].info());}}public void searchState(Student2[] stu,int state){for(int i = 0;i < stu.length;i++){if(stu[i].state == state){System.out.println(stu[i].info());}}}public void sort(Student2[] stu){for(int i = 0;i < stu.length - 1;i++){for(int j = 0;j <stu.length - 1 - i;j++){if(stu[j].score >stu[j+1].score){//如果需要换序，交换的是数组的元素，Student对象！！！Student2 temp = stu[j];stu[j] = stu[j+1];stu[j+1] = temp;}}}}
}
class Student2{int number;  //学号int state;  //年级int score;  //成绩//显示学生信息的方法public String info(){return "学号:" + number + ",年级:" + state + ",成绩:" + score;}
}

4.1 对象数组的内存解析

// 引用类型的变量，只能存储两类值：null或地址值（含变量类型）
Student[] stus= new Student[5];
stus[0] = new Student();
sysout(stus[0].state);//1
sysout(stus[1]);//null
sysout(stus[1].number);//异常
stus[1] = new Student();
sysout(stus[1].number);//0class Student{int number;//学号int state = 1;//年级int score;//成绩
}

4.2 匿名对象的使用

/** 一、理解"万事万物皆对象"* 1.在Java语言范畴当中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构*      >Scanner,String等*        >文件：File*         >网络资源：URL* 2.涉及到Java语言与前端HTML、后端的数据库交互时，前后端的结构在Java层面交互时，都体现为类、对象* * 二、内存解析的说明* 1.引用类型的变量，只能存储两类值：null 或 地址值（包含变量的类型）* * 三、匿名对象的使用* 1.理解：我们创建的对象，没有显式的赋给一个变量名。即为匿名对象* 2.特征：匿名对象只能调用一次* 3.使用：*/
public class InstanceTest {public static void main(String[] args) {Phone p = new Phone();System.out.println(p);//匿名对象
//      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);}
}

4.3 自定义数组的工具类

/** 自定义数组的工具类*/
public class ArrayUtil {//求数组的最大值public int getMax(int[] arr) {int maxValue = arr[0]; //如果随机数是负数，就不能用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]; //如果随机数是负数，就不能用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 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(arr[j],arr[j+1]);//正确的：swap(arr,j,j + 1);}}}}//错误的：交换数组中指定两个位置元素的值
//  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");}}//查找数组中指定的元素public int getIndex(int[] arr,int dest) {//线性查找：boolean isFlag = true;for(int i = 0;i < arr.length;i++) {if( dest == arr[i] ) {return i;}}return -1; //返回一个负数，表示没有找到     }}

测试类

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);util.print(arr);util.sort(arr);System.out.println();System.out.println("排序后:");util.print(arr);     }}

4.4 方法的重载

/** 方法的重载（overload）* * 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");}//如下三个方法不构成重载
//  public int getSum(int i,int j) {//      return 0;
//  }// public void getSum(int m,int n) {//
//  }// private void getSum(int i,int j) {//
//  }}

举例

1.判断：
与void show(int a,char b,double c){ }构成重载的有：
a)void show(int x,char y,double z){ } // no
b)int show(int a,double c,char b){ } // yes
c) void show(int a,double c,char b){ } // yes
d) boolean show(int c,char b){ } // yes
e) void show(double c){ } // yes
f) double show(int x,char y,double z){ } // no
g) void shows(){double c} // no

练习

/** 1.编写程序，定义三个重载方法并调用。方法名为mOL。*  三个方法分别接收一个int参数、两个int参数、一个字符串参数。* 分别执行平方运算并输出结果，相乘并输出结果，输出字符串信息。* 在主类的 main ()方法中分别用参数区别调用三个方法。* 2.定义三个重载方法max()，* 第一个方法求两个int值中的最大值，* 第二个方法求两个double值中的最大值，* 第三个方法求三个double值中的最大值，并分别调用三个方法。* */
public class OverLoadever {public static void main(String[] args) {OverLoadever test = new OverLoadever();//1.调用3个方法test.mOL(5);test.mOL(6, 4);test.mOL("fg");//2.调用3个方法int num1 = test.max(18, 452);System.out.println(num1);double num2 = test.max(5.6, -78.6);System.out.println(num2);double num3 = test.max(15, 52, 42);System.out.println(num3);}//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 i,double j){return (i > j) ? i : j;}public double max(double d1,double d2,double d3){double max = (d1 > d2) ? d1 : d2;return (max > d3) ? max : d3;}
}

4.5 可变个数的形参

/** 可变个数形参的方法* * 1.jdk5.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) {System.out.println("1");}//  public void show(String s) {//      System.out.println("2");
//  }public void show(String ... strs) {System.out.println("3");for(int i = 0;i < strs.length;i++) {System.out.println(strs[i]);}}//可变个数的形参在方法的形参中，必须声明在末尾
//  public void show(String ... strs,int i) { //编译不通过
//      System.out.println("4");
//  }public void show(int i,String ... strs) {System.out.println("5");}}

4.6 方法参数的值传递机制(重点)

关于变量的赋值

/** 关于变量的赋值：* * 如果变量是基本数据类型，此时赋值的是变量所保存的数据值。* 如果变量是引用数据类型，此时赋值的是变量所保存的引用数据的地址值*/
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 = 10n = 20;System.out.println("m = " + m + ", n = " + n); // m = 10,n = 20System.out.println("------------------引用数据类型------------------------");Order o1 = new Order();o1.orderId = 1001;Order o2 = o1; //赋值以后，o1和o2的地址值相同，都指向了堆空间中同一个对象实体// o1.orderId = 1001, o2.orderId = 1001System.out.println("o1.orderId = " + o1.orderId + ", o2.orderId = " + o2.orderId);o2.orderId = 1002;// o1.orderId = 1002, o2.orderId = 1002System.out.println("o1.orderId = " + o1.orderId + ", o2.orderId = " + o2.orderId);}}class Order{int orderId;}

针对于基本数据类型

/** 方法形参的传递机制：值传递* * 1.形参：方法定义时，声明的小括号内的参数*   实参：方法调用时，实际传递给形参的数据*   * 2.值传递机制：* 如果形参是基本数据类型，此时实参赋给形参的是：实参真实存储的数据值* 如果形参是引用数据类型，此时实参赋给形参的是：实参存储数据的地址值* */
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); //此时的m,n是实参System.out.println("m = " + m + ", n = " + n); // m = 10, n = 20}public void swap(int m,int n) { //此时的m,n是形参int temp = m;m = n;n = temp;System.out.println("swap方法 " + "m = " + m + ", n = " + n);//swap方法 m = 20, n = 10}}

针对于引用数据类型

/** 方法形参的传递机制：值传递* * 1.形参：方法定义时，声明的小括号内的参数*   实参：方法调用时，实际传递给形参的数据*   * 2.值传递机制：* 如果形参是基本数据类型，此时实参赋给形参的是：实参真实存储的数据值* 如果形参是引用数据类型，此时实参赋给形参的是：实参存储数据的地址值* */
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); //此时的data是实参System.out.println("m = " + data.m + ", n = " + data.n); // m = 20, n = 10}public void swap(Data data) { //此时的data是形参int temp = data.m;data.m = data.n;data.n = temp;System.out.println("swap方法 "+"m = " + data.m + ", n = " + data.n);//swap方法 m = 20, n = 10}}class Data{int m;int n;
}

练习1

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;
}

练习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="+a);System.out.println("b="+b);System.exit(0); //正常退出程序，也就是结束当前正在运行中的java虚拟机}}

程序运行结果：

a=100
b=200

练习3

/** 微软：* 定义一个int型的数组：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]; //arr[0] / arr[0] = 1,这样就导致arr[0] = 1了，后面所有数除以arr[0]都        是它本身
}//正确写法1
for(int i = arr.length –1;i >= 0;i--){arr[i] = arr[i] / arr[0];
}//正确写法2
int temp = arr[0]; //定义一个临时变量temp
for(int i= 0;i < arr.length;i++){arr[i] = arr[i] / temp;
}

练习4

/** int[] arr = new int[10];* System.out.println(arr);//地址值?* * char[] arr1 = new char[10];* System.out.println(arr1);//地址值?*/
public class ArrayPrint {public static void main(String[] args) {int[] arr = new int[]{1,2,3};System.out.println(arr);//地址值char[] arr1 = new char[]{'a','b','c'}; //char型数组打印的都是里面存储的数据，而不是地址值System.out.println(arr1);//abc}
}

练习5

/** 练习5：将对象作为参数传递给方法* (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()方法，调用完毕后输出当前半径值。**/
public class Circle {double radius; //半径//返回圆的面积public double findArea() {return Math.PI * radius * radius;}}

PassObject类

public class PassObject {public static void main(String[] args) {PassObject test = new PassObject();Circle c = new Circle();test.printAreas(c, 5);System.out.println("\t now radius is " + c.radius);}public void printAreas(Circle c, int time) {for(int i = 1;i <= time;i++) {//设置圆的半径值c.radius = i;double area = c.findArea();System.out.println(c.radius + "\t\t" + area);}c.radius = time + 1;}}

4.7 递归

/** 递归方法的使用（了解）* 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("-------------------");System.out.println(test.f(10));}//例2：计算1-n之间所有自然数的和public int getSum(int n) {if(n == 1) {return 1;}else {return n + getSum(n - 1);}}//例3：计算1-n之间所有自然数的乘积:相当于n!,表示n的阶乘public int getSum1(int n) {if(n == 1) {return 1;}else {return n * getSum1(n - 1);}}/** 例4：已知有一个数列：f(0) = 1,f(1) = 4,f(n+2)=2 * f(n+1) + f(n),* 其中n是大于0的整数，求f(10)的值。* * 解题思路：可以把f(n+2)当做f(n)，f(n+1)当做f(n-1)，f(n)当做f(n-2)*/public int f(int n) {if(n == 0) {return 1;}else if(n == 1) {return 4;}else {return 2 * f(n - 1) + f(n - 2);}}}

练习

/** 输入一个数据n，计算斐波那契数列(Fibonacci)的第n个值* 1  1  2  3  5  8  13  21  34  55* 规律：一个数等于前两个数之和* 要求：计算斐波那契数列(Fibonacci)的第n个值，并将整个数列打印出来*/
public class Recursion2 {public static void main(String[] args) {Recursion2 test = new Recursion2();int value = test.f(10);System.out.println(value);}public int f(int n) {if (n == 1 || n == 2) {return 1;} else {return f(n - 1) + f(n - 2);}}
}

5.面向对象的特征之一：封装与隐藏

封装性的引入与体现
为什么需要封装？封装的作用和含义？
我要用洗衣机，只需要按一下开关和洗涤模式就可以了。有必要了解洗衣机内部的结构吗？有必要碰电动机吗？
我要开车，…

我们程序设计追求“高内聚，低耦合”。
高内聚：类的内部数据操作细节自己完成，不允许外部干涉；
低耦合：仅对外暴露少量的方法用于使用。

隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

/** 面向对象的特征一：封装与隐藏* 一、问题的引入：*      当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对 对象的属性进行赋值。*        这里，赋值操作要受到属性的数据类型和存储范围的制约。*      除此之外，没有其他制约条件。但是，在实际问题中，我们往往需要给属性赋值，加入额外的限制条件。*         这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。（比如：setLegs()）*   同时，我们需要避免用户再使用"对象.属性"的方式直接对属性进行赋值。而需要将属性声明为私有的(private).*      -->此时，针对于属性就体现了封装性。*  * 二、封装性的体现：*         我们将类的属性xxx私有化(private),同时，*      提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值*     拓展：封装性的体现：① 如上  ② 不对外暴露私有的方法  ③ 单例模式   ...* * 三、封装性的体现，需要权限修饰符来配合。* 1.Java规定的4种权限（从小到大排列）：private、缺省(default)、protected、public* 2.4种权限可以用来修饰类及类的内部结构：属性、方法、构造器、内部类* 3.具体的，4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类*        修饰类的话，只能使用：缺省(default)、public* * 总结封装性：Java提供了4种权限修饰符来修饰类及类的内部结构，* 体现类及类的内部结构在被调用时的可见性的大小。*  */
public class AnimalTest {public static void main(String[] args) {Animal a = new Animal();a.name = "大黄";a.show();//a.setLegs(6);a.setLegs(-6);a.show();}}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;}//提供关于属性age的get和set方法public int getAge(){return age;}public void setAge(int a){age = a;}public void eat() {System.out.println("动物进食");}public void show() {System.out.println("name = " + name + ", age = " + age + ", legs = " + legs);}}

5.1 四种权限修饰符

Java规定的4种权限修饰符（从小到大排列）：private、缺省(default)、protected、public

修饰符	类内部	同一个包	不同包的子类	同一个工程
private	√
default（缺省）	√	√
protected	√	√	√
public	√	√	√	√

4种权限可以用来修饰类及类的内部结构：属性、方法、构造器、内部类
具体的：
4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类
对于（类）class的权限修饰只可以用public和default(缺省)
- public类可以在任意地方被访问。
- default类只可以被同一个包内部的类访问。

Order类

/** 三、封装性的体现，需要权限修饰符来配合。*   1.Java 规定的 4 种权限：(从小到大排序)private、缺省(default)、protected、public*   2.4 种权限用来修饰类及类的内部结构：属性、方法、构造器、内部类*   3.具体的，4 种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类*          修饰类的话，只能使用：缺省、public*  总结封装性：Java 提供了 4 中权限修饰符来修饰类积累的内部结构，体现类及类的内部结构的可见性的方法。* */
public class Order {private int orderPrivate;int orderDefault;public int orderPublic;private void methodPrivate(){orderPrivate = 1;orderDefault = 2;orderPublic = 3;}void methodDefault(){orderPrivate = 1;orderDefault = 2;orderPublic = 3;}public void methodPublic(){orderPrivate = 1;orderDefault = 2;orderPublic = 3;}
}

OrderTest 类

public class OrderTest {public static void main(String[] args) {Order order = new Order();order.orderDefault = 1;order.orderPublic = 2;//出了 Order 类之后，私有的结构就不可调用了
//      order.orderPrivate = 3;//The field Order.orderPrivate is not visibleorder.methodDefault();order.methodPublic();//出了 Order 类之后，私有的结构就不可调用了
//      order.methodPrivate();//The method methodPrivate() from the type Order is not visible}
}

相同项目不同包的 OrderTest 类

public class OrderTest {public static void main(String[] args) {Order order = new Order();order.orderPublic = 2;//出了 Order 类之后，私有的结构、缺省的声明结构就不可调用了
//      order.orderDefault = 1;
//      order.orderPrivate = 3;//The field Order.orderPrivate is not visibleorder.methodPublic();//出了 Order 类之后，私有的结构、缺省的声明结构就不可调用了
//      order.methodDefault();
//      order.methodPrivate();//The method methodPrivate() from the type Order is not visible}
}

封装性的练习

/** 1.创建程序,在其中定义两个类：Person和PersonTest类。定义如下：* 用setAge()设置人的合法年龄(0~130)，用getAge()返回人的年龄。*/
public class Person {private int age;private String name;public Person(){age = 18;}public Person(String n,int a){name = n;age = a;}public void setAge(int a){if(a < 0 || a > 130){//          throw new RuntimeException("传入的数据非法！");System.out.println("传入的数据非法！");return;}age = a;}public int getAge(){return age;}//绝对不要这样写！！
//  public int doAge(int a){//      age = a;
//      return age;
//  }public void setName(String n){name = n;}public String getName(){return name;}}

测试类

/** 在PersonTest类中实例化Person类的对象b，* 调用setAge()和getAge()方法，体会Java的封装性。*/
public class PersonTest {public static void main(String[] args) {Person p1 = new Person();
//      p1.age = 1;编译不通过p1.setAge(12);System.out.println("年龄为：" + p1.getAge());//        p1.doAge(122);Person p2 = new Person("Tom", 21);System.out.println("name = " + p2.getName() + ",age = " + p2.getAge());}
}

6.类的成员之三：构造器(或构造方法)

/** 类的结构之三：构造器（或构造方法、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); //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("人可以学习");}}

练习1

/* 2.在前面定义的 Person 类中添加构造器，* 利用构造器设置所有人的 age 属性初始值都为 18。* */
public class Person {private int age;public Person(){age = 18;}
}public class PersonTest {public static void main(String[] args) {Person p1 = new Person();System.out.println("年龄为:" + p1.getAge());}
}

练习2

/* * 3.修改上题中类和构造器，增加 name 属性,*   使得每次创建 Person 对象的同时初始化对象的 age 属性值和 name 属性值。*/
public class Person {private int age;private String name;public Person(){age = 18;}public Person(String n,int a){name = n;age = a;}public void setName(String n){name = n;}public String getName(){return name;}public void setAge(int a){if(a < 0 || a > 130){//          throw new RuntimeException("传入的数据据非法");System.out.println("传入的数据据非法");return;}age = a;}public int getAge(){return age;}
}public class PersonTest {public static void main(String[] args) {Person p2 = new Person("Tom",21);System.out.println("name = " + p2.getName() + ",age = " + p2.getAge());}
}

练习3

/** 编写两个类，TriAngle和TriAngleTest，其中TriAngle类中声明私有的底边长base和高height，* 同时声明公共方法访问私有变量。* 此外，提供类必要的构造器。另一个类中使用这些公共方法，计算三角形的面积。*/
public class TriAngle { //angle:角    angel:天使private double base;//底边长private double height;//高public TriAngle(){}public TriAngle(double b,double h){base = b;height = h;}public void setBase(double b){base = b;}public double getBase(){return base;}public void setHeight(double h){height = h;}public double getHeight(){return height;}}

TriAngleTest类

public class TriAngleTest {public static void main(String[] args) {TriAngle t1 = new TriAngle();t1.setBase(2.0);t1.setHeight(2.4);
//      t1.base = 2.5;//The field TriAngle.base is not visible
//      t1.height = 4.3;System.out.println("base : " + t1.getBase() + ",height : " + t1.getHeight());TriAngle t2 = new TriAngle(5.1,5.6);System.out.println("base : " + t2.getBase() + ",height : " + t2.getHeight());}
}

6.1 总结：属性赋值的先后顺序

/** 总结：属性赋值的先后顺序* * ① 默认初始化* ② 显式初始化* ③ 构造器中初始化* * ④ 通过"对象.方法" 或 "对象.属性"的方式，赋值* * 以上操作的先后顺序：① - ② - ③ - ④  */
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;}}

6.2 JavaBean的使用

/** JavaBean是一种Java语言写成的可重用组件。所谓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;}}

6.3 UML 类图

7.关键字的使用

7.1 关键字：this 的使用

/** this关键字的使用：* 1.this可以用来修饰、调用：属性、方法、构造器* * 2.this修饰属性和方法：*   this理解为：当前对象 或 当前正在创建的对象* *  2.1 在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象的属性或方法。但是，*   通常情况下，我们都选择省略"this."。特殊情况下，如果方法的形参和类的属性同名时，我们必须显式*   的使用"this.变量"的方式，表明此变量是属性，而非形参。* *  2.2 在类的构造器中，我们可以使用"this.属性"或"this.方法"的方式，调用当前正在创建的对象属性或方法。*  但是，通常情况下，我们都选择省略"this."。特殊情况下，如果构造器的形参和类的属性同名时，我们必须显式*   的使用"this.变量"的方式，表明此变量是属性，而非形参。* * 3. 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("人学习");}}

this的练习

Boy类

public class Boy {private String name;private int age;public Boy() {}public Boy(String name) {this.name = name;}public Boy(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public void marry(Girl girl){System.out.println("我想娶" + girl.getName());}public void shout(){if(this.age >= 22){System.out.println("你可以去合法登记结婚了！");}else{System.out.println("先多谈谈恋爱~~");}}
}

Girl类

public class Girl {private String name;private int age;public Girl() {}public Girl(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public void marry(Boy boy){System.out.println("我想嫁给" + boy.getName());boy.marry(this);}/*** @Description 比较两个对象的大小* @author shkstart* @date 2019年1月18日下午4:02:09* @param girl* @return  正数：当前对象大；  负数：当前对象小；  0：当前对象与形参对象相等*/public int compare(Girl girl){//      if(this.age > girl.age){//          return 1;
//      }else if(this.age < girl.age){//          return -1;
//      }else{//          return 0;
//      }return this.age - girl.age;}
}

测试类

public class BoyGirlTest {public static void main(String[] args) {Boy boy = new Boy("罗密欧", 21);boy.shout();Girl girl = new Girl("朱丽叶", 18);girl.marry(boy);Girl girl1 = new Girl("祝英台",19);int compare = girl.compare(girl1);if(compare > 0){System.out.println(girl.getName() + "大");}else if(compare < 0){System.out.println(girl1.getName() + "大");}else{System.out.println("一样大");}}
}

练习2

/** 写一个测试程序。* （1）创建一个 Customer，名字叫 Jane Smith, 他有一个账号为 1000，* 余额为 2000 元，年利率为 1.23％的账户。* （2）对 Jane Smith 操作。存入 100 元，再取出 960 元。再取出 2000 元。* 打印出 Jane Smith 的基本信息* * 成功存入：100.0* 成功取出：960.0* 余额不足，取款失败* Customer  [Smith,  Jane]  has  a  account:  id  is 1000, *  annualInterestRate  is 1.23％,  balance  is 1140.0*/

Account类

public class Account {private int id;//账号private double balance;//余额private double annualInterestRate;//年利率public Account (int id, double balance, double annualInterestRate ){this.id = id;this.balance = balance;this.annualInterestRate = annualInterestRate;}public int getId() {return id;}public void setId(int id) {this.id = id;}public double getBalance() {return balance;}public void setBalance(double balance) {this.balance = balance;}public double getAnnualInterestRate() {return annualInterestRate;}public void setAnnualInterestRate(double annualInterestRate) {this.annualInterestRate = annualInterestRate;}//在提款方法withdraw中，需要判断用户余额是否能够满足提款数额的要求，如果不能，应给出提示。public void withdraw (double amount){//取钱if(balance < amount){System.out.println("余额不足，取款失败");return;}balance -= amount;System.out.println("成功取出：" + amount);}public void deposit (double amount){//存钱if(amount > 0){balance += amount;System.out.println("成功存入：" + amount);}}
}

Customer类

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;}}

CustomerTest类

public class CustomerTest {public static void main(String[] args) {Customer cust = new Customer("Jane", "Smith");Account acct = new Account(1000, 2000, 0.0123);cust.setAccount(acct);cust.getAccount().deposit(100);cust.getAccount().withdraw(960);cust.getAccount().withdraw(2000);System.out.println("Customer[" + cust.getLastName() + "," + cust.getFirstName() + "] has a account: id is " + cust.getAccount().getId() + ",annualInterestRate is "+cust.getAccount().getAnnualInterestRate() * 100 + "% ,balance is " + cust.getAccount().getBalance());}
}

练习2

Account类

public class Account {private double balance;public Account(double init_balance){this.balance = init_balance;}public double getBalance(){return 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类

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类

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[numberOfCustomers] = cust;// numberOfCustomers++;// 或customers[numberOfCustomers++] = cust;}// 获取客户的个数public int getNumOfCustomers() {return numberOfCustomers;}// 获取指定位置上的客户public Customer getCustomer(int index) {// return customers[index];//可能报异常if (index >= 0 && index < numberOfCustomers) {return customers[index];}return null;}
}

BankTest类

public class BankTest {public static void main(String[] args) {Bank bank = new Bank();bank.addCustomer("Jane", "Smith");//连续操作bank.getCustomer(0).setAccount(new Account(2000));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.getNumOfCustomers());}
}

7.2 关键字：package 的使用

/** 一、package关键字的使用* 1.为了更好的实现项目中类的管理，提供包的概念* 2.使用package声明类或接口所属的包，声明在源文件的首行* 3.包，属于标识符，遵循标识符的命名规则、规范(xxxyyyzzz)、“见名知意”* 4.每"."一次，就代表一层文件目录。* * 补充：同一个包下，不能命名同名的接口、类。*     不同的包下，可以命名同名的接口、类。*/

JDK中主要的包介绍

1.java.lang----包含一些 Java 语言的核心类，如 String、Math、Integer、System 和 Thread，提供常用功能
2.java.net----包含执行与网络相关的操作的类和接口。
3.java.io----包含能提供多种输入/输出功能的类。
4.java.util----包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日期日历相关的函数。
5.java.text----包含了一些 java 格式化相关的类
6.java.sql----包含了 java 进行 JDBC 数据库编程的相关类/接口
7.java.awt----包含了构成抽象窗口工具集（abstractwindowtoolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。B/S  C/S

7.3 MVC设计模式

MVC 是常用的设计模式之一，将整个程序分为三个层次：视图模型层，控制器层，与数据模型层。这种将程序输入输出、数据处理，以及数据的展示分离开来的设计模式使程序结构变的灵活而且清晰，同时也描述了程序各个对象间的通信方式，降低了程序的耦合性。

7.4 import 的使用

import java.lang.reflect.Field;
import java.util.*;import cn.sxt.exer4.Account;
import cn.sxt.exer4.Bank;
import cn.sxt.java2.java3.Dog;import static java.lang.System.*;
import static java.lang.Math.*;
/** 二、import关键字的使用* import:导入* 1. 在源文件中显式的使用import结构导入指定包下的类、接口* 2. 声明在包的声明和类的声明之间* 3. 如果需要导入多个结构，则并列写出即可* 4. 可以使用"xxx.*"的方式，表示可以导入xxx包下的所有结构* 5. 如果使用的类或接口是java.lang包下定义的，则可以省略import结构* 6. 如果使用的类或接口是本包下定义的，则可以省略import结构* 7. 如果在源文件中，使用了不同包下的同名的类，则必须至少有一个类需要以全类名的方式显示。* 8. 使用"xxx.*"方式表明可以调用xxx包下的所有结构。但是如果使用的是xxx子包下的结构，则仍需要显式导入* * 9. import static:导入指定类或接口中的静态结构:属性或方法。 */
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);//全类名的方式显示cn.sxt.exer3.Account acct1 = new cn.sxt.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);}
}

三篇文章彻底搞懂Java面向对象之一相关推荐

一篇文章，搞懂自动化行业现状
在中国制造2025,工业4.0的口号下,现在自动化行业是风生水起,欣欣向荣.有企业转型的.有个人创业的.有跨界打劫的.还有政府扶持的.....好像做制造业的不搞点自动化,智能化你都不好意思说你在这个行 ...
一篇带你搞懂 java 集合
一.前言集合是java的基础. 我们有了集合,在我们开发过程中,事半功倍.我们常用的集合有这几类:Array,Map,Set,Queue等,他们每一类在java迭代升级的过程中,也是有不同的升级优化 ...
搞懂 Java HashMap 源码
HashMap 源码分析前几篇分析了 ArrayList , LinkedList ,Vector ,Stack List 集合的源码,Java 容器除了包含 List 集合外还包含着 Set 和 ...
java开发可重用代码包工具包_[Java教程]彻底搞懂Java开发工具包（JDK）安装及环境变量配置...
[Java教程]彻底搞懂Java开发工具包(JDK)安装及环境变量配置 0 2021-01-04 04:00:04 安装并配置JDK环境变量,不但要知道怎样做,也要知道为什么这样做,知其然知其所以然. ...
5张图搞懂Java深浅拷贝
微信搜一搜「bigsai」关注这个专注于Java和数据结构与算法的铁铁文章收录在github/bigsai-algorithm 欢迎star收藏如果本篇对你有帮助,记得点赞收藏哦! 在开发.刷 ...
java 内部类定于_搞懂 JAVA 内部类
前些天写了一篇关于 2018 年奋斗计划的文章,其实做 Android 开发也有一段时间了,文章中所写的内容,也都是在日常开发中遇到各种问题后总结下来需要巩固的基础或者进阶知识.那么本文就从内部类开刀 ...
java 自旋锁_搞懂Java中的自旋锁
轻松搞懂Java中的自旋锁前言在之前的文章<一文彻底搞懂面试中常问的各种"锁">中介绍了Java中的各种"锁",可能对于不是很了解这些概念的同学 ...
C++面试常见问答题看这三篇文章就够了（上）
目录 1. 标识符的组成结构 2. 动态关联和静态关联的区别 3. 重载(overload)和重写(overried)的区别 4. class和struct的区别 5. 构造方法的特点 6. 面向对 ...
看懂这篇文章,你就懂了信息安全的密码学
看懂这篇文章-你就懂了信息安全的密码学一.前言一个信息系统缺少不了信息安全模块,今天就带着大家全面了解并学习一下信息安全中的密码学知识,本文将会通过案例展示让你了解抽象的密码学知识,阅读本文你 ...

三篇文章彻底搞懂Java面向对象之一

文章目录

1.Java面向对象学习的三条主线

2.Java语言的基本元素：类和对象

2.1 类和对象的创建与使用（面向对象思想落地的实现）

2.2 内存解析

3.类的成员之一：属性（field）

3.1 语法格式

3.2 变量的分类：成员变量与局部变量

3.3 成员变量（属性）和局部变量的区别？

3.4 成员变量与局部变量的内存位置

4.类的成员之二：方法(method)

4.1 对象数组的内存解析

4.2 匿名对象的使用

4.3 自定义数组的工具类

4.4 方法的重载

4.5 可变个数的形参

4.6 方法参数的值传递机制(重点)

4.7 递归

5.面向对象的特征之一：封装与隐藏

5.1 四种权限修饰符

6.类的成员之三：构造器(或构造方法)

6.1 总结：属性赋值的先后顺序

6.2 JavaBean的使用

6.3 UML 类图

7.关键字的使用

7.1 关键字：this 的使用

7.2 关键字：package 的使用

7.3 MVC设计模式

7.4 import 的使用

三篇文章彻底搞懂Java面向对象之一相关推荐

最新文章

热门文章

三篇文章彻底搞懂Java面向对象之一

文章目录

1.Java面向对象学习的三条主线

2.Java语言的基本元素： 类和对象

2.1 类和对象的创建与使用（面向对象思想落地的实现）

2.2 内存解析

3.类的成员之一：属性（field）

3.1 语法格式

3.2 变量的分类：成员变量 与 局部变量

3.3 成员变量（属性）和局部变量的区别？

3.4 成员变量 与 局部变量的内存位置

4.类的成员之二：方法(method)

4.1 对象数组的内存解析

4.2 匿名对象的使用

4.3 自定义数组的工具类

4.4 方法的重载

4.5 可变个数的形参

4.6 方法参数的值传递机制(重点)

4.7 递归

5.面向对象的特征之一：封装与隐藏

5.1 四种权限修饰符

6.类的成员之三：构造器(或构造方法)

6.1 总结：属性赋值的先后顺序

6.2 JavaBean的使用

6.3 UML 类图

7.关键字的使用

7.1 关键字：this 的使用

7.2 关键字：package 的使用

7.3 MVC设计模式

7.4 import 的使用

三篇文章彻底搞懂Java面向对象之一相关推荐

最新文章

热门文章

2.Java语言的基本元素：类和对象

3.2 变量的分类：成员变量与局部变量

3.4 成员变量与局部变量的内存位置