Java 基础是学习 JavaEE、大数据、Android 开发的基石
Java 面向对象
- 1. Java 学习面向对象的三条主线
- 2. 面向过程与面向对象
- 3. Java 语言的基本元素：类和对象
- 4. 类中属性的使用
- 5. 类中方法的声明和使用
- 6. 练习
- 7. 类中对象的声明
- 8. 再谈方法
- 9. 封装和隐藏
- 10. 构造器（构造方法、constructor）
- 11. 总结属性赋值
- 12. 拓展知识：JavaBean
- 13. this 的使用
- 14. 关键字：package、import的使用
- 15. MVC 设计模式
1. Java 学习面向对象的三条主线
- Java 类及类的成员：属性、方法、构造器；代码块、内部类
- 面向对象的三大特征：封装性、继承性、多态性
- 其他关键字：this、super、static、final、abstract、interface、package、import …
2. 面向过程与面向对象
面向过程（POP）与面向对象（OOP）
面向过程：强调的功能行为，以函数为最小单位，考虑怎么做。
面向对象：强调具备了功能的对象，以类 / 对象为最小单位，考虑谁来做。
面向对象的思想概述
程序员从面向过程的执行者转化成了面向对象的指挥者
3. Java 语言的基本元素：类和对象
面向对象的两个要素：类、对象
类（class）：对一类事务的描述，是抽象的、概念上的定义
对象（object）：是实际存在的该类事务的每个个体，因而也称为实例（ instance ）
常见的类的成员有：属性、行为
属性：对应类中的成员变量
行为：对应类中的成员方法
一、设计类，其实就是设计类的成员
属性 = 成员变量 = field = 域、字段
方法 = 成员方法 = 函数 = method
创建类的对象 = 类的实例化 = 实例化类
二、类和对象的使用（面向对象思想落地的实现）
- 创建类，设计类的成员
- 创建类的对象
- 通过“对象.属性”，“对象.方法”调用对象的结构
三、如果创建了一个类的多个对象，则每个对象都拥有一套独立的类的属性
User new user3 = user ： 将 user 的地址赋给 user3
四、对象的内存解析
对象变量存储在栈中，对象空间存储在堆中
package day06;
public class PersonTest {
public static void main(String[] args) {
// 创建User类的对象
Person user = new Person();
// 调用对象的结果：属性、方法
// 调用属性： 属性.变量
user.name = "Tom";
user.isMale = true;
// 调用方法： 属性.方法
user.talk("chinese");
user.eat("apple");
// 每一个对象都独立的拥有一套类的属性
Person user2 = new Person();
System.out.println(user2.name); // null
// 将 user 的地址赋给 user3
Person user3 = user;
System.out.println(user3.name); // Tom
user3.name = "Sam";
System.out.println(user.name); // Sam
}
}
class Person {
// 属性（成员变量）
String name;
int age;
boolean isMale;
// 方法
public void talk(String language) { // language：形参
System.out.println("我们使用" + language + "进行交流");
}
public void eat(String food) {
}
}4. 类中属性的使用
属性（成员变量） VS 局部变量
1 . 相同点：
- 定义变量的格式：数据类型 变量名 = 变量值
- 先声明，后使用
- 变量都有其对应的作用域
2 . 不同点：
- 在类中的位置不同，属性：直接定义在类的一对 { } 内；局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
- 关于权限修饰符的不同：属性：可以在声明属性时，指明其权限，使用权限修饰符，常用的权限修饰符：private、public、缺省、protected ；局部变量：不能使用权限修饰符
- 默认初始化值的情况：属性：类的属性，根据其类型，都有默认初始化值。局部变量：没有默认初始化值，意味着，我们在调用初始化值的时候一定要赋值，特别的，形参在调用时进行赋值。
- 在内存中加载的位置：属性：加载到堆空间中（非static）。局部变量：加载到栈空间中。
package day06;
public class UserTest {
public static void main(String[] args) {
User user = new User();
System.out.println(user.nameString);
System.out.println(user.age);
System.out.println(user.isMale);
user.talk("汉语");
user.eat();
}
}
class User {
// 属性（成员变量）
String nameString;
int age;
boolean isMale;
public void talk(String languageString) { // language:形参
System.out.println("我们使用" + languageString + "进行交流");
}
public void eat() {
String foodString = "馅饼";
System.out.println("北方人喜欢吃" + foodString);
}
}5. 类中方法的声明和使用
**方法：**描述类应该具备的功能。
比如：Math()类、sqrt()、random()、Scanner类 …
1 . 举例
public void eat() {
System.out.println("你已经吃饭了！");
}
public void sleep(int hour) {
System.out.println("你已经睡了" + hour + "小时了");
}
public String getName() {
return name;
}
public String getNation(String nation) {
String info = "我的国籍是" + nation;
return info;
}2 . 方法的声明
权限修饰符 返回值类型 方法名（形参列表）{
方法体
}注意：static、final、abstract 来修饰的方法，后面再讲。
3 . 说明
- 关于权限修饰符，默认方法的权限修饰符先都使用 public
- 返回值类型：有返回值 VS 没有返回值。有返回值时，则必须在方法声明时，指定返回值的类型，同时，方法中，需要使用 return 关键字来返回指定类型的变量或者常量。没有返回值时，则要用 void 类型，同时，方法中，可以不使用 return 关键字返回指定类型的变量或者常量。
- 方法名：属于标识符，遵循表示符的命名规则，要 “ 见名知意 ”。
- 形参列表：方法可以声明 0 个，1 个，或者多个形参。
- 方法体：方法功能的体现
4 . return 关键字的使用：
- 使用范围：使用在方法体中。
- 左右：(1) 结束方法；(2) 针对有返回值的方法，使用 " return 数据 "方法返回所要的数据。
- return 后面的语句都不会将执行。
5 . 方法的使用
方法的使用中可以调用当前类的属性或方法（可以是方法自己）（递归）
但不能在方法中定义方法
package day06;
public class CustomerTest {
public static void main(String[] args) {
Customer customer = new Customer();
customer.eat();
customer.sleep(9);
}
}
class Customer {
String nameString;
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 nameString;
} else {
return "Tom";
}
}
public String getNation(String nationString) {
String infoString = "我的国籍是" + nationString;
return infoString;
}
}6. 练习
1 . 创建一个Person类，其定义如下
Person |
name：String |
age：int |
sex：int |
+study()：void |
+showAge()：void |
+addAge(int i)：int |
要求：
- 创建Person类的对象，设置该对象的name、age、sex属性，调用study方法，输出字符串"studying"，调用showAge()方法显示age值，调用addAge()方法给对象的age属性值增加2岁。
- 创建第二个对象，执行上述操作，体会同一个类不同对象之间的关系。
person 类
package day06test;
public class Person {
String name;
int age;
/**
* sex取值1：女性
* sex取值2：男性
*/
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;
}
}测试类
package day06test;
public class PersonTest {
public static void main(String[] args) {
Person person = new Person();
person.name = "Tom";
person.age = 18;
person.sex = 1;
person.study();
person.showAge();
int newAge = person.addAge(2);
System.out.println(person.name + "的新年龄" + person.age);
}
}2 . 利用面向对象的编程方法，设置类Circle计算圆的面积
package day06test;
// 测试类
public class CircleTest {
public static void main(String[] args) {
Circle circle = new Circle();
circle.radius = 3.2;
System.out.println(circle.findArea());
}
}
// 圆
class Circle {
// 属性
double radius;
// 求圆的面积
public double findArea() {
double area = 3.14 * radius * radius;
// double area = Math.PI * radius * radius;
return area;
}
}3 . 打印矩形并求矩形面积
- 编写程序，声明一个method方法，在方法中打印一个108的型矩形，在main方法中调用该方法。
package day06test;
public class Exer3Test {
public static void main(String[] args) {
Exer3Test exer3Test = new Exer3Test();
exer3Test.method();
}
public void method() {
for(int i = 0; i < 10; i ++ ) {
for(int j = 0; j < 8; j ++ ) {
System.out.print("*");
}
System.out.println();
}
}
}- 修改上一个程序，在method方法中，除打印一个108的型矩形外，再计算该矩形的面积。并将其作为方法返回值。在main方法中调用该方法，接收返回的面积并打印。
package day06test;
public class Exer3Test {
public static void main(String[] args) {
Exer3Test exer3Test = new Exer3Test();
int area = exer3Test.method();
System.out.println(area);
}
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;
}
}- 修改上一个程序，在method方法中提供m和n两个参数，方法中打印一个mn的型矩形，并计算该矩形的面积，将其作为方法返回值。在main方法中调用该方法，接收返回的面积值并打印。
package day06test;
public class Exer3Test {
public static void main(String[] args) {
Exer3Test exer3Test = new Exer3Test();
int area = exer3Test.method(5, 6);
System.out.println(area);
}
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。
package day06test;
import java.util.Arrays;
public class StudentTest {
public static void main(String[] args) {
// 声明 student 类型的数字
Student[] student = new Student[20];
for(int i = 0; i < student.length; i ++ ) {
// 给数组元素赋值
student[i] = new Student();
// 给student对象的属性赋值
student[i].number = (i + 1);
// 年级[1-6]
student[i].state = (int)(Math.random() * (6 - 1 + 1) + 1);
// 成绩[0-100]
student[i].score = (int)(Math.random() * (100 - 0 + 1));
}
// 输出年级为3的学生信息
for(int i = 0; i < student.length; i ++ ) {
if(student[i].state == 3)
System.out.println(student[i].number + "," + student[i].state + "," + student[i].score);
}
// 冒泡排序后输出全部所有学生信息
for(int i = 0; i < student.length; i ++ ) {
for(int j = 0; j < student.length - 1 - i; j ++ ) {
if(student[j].score > student[j + 1].score) {
Student temp = student[j];
student[j] = student[j + 1];
student[j + 1] = temp;
}
}
}
for(int i = 0; i < student.length; i ++ ) {
System.out.println(student[i].number + "," + student[i].state + "," + student[i].score);
}
}
}
class Student {
int number;
int score;
int state;
}7. 类中对象的声明
一、理解“万事万物皆对象”
1 . 在 Java 语言范畴中，我们都将功能、结构封装到类中，通过类的实例化，来调用具体的功能结构
-> Scanner、String
-> 文件：File
-> 网络资源：URL
2 . 设计到 Java 语言与前端 Html、后端的数据库交互的时候，前端的结构在 Java 层面交互时，都体现为类、对象。
二、内存解析的说明
1 . 引用类型的变量，只可能存储两类值：null 或 地址值（含变量类型）
三、匿名对象的使用
1 . 理解：我们创建的对象，没有显式的赋给一个变量名。即为匿名对象。
2 . 特征：匿名对象只能调用一次。
3 . 使用：如下
package day07;
public class Instance {
public static void main(String[] args) {
Phone phone = new Phone();
System.out.println(phone);
phone.sendEmail();
// 匿名对象
new Phone().price = 1999;
new Phone().showPrice(); // 0.0
// 匿名对象的使用
PhoneMall phoneMall = new PhoneMall();
phoneMall.show(new Phone());
}
}
class PhoneMall {
public void show(Phone phone) {
phone.sendEmail();
phone.playGrame();
}
}
class Phone {
double price;
public void sendEmail() {
System.out.println("发送邮件");
}
public void playGrame() {
System.out.println("玩游戏");
}
public void showPrice() {
System.out.println(price);
}
}四、自定义数组工具类
package day07;
public class ArraysUtil {
// 求数组的最大值
public int getMax(int[] arr) {
int maxValue = arr[0];
for(int i = 0; i < arr.length; i ++ ) {
if(maxValue < arr[i]) maxValue = arr[i];
}
return maxValue;
}
// 求数组的最小值
public int getMin(int[] arr) {
int minValue = arr[0];
for(int i = 0; i < arr.length; i ++ ) {
if(minValue > arr[i]) minValue = arr[i];
}
return minValue;
}
// 求数组的总和
public int getSum(int[] arr) {
int sumValue = 0;
for(int i = 0; i < arr.length; i ++ ) {
sumValue += arr[i];
}
return sumValue;
}
// 求数组的平均值
public int getAvg(int[] arr) {
int avgValue = 0;
avgValue = getSum(arr) / arr.length;
return avgValue;
}
// 翻转数组
public void reverse(int[] arr) {
for(int i = 0; i < arr.length; 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; i ++ ) {
for(int j = 0; j < arr.length - i - 1; j ++ ) {
if(arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
// 遍历数组
public void print(int[] arr) {
for(int i = 0; i < arr.length; i ++ ) {
System.out.println(arr[i] + "\t");
}
}
// 二分查找
public int getIndex(int[] arr, int dest) {
for(int i = 0; i < arr.length; i ++ ) {
if(dest == arr[i]) {
return i;
}
}
return -1;
}
}8. 再谈方法
1 . 方法的重载
- 重载的定义：在同一个类中，允许存在多个同名方法，只要它们的参数个数或者参数类型不同即可。
“两同一不同”：同一个类、不同方法名；参数列表不同：参数个数不同，参数类型不同 - 判断是否是重载：根方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系！严格按照定义判断就可！
package day08;
public class OverLoadTest {
// 四个方法构成了重载
public void getSum(int i, int j) {
}
public void getSum(double d1, double d2) {
}
public void getSum(String s, int i) {
}
public void getSum(int i, String s) {
}
// 下面的不是重载
// public int getSum(int i, int j) {
//
// }
//
// public void getSum(int n, int m) {
//
// }
//
// private void getSum(int i, int j) {
//
// }
}- 在通过对象调用方法时，如何确定某一个指定的方法：方法名 —> 参数列表
- 例题：
package day08;
public class OverExer {
public void mOL(int i) {
System.out.println(i);
}
public void mOL(int i, int j) {
System.out.println(i + j);
}
public void mOL(String a) {
System.out.println(a);
}
public int max(int i, int j) {
return i > j ? i : j;
}
public double max(double d1, double d2) {
return d1 > d2 ? d1 : d2;
}
public double max(double d1, double d2, double d3) {
double max = d1 > d2 ? d1 : d2;
return max > d3 ? max : d3;
}
public static void main(String[] args) {
OverExer overExer = new OverExer();
overExer.mOL(1);
overExer.mOL(2, 3);
overExer.mOL("Hello!");
System.out.println(overExer.max(4, 5));
System.out.println(overExer.max(6.0, 7.1));
System.out.println(overExer.max(8.9, 9.9, 10));
}
}结果
2 . 可变个数形参的方法
- jdk 5.0 新增的内容
- 具体使用
a. 可变个数形参的格式：数据类型 … 变量名
b. 当调用可变个数形参的方法时，传入的参数个数可以是：0个、1个、2个、n个 - 可变个数参数的方法与本类中方法名相同，形参不同的方法构成重载
- 可变个数参数的方法与本类中方法名相同，形参类型也相同的方法不构成重载
- 可变个数形参在方法的形参中，必须声明在末尾
- 可变个数形参在方法的形参中，最多只能声明一个可变形参
package day08;
public class MethodArgsTest {
public void show(int i) {
}
// 可变个数形参的方法
public void show(String ... strs) {
// 实际上和数组的相同的
for(int i = 0; i < strs.length; i ++ ) {
System.out.println(strs[i]);
}
}
// 与上面的可变个数形参的方法不构成重载
// public void show(String[] s) {
//
// }
// 正确
public void show(int i, String ... strings) {
}
// 错误
// public void show(String ... strings, int i) {
//
// }
public static void main(String[] args) {
MethodArgsTest methodArgsTest = new MethodArgsTest();
methodArgsTest.show(12);
methodArgsTest.show("Hello!");
methodArgsTest.show("hello", "world");
methodArgsTest.show();
}
}3 . 方法参数的传递机制
- 关于变量的赋值
如果变量是基本数据类型，此时赋值的是变量所保存的数据值
如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值
package day08;
public class ValueTransferTest {
public static void main(String[] args) {
System.out.println("--------基本数据类型---------");
int n = 10;
int m = n;
System.out.println("n = " + n + ", m = " + m);
System.out.println("--------引用数据类型---------");
Order o1 = new Order();
o1.x = 1001;
Order o2 = o1; // 赋值以后，o1和o2的地址值相同，指向同一个数据
System.out.println("o1.x = " + o1 + ", o2.x = " + o2);
o2.x = 1002;
System.out.println("o1.x = " + o1 + ", o2.x = " + o2);
}
}
class Order {
int x;
}- 值传递
- 形参：方法定义时，声明的小括号内的参数
- 实参：方法调用时，实际传递给形参的数据
- 值传递机制
- 如果参数是基本数据类型，此时实参赋给形参的实际的数值
package day08;
public class ValueTransTest1 {
public static void main(String[] args) {
// 交换两个变量的操作
int n = 10;
int m = 20;
System.out.println("n = " + n + ", m = " + m);
int temp = m;
m = n;
n = temp;
System.out.println("n = " + n + ", m = " + m);
ValueTransTest1 valueTransTest1 = new ValueTransTest1();
valueTransTest1.swap(n, m);
System.out.println("n = " + n + ", m = " + m);
}
public void swap(int n, int m) {
int temp = m;
m = n;
n = temp;
}
}
- 如果参数是引用数据类型，此时实参赋给形参的是实参存储的数据的地址值
package day08;
public class ValueTransTest2 {
public static void main(String[] args) {
Data data = new Data();
data.m = 10;
data.n = 20;
System.out.println("n = " + data.n + ", m = " + data.m);
ValueTransTest2 valueTransTest2 = new ValueTransTest2();
valueTransTest2.swap(data);
System.out.println("n = " + data.n + ", m = " + data.m);
}
public void swap(Data data) {
int temp = data.m;
data.m = data.n;
data.n = temp;
}
}
class Data{
int m;
int n;
}
练习：
1.定义一个Circle类，包含一个double型的radius属性代表圆的半径，一个findArea()方法返回圆的面积
2.定义一个类PassObject，在类中定义一个方法printAreas()，该方法的定义如下：public void printAreas(Circle c, int time) ，在printAreas方法中打印输出1到time之间的每个整数半径值，以及对应的面积
例如：time为5，则输出半径为1，2，3，4，5，以及对应的圆的面积
3.在main方法中调用public void printAreas()方法。
package day08;
public class Circle {
double radius;
public double findArea() {
return Math.PI * radius * radius;
}
}package day08;
public class PassObject {
public static void main(String[] args) {
PassObject passObject = new PassObject();
Circle circle = new Circle();
passObject.printAreass(circle, 5);
}
private void printAreass(Circle c, int time) {
for(int i = 1 ; i <= time; i ++ ) {
c.radius = i;
System.out.println("半径：" + i + "面积：" + c.findArea());
}
}
}
4 . 递归方法
- 定义：一个方法体内调用它本身
- 方法的递归包含一种隐性的循环，他会重复执行某段代码，但这种重复执行无需循环控制。递归一定要已知方向递归，否则就会变成无穷递归
简单栗子：
package day08;
public class RecursionTest {
public static void main(String[] args) {
RecursionTest recursionTest = new RecursionTest();
int sum = recursionTest.getSum(100);
System.out.println(sum);
}
// 递归求和
public int getSum(int n) {
// 递归结束的条件
if(n == 1) {
return 1;
} else {
return n + getSum(n - 1);
}
}
}9. 封装和隐藏
隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。
1. 问题的引入
当我们创建一个类的对象一会，我们可以通过“对象 . 属性”的方式，对对象的属性进行赋值。这里，复制操作受属性的数据类型和存储范围的制约。除此之外，没有其他制约条件。但是，在实际问题中，我们往往需要给属性赋值加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。比如（set legs）同时，我们要避免用户再使用“对象 . 属性”的方式对属性进行赋值。则需要将属性声明为私有的（private）-- > 此时，针对属性就体现了封装性
2. 封装性的体现
我们将属性xxx私有化（private），同时提供公共的（public）方法来获取（getxxx）和设置（setxxx）此属性的值
拓展
封装性的体现：
- 属性的封装性
- 方法的封装性
- 单例模式
package day9;
public class AnimalTest {
public static void main(String[] args) {
Animal animal = new Animal();
animal.name = "大黄";
animal.age = 1;
// animal.legs = 4; // The field Animal.legs is not visible
animal.setlegs(6);
animal.show();
}
}
class Animal {
String name;
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);
}
}3. 封装性的体现，需要权限修饰符来配合
- Java 规定的 4 种权限（从小到大排列）：private、缺省（default）、protected、public
修饰符 | 类内部 | 同一个包 | 不同包的子类 | 同一个工程 |
private | Yes | |||
缺省 | Yes | Yes | ||
protected | Yes | Yes | Yes | |
public | Yes | Yes | Yes | Yes |
- 4 种权限可以用来修饰类及类的内部结构：属性、方法、构造器、内部类
- 具体的，对于class的权限修饰只可以用public和default（缺省）
package day9;
public class Order {
private int orderPrivate;
int orderDefault;
public int orderPublic;
public void methodPublic() {
orderPrivate = 1;
orderDefault = 2;
orderPublic = 3;
}
void methodDfault() {
orderPrivate = 1;
orderDefault = 2;
orderPublic = 3;
}
private void methodPrivate() {
orderPrivate = 1;
orderDefault = 2;
orderPublic = 3;
}
}package day9;
public class OrderTest {
public static void main(String[] args) {
Order order = new Order();
order.orderDefault = 1;
order.orderPublic = 2;
// 出了Order类之后，私有的结构就不可以调用了
// order.orderPrivate = 3;
order.methodDfault();
order.methodPublic();
// 出了Order类之后，私有的方法就不可以调用了
// order.methodPrivate();
}
}4. 总结封装性
Java 提供了 4 种权限修饰符来修饰类及类的内部结构，体现了类及类的内部结构在别调用时的可见性大小
10. 构造器（构造方法、constructor）
1. 构造器的作用
创建类的对象：Person person = new Person();
给对象进行初始化：Person person = new Person(“Peter”, 15);
2. 说明
- 如果没有显式的定义类的构造器的话，则系统会默认提供一个空参的构造器
- 定义构造器的格式：权限修饰符 类名 ( 形参列表 ) { }
public Person() {
}- 一个类中的多个构造器之间构成重载关系
- 一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器了
- 一个类中至少有一个构造器
package day9;
public class PersonTest {
public static void main(String[] args) {
// 创建类的对象：new + 构造器
Person person = new Person();
person.eat();
}
}
class Person {
// 属性
String name;
int age;
// 构造器
public Person() {
System.out.println("Person()....");
}
// 方法
public void eat() {
System.out.println("人吃饭");
}
public void study() {
System.out.println("人学习");
}
}11. 总结属性赋值
属性赋值的先后顺序
- 默认初始化
- 显式初始化
- 构造器中赋值
- 通过" 对象 . 方法 " 或 " 对象 . 属性 " 的方式赋值
12. 拓展知识：JavaBean
JavaBean 是一种 Java 写成的可重用组件
JavaBean 是指符合如下标准的 Java 类：
- 类是公共的
- 有一个午餐的公共构造器
- 有属性，且有对应的get、set方法
package day9;
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 a) {
name = a;
}
public String getName() {
return name;
}
}13. this 的使用
this 关键字的使用
- this 可以用来修饰属性、方法、构造器
- this 修饰属性和方法：this理解为：当前对象，或正在创建的对象；
在类的方法中，我们可以使用“this . 属性”或“this . 方法”的形式，调用当前对象属性或方法。但是，通常情况下，我们都选择省略“this”，特殊情况下，如果方法的形参和类的属性同名时，我们必须显式的使用“this . 变量”的方式，表明此变量是属性，而非形参。
在类的构造器中，我们可以使用“this . 属性”或“this . 方法”的形式，调用当前正在创建的对象属性或方法。但是，通常情况下，我们都选择省略“this”，特殊情况下，如果方法的形参和类的属性同名时，我们必须显式的使用“this . 变量”的方式，表明此变量是属性，而非形参。 - this 调用构造器
在构造器中，我们可以显式的使用“this ( 形参列表 )”的形式调用其他构造器
不能调用自己
this 调用构造器必须放在首行（不放在首行会报错）
package day9;
public class PersonTest02 {
public static void main(String[] args) {
Person02 person02 = new Person02();
person02.setAge(10);
person02.setName("大黄");
person02.getAge();
person02.getName();
}
}
class Person02 {
private String name;
private int age;
public Person02() {
}
public Person02(String name) {
this();
this.name = name;
}
public Person02(String name, int age) {
this(name);
this.age = age;
}
public void setName(String name) {
// this.name指的是当前对象person02的name
// name指的是传入的参数
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
}14. 关键字：package、import的使用
1. package 关键字的使用
- 为了更好的实现项目中类的管理，提供包的概念
- 使用package声明类或接口所属的包，声明在源文件的首行
- 包，属于标识符，遵循标识符的命名规则、规范（xxxyyyzzz）、“见名知意”
- 每“ . ”一次，就代表一层文件目录
补充：同一个包下不能命名同名的接口、类；不同的包下可以命名同名的接口、类
2. 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）
3. import 关键字的使用
import：导入
- 在源文件中显式的使用import结构导入指定包下的类、接口
- 声明在包的声明和类的声明之间
- 如果需要导入多个结构，并列写出即可
- 可以使用" xxx.* "的方式，表示可以导入xxx包下的所有结构
- 如果使用的类或接口是java.lang包下定义的，则可以省略import结构
- 如果使用的类或接口是本包下定义的，则也可以省略
- 如果在源文件中，使用了不同包下的同名类，则必须至少有一个类要使用全类名的方式
- 如果使用“ xxx.* ”方式表明可以调用 xxx 包下的所有结构。但是如果使用的是 xxx 包下子包中的结构，则荣需要显示的导包
- import static：导入指定类或接口的静态结构：属性、方法
15. MVC 设计模式
MVC是常用的设计模式之一，将整个程序分为三个层次：视图模式层、控制器层、数据模型层
模型层 model 主要处理数据
数据对象封装 model.bean、domain
数据库操作类 model.dao
数据库 model.db
视图层 view 显示数据
相关工具类 view.utils
自定义 view.ui
控制层 controller 处理业务逻辑
应用界面相关 controller.activity
存放fragment controller.fragment
显示列表的适配器 controller.adapter
服务相关的 controller.service
抽取的基类 controller.base
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
