Java基础系列（5）- 面向对象（上） 类和对象 java类及类的成员 内存解析 属性 方法
类(Class)和对象(Object)是面向对象的核心概念。
- 类是对一类事物的描述，是抽象的、概念上的定义
- 对象是实际存在的该类事物的每个个体，因而也称为实例(instance)
java类及类的成员
属性(field)：对应类中的成员变量 （也叫成员变量、域、字段）
方法(method)：对应类中的成员方法（也叫函数）
内存解析
堆（Heap），此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。这一点在Java虚拟机规范中的描述是：所有的对象实例以及数组都要在堆上分配。
栈（Stack），是指虚拟机栈。虚拟机栈用于存储局部变量等。局部变量表存放了编译期可知长度的各种基本数据类型（boolean、byte、char 、 short 、 int 、 float 、 long 、double）、对象引用（reference类型，它不等同于对象本身，是对象在堆内存的首地址）。 方法执行完，自动释放。
方法区（Method Area），用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。
属性
语法格式：修饰符 数据类型 属性名=初始化值
-
说明1：修饰符：
-
常用的权限修饰符有：private、缺省、protected、public
-
其他修饰符：static、final (暂不考虑)
-
-
说明2：数据类型
- 任何基本数据类型 (如int、Boolean) 或 任何引用数据类型。
-
说明3：属性名
- 属于标识符，符合命名规则和规范即可。
举例
public class Person{
private int age; //声明private变量 age
public String name = “Lila”; //声明public变量 name
}
变量的分类：成员变量(属性)与局部变量
在方法体外，类体内声明的变量称为成员变量。
在方法体内部声明的变量称为局部变量。
属性（成员变量） VS 局部变量
相同点：
- 定义变量的格式：数据类型 变量名 = 变量值
- 先声明，后使用
- 变量都有其对应的作用域
不同点：
- 在类中声明的位置的不同：
- 属性：直接定义在类的一对 {} 内
- 局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
- 关于权限修饰符的不同：
- 属性：可以在声明属性时，指明其权限，使用权限修饰符
- 常用的权限修饰符：private、public、缺省、protected
- 默认初始化值的情况：
- 属性：类的属性，根据其类型，都有默认初始化值
- 整型（byte、short、int、long） 默认 0
- 浮点型（float、double）：0.0
- 字符型（char）：0 （或 'u0000'）
- 布尔型（boolean）：false
- 引用数据类型（类、数组、接口）：null
- 局部变量：没有默认初始化值
- 意味着，我们在调用局部变量之前，一定要显示赋值
- 特别地：形参在调用时，我们赋值即可
- 属性：类的属性，根据其类型，都有默认初始化值
- 在内存中加载的位置
- 属性：加载到堆空间中（static放在方法区）
- 局部变量：加载到栈空间
方法
什么是方法(method、函数）:
方法是类或对象行为特征的抽象，用来完成某个功能操作。在某些语言中也称为函数或过程。
- 将功能封装为方法的目的是，可以实现代码重用，简化代码
- Java里的方法不能独立存在，所有的方法必须定义在类里。
举例
public class Person {
private int age;
public int getAge() { //声明方法getAge()
return age;
}
public void setAge(int i) { //声明方法setAge
age = i; //将参数i的值赋给类的成员变量age
}
}
方法的声明格式
修饰符 返回值类型 方法名（参数类型 形参1, 参数类型 形参2, ….）｛
方法体程序代码
return 返回值;
｝
其中：
修饰符：public, 缺省, private, protected等
返回值类型：
1. 没有返回值：`void`。通常，没有返回值的方法中，就不适用return，但是，如果使用的话，只能`return;`表示结束此方法的意思
2. 有返回值，声明出返回值的类型。与方法体中 `return返回值`搭配使用
方法名：属于标识符，命名时遵循标识符命名规则和规范，见名知意
形参列表：可以包含零个，一个或多个参数。多个参数时，中间用,隔开
返回值：方法在执行完毕后返还给调用它的程序的数据
return关键字的使用：
1. 使用范围：使用在方法体中
2. 作用：结束方法；针对有返回值类型的方法，使用 return 数据 方法返回所要的数据
3. 注意点：return 关键字后面不可以跟执行语句
练习题一：
Person类
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;
}
}
PersonTest类
/*
* 要求：
* (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();
p1.showAge();
int newAge = p1.addAge(2);
System.out.println(p1.name + "的新年龄为：" + newAge);
System.out.println(p1.age);//20
//*************************
Person p2 = new Person();
p2.showAge();//0
p2.addAge(10);
p2.showAge();//10
p1.showAge();
}
}
练习题二：
/*
* 2.利用面向对象的编程方法，设计类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;
// }
//
}
练习题三：
/*
* 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 test = new Exer3Test();
//3.1测试
// test.method();
//3.2测试
//方式一：
// int area = test.method();
// System.out.println("面积为：" + area);
//方式二：
// System.out.println(test.method());
//3.3测试
int area = test.method(12, 10);
System.out.println("面积为：" + area);
}
//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.2
// public 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;
// }
//3.3
public int method(int m,int n){
for(int i = 0;i < m;i++){
for(int j = 0;j < n;j++){
System.out.print("* ");
}
System.out.println();
}
return m * n;
}
}
练习题四：
/*
* 4. 对象数组题目：
定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩score(int)。
创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。
问题一：打印出3年级(state值为3）的学生信息。
问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
提示：
1) 生成随机数：Math.random()，返回值类型double;
2) 四舍五入取整：Math.round(double d)，返回值类型long。
*
*
*
*
*/
public class StudentTest {
public static void main(String[] args) {
// Student s1 = new Student();
// Student s1 = new Student();
// Student s1 = new Student();
// Student s1 = new Student();
// Student s1 = new Student();
// Student s1 = new Student();
//声明Student类型的数组
Student[] stus = new Student[20]; //String[] arr = new String[10];
for(int i = 0;i < stus.length;i++){
//给数组元素赋值
stus[i] = new Student();
//给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));
}
//遍历学生数组
for(int i = 0;i <stus.length;i++){
// System.out.println(stus[i].number + "," + stus[i].state
// + "," + stus[i].score);
System.out.println(stus[i].info());
}
System.out.println("********************");
//问题一：打印出3年级(state值为3）的学生信息。
for(int i = 0;i <stus.length;i++){
if(stus[i].state == 3){
System.out.println(stus[i].info());
}
}
System.out.println("********************");
//问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
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对象！！！
Student temp = stus[j];
stus[j] = stus[j + 1];
stus[j + 1] = temp;
}
}
}
//遍历学生数组
for(int i = 0;i <stus.length;i++){
System.out.println(stus[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;
2) 四舍五入取整：Math.round(double d)，返回值类型long。
*
*
* 此代码是对StudentTest.java的改进：将操作数组的功能封装到方法中。
*
*/
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));
}
StudentTest1 test = new StudentTest1();
//遍历学生数组
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 shkstart
* @date 2019年1月15日下午5:10:19
* @param stus
*/
public void print(Student1[] stus){
for(int i = 0;i <stus.length;i++){
System.out.println(stus[i].info());
}
}
/**
*
* @Description 查找Stduent数组中指定年级的学生信息
* @author shkstart
* @date 2019年1月15日下午5:08:08
* @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 shkstart
* @date 2019年1月15日下午5:09:46
* @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;
}
}
匿名对象的使用
public class InstanceTest {
public static void main(String[] args) {
Phone p = new Phone();
// p = null;
System.out.println(p);
p.sendEmail();
p.playGame();
//匿名对象
// 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);
}
}
方法的重载(overload)
重载的概念
在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
重载的特点
与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类型)。调用时，根据方法参数列表的不同来区别。
重载示例
//返回两个整数的和
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;}
可变个数的形参
JavaSE 5.0 中提供了Varargs(variable number of arguments)机制，允许直接定义能和多个实参相匹配的形参。从而，可以用一种更简单的方式，来传递个数可变的实参。
//JDK 5.0以前：采用数组形参来定义方法，传入多个同一类型变量
public static void test(int a ,String[] books);
//JDK5.0：采用可变个数形参来定义方法，传入多个同一类型变量
public static void test(int a ,String…books);
-
声明格式：方法名(参数的类型名 ...参数名)
-
可变参数：方法参数部分指定类型的参数个数是可变多个：0个，1个或多个
-
可变个数形参的方法与同名的方法之间，彼此构成重载
-
可变参数方法的使用与方法参数部分使用数组是一致的
-
方法的参数部分有可变形参，需要放在形参声明的最后
-
在一个方法的形参位置，最多只能声明一个可变个数形参
方法参数的值传递机制
方法，必须由其所在类或对象调用才有意义。若方法含有参数：
形参：方法声明时的参数
实参：方法调用时实际传给形参的参数值
Java的实参值如何传入方法呢？
Java里方法的参数传递方式只有一种：值传递。 即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。
- 形参是基本数据类型：将实参基本数据类型变量的
数据值传递给形参 - 形参是引用数据类型：将实参引用数据类型变量的
地址值传递给形参
例题一
方法一：
public static void method(int a, int b){
a = a * 10;
b = b * 20;
System.out.println(a);
System.out.println(b);
System.exit(0);
}
方式二：
public static void method(int a, int b) {
PrintStream ps = new PrintStream(System.out) {
@Override
public void println(String x) {
if ("a=10".equals(x)) {
x = "a=100";
} else {
x = "b=200";
}
super.println(x);
}
};
System.setOut(ps);
}
例题二
定义一个int型的数组：int[] arr = new int[]{12,3,3,34,56,77,432};让数组的每个位置上的值去除以首位置的元素，得到的结果，作为该位置上的新值。遍历新的数组。
错误答案：(只有第一次得时候arr[0]是12，之后都是1)
for(int i= 0；i < arr.length;i++){
arr[i] = arr[i] / arr[0];
}
正确答案：
//正确写法1
for(int i = arr.length – 1;i >= 0;i--){
arr[i] = arr[i] / arr[0];
}
//正确写法2
int temp = arr[0];
for(int i= 0；i < arr.length;i++){
arr[i] = arr[i] / temp;
}
递归方法
递归方法：一个方法体内调用它自身。
-
方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
-
递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。
例子一：计算1-100之间所有自然数的和
//计算1-100之间所有自然数的和
public int sum(int num){
if(num == 1){
return 1;
}else{
return num + sum(num - 1);
}
}
例子二：已知有一个数列：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); 这样写有问题，n太多会栈空间溢出
return 2 * f(n - 1) + f(n - 2);
}
}
封装与隐藏
Java中通过将数据声明为私有的(private)，再提供公共的（public）方法:getXxx()和setXxx()实现对该属性的操作，以实现下述目的：
隐藏一个类中不需要对外提供的实现细节；
- 使用者只能通过事先定制好的
方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作； - 便于修改，增强代码的可维护性
四种访问权限修饰符
对于class的权限修饰只可以用public和default(缺省)。
-
public类可以在任意地方被访问。
-
default类只可以被同一个包内部的类访问。
构造器
构造器的特征
- 它具有与类相同的名称
- 它不声明返回值类型。（与声明为void不同）
- 不能被static、final、synchronized、abstract、native修饰，不能有return语句返回值
构造器的作用：创建对象；给对象进行初始化
根据参数不同，构造器可以分为如下两类：
- **隐式无参构造器（系统****默认提供）
- 显式定义一个或多个构造器（无参、有参）
注意
- Java语言中，每个类都至少有一个构造器
- 默认构造器的修饰符与所属类的修饰符一致
- 一旦显式定义了构造器，则系统
不再提供默认构造器 - 一个类可以创建多个
重载的构造器 - 父类的构造器不可被子类继承
JavaBean
JavaBean是一种Java语言写成的可重用组件。
所谓javaBean，是指符合如下标准的Java类：
- 类是公共的
- 有一个无参的公共的构造器
- 有属性，且有对应的get、set方法
UML类图
this的使用
使用this，调用属性、方法
class Person { // 定义Person类
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public void getInfo() {
System.out.println("姓名：" + name);
this.speak();
}
public void speak() {
System.out.println(“年龄：” + this.age);
}
}
使用this调用本类的构造器
class Person { // 定义Person类
private String name;
private int age;
public Person() { // 无参构造器
System.out.println("新对象实例化");
// 这里有40行代码，为了不让其他构造器重复写这40行代码，于是其他构造器调用这个构造器
}
public Person(String name) {
this(); // 调用本类中的无参构造器
this.name = name;
}
public Person(String name, int age) {
this(name); // 调用有一个参数的构造器
this.age = age;
}
public String getInfo() {
return "姓名：" + name + "，年龄：" + age;
}
}
注意：
-
可以在类的构造器中使用"this(形参列表)"的方式，调用本类中重载的其他的构造器！
-
明确：构造器中不能通过"this(形参列表)"的方式调用自身构造器
-
如果一个类中声明了n个构造器，则最多有 n - 1个构造器中使用了 "this(形参列表)"
-
"this(形参列表)"必须声明在类的构造器的首行！
-
在类的一个构造器中，最多只能声明一个"this(形参列表)
关键字：package、import
package
package语句作为Java源文件的第一条语句，指明该文件中定义的类所在的包。(若缺省该语句，则指定为无名包)。
它的格式为：
package 顶层包名.子包名 ;
包对应于文件系统的目录，package语句中，用 “.” 来指明包(目录)的层次；
包通常用小写单词标识。通常使用所在公司域名的倒置：com.atguigu.xxx
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----包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。
import
为使用定义在不同包中的Java类，需用import语句来引入指定包层次下所需要的类或全部类(.*)。import语句告诉编译器到哪里去寻找类。
语法格式：
import 包名.类名;
注意
- 在源文件中使用import显式的导入指定包下的类或接口
- 声明在包的声明和类的声明之间。
- 如果需要导入多个类或接口，那么就并列显式多个import语句即可
- 举例：可以使用java.util.*的方式，一次性导入util包下所有的类或接口。
- 如果导入的类或接口是java.lang包下的，或者是当前包下的，则可以省略此import语句。
- 如果在代码中使用不同包下的同名的类。那么就需要使用类的全类名的方式指明调用的
是哪个类。 - 如果已经导入java.a包下的类。那么如果需要使用a包的子包下的类的话，仍然需要导入。
- import static组合的使用：调用指定类或接口下的静态的属性或方法