目录
JAVA 的面向对象学习是学习 JAVA 最重要，最关键的一部分。前期学习需要掌握其基本原理以及基本使用即可。随着后面的不断使用再逐渐深刻理解，切不可“毕其功于一役”，一口气吃个胖子，期望第一遍或第二遍学习就将其搞清楚，弄明白，反倒最后丧失了自信心，产生畏难情绪。
1. 面向对象学习的三个方面
面向对象的学习可简单概括为三个方面：
（1）类及类的成员；属性，方法，构造器，代码块，内部类
（2）面向对象的三大特征；封装，继承，多态
（3）关键字的使用；this，super，public，static，final，abstract，interface，packing，import 等；
2. “大处着眼，小处着手”
在写代码的过程中做到“大处着眼，小处着手”；
3. 面向对象思想
面向对象思想也需要在后期的不断接触中慢慢感悟和理解，一开始不能接受是正常的；
高级语言根据其思想划分为两类：面向对象（如 Java），面向过程（如 C 语言）；
面向对象思想：将事物抽象为对象，给对象赋予一些属性和方法并封装起来，使程序更加模块化，更加易于理解和调用；
面向过程思想：把事情拆分为几个步骤，并按一定顺序执行；
4. 面向对象两要素
类：对一类事物的描述/概括，是抽象的；
对象：实际存在的事物，类似于数据库中的实体；
比如，学生 如果是类的话，小明，小红，小花就是对象；
面向对象的重点是类的设计，设计类就是设计类的成员（属性，方法，构造器，代码块，内部类）；
5. 类的设计
刚开始学习，类的成员中重要的就是设计类的属性（成员变量）和方法（成员方法 ）；
比如 人 是一个类，小明是类的一个对象，小明的属性有体重，身高等，行为（方法）有吃饭，睡觉，学习等；
6. 类和其对象的代码实现
想要按照”面向对象的“思想编写程序，需经历三步：
1. 创建类，设计类的成员；
2. 创建类的对象；
3. 通过”对象.方法“和”对象.属性“调用对象的结构；
//1.类的创建
class Person{
//成员变量/属性
String name;
int age = 18;
//成员方法/方法/函数
public void eat(){
System.out.println("每天一苹果");
}
public void sleep(){
System.out.println("睡睡眠眠");
}
public void english(String course){
System.out.println("好好学习"+course);
}
}
class PerDemo{
// 程序的入口
public static void main(String[] args) {
//2.类的实例化/创建类的对象/实例化类
Person p = new Person();
p.name = "小明";
//3.类的对象调用方法和属性
System.out.println(p.name);
p.eat();
p.english("英语");
p.sleep();
}
}6.1 注意
(1) 如果一个类有多个对象，那么各个对象的属性是独立的，互不影响的；
//1.类的创建
class Person{
//成员变量/属性
String name;
int age = 18;
//成员方法/方法/函数
public void eat(){
System.out.println("每天一苹果");
}
public void sleep(){
System.out.println("睡睡眠眠");
}
public void english(String course){
System.out.println("好好学习"+course);
}
}
class PerDemo{
// 程序的入口
public static void main(String[] args) {
//2.类的实例化/创建类的对象/实例化类
Person p = new Person();
p.name = "小明";
//3.类的对象调用方法和属性
System.out.println(p.name);
System.out.println(p.age);
p.eat();
p.english("英语");
p.sleep();
//再创建一个对象
//一个类创建多个对象，不同对象使用的一套属性是独立的，互不影响的（方法可共用）
Person p2 = new Person();
System.out.println(p2.name);//类中尚未赋值，因此使用其默认值
System.out.println(p2.age);//类中明确年龄为18,相当于其默认值为18
p2.eat();
}
}(2) 将 p 变量保存的对象地址值赋给 p3 ，导致 p,p3 指向堆空间中的同一个实体;
//1.类的创建
class Person{
//成员变量/属性
String name;
int age = 18;
//成员方法/方法/函数
public void eat(){
System.out.println("每天一苹果");
}
public void sleep(){
System.out.println("睡睡眠眠");
}
public void english(String course){
System.out.println("好好学习"+course);
}
}
class PerDemo{
// 程序的入口
public static void main(String[] args) {
//2.类的实例化/创建类的对象/实例化类
Person p = new Person();
p.name = "小明";
//3.类的对象调用方法和属性
System.out.println(p.name);
System.out.println(p.age);
p.eat();
p.english("英语");
p.sleep();
System.out.println("===========================");
//注意：
//再创建一个对象
//（1）一个类创建多个对象，不同对象使用的一套属性是独立的，互不影响的（方法可共用）
Person p2 = new Person();
System.out.println(p2.name);//类中尚未赋值，因此使用其默认值
System.out.println(p2.age);//类中明确年龄为18,相当于其默认值为18
p2.eat();
System.out.println("===========================");
//(2)将 p 变量保存的对象地址值赋给 p3 ，导致 p,p3 指向堆空间中的同一个实体；
Person p3 ;
p3 = p;
System.out.println(p3.name);
p3.age = 88;
System.out.println(p3.age);
p.age = 100;
System.out.println(p3.age);
p3.eat();
}
}6.2 内存解析
首先：堆存放对象实例，栈存放局部变量；
方法区存放类信息，常量，静态变量，即时编译器编译后的代码等；
new 结构产生的对象都存储在堆里，堆会产生一个对象实体，对象实体存在一个地址值，又称为首地址值，一般用 16 进制表示。main 方法中的变量都是局部变量，局部变量存储在栈里，对象实例存放在堆里；
6.3 方法
6.3.1 方法的分类
6.3.2 方法的声明
权限修饰符 返回值类型 方法名（ 形参列表 ）{
方法体
}
例如：
public void eat(){//无参无返回值
System.out.println("吃饭");
}
public void sleep(String name){//有参无返回值
String who = name + "吃饭";
}
public String song(){//无参有返回值
String s = "唱什么歌";
return s;
}
public String study(String Course){//有参有返回值
String p = "学习"+Course;
return p;
}说明
（1）权限修饰符有 private，public，缺省，protected ，暂不详细介绍；
（2）权限修饰符后，返回值类型前也可以使用：static，final，abstract 等关键字，这里暂不详细介绍；
（3）有参方法的返回值
定义有参方法，必须有返回值；
在声明方法时，就需要定义返回值类型；
public String talk(){//有参有返回值
String p = name ;
if (name == null) {
return "null";
}else {
return name;
}
}方法中需要使用 return 关键字指定返回类型的变量或常量，并在调用时使用一个变量接收（当然也有第二种方式）；
class T{
String name;
int age;
public String na(){
return name = "小白";
}
}
class TD{
public static void main(String[] args) {
T t = new T();
// 输出返回值的方法一
// String s = t.na();
// System.out.println(s);
// 输出返回值的方法二
System.out.println(t.na());
}
}（4）声明方法是否设置返回值
看具体要求；
凭借经验；
6.3.3 方法命名
方法名属于标识符，遵循标识符命名规则即可；
“见名知义”；
6.3.4 方法的使用
方法可以调用当前类的属性以及方法，但绝对不可以方法中定义方法；
public void eat(){//无参无返回值
System.out.println("吃饭");
}
public String study(String Course){//有参有返回值
String p = "学习"+Course;
eat();
return p;
}
6.4 形参列表
一个方法的形参可以存在0个，1个，乃至多个；
形参的定义需要根据具体情况和经验分析判断；
7. 练习测试
对象数组：定义类，包含三个属性：学号（number：int）年纪(state：int) 成绩(grade：int )，要求：（1）打印出3年级的学生信息；（2）使用冒泡排序按学生成绩排序，并打印输出所有学生信息；
class STUdent{
int id; //学号
int state; //班级
int score; //分数
/**
* 冒泡排序
*/
public void sort(STUdent[] arr){
for(int i = 0;i < arr.length - 1;i++){
for(int j = 0;j < arr.length - 1 - i;j++){
STUdent temp;
if(arr[j].score > arr[j+1].score){
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
/**
* 遍历输出
*/
public void print(STUdent[] st){
for(int i = 0;i<st.length;i++){
System.out.println( st[i].score+" "+st[i].id+" "+st[i].state);
// System.out.println(st[i]);// 输出的结果为地址值
}
}
/**
* 查找并输出
*/
public void search(STUdent[] st,int a){
// 按照要求输出
for(int i = 0;i < st.length;i++){
if(st[i].state == a){
System.out.print(st[i].id + " " + st[i].state + " " + st[i].score);
System.out.println(" ");
}
}
}
}
class Obd{
public static void main(String[] args) {
STUdent[] st = new STUdent[20];
for(int i = 0;i < st.length;i++){
// 每个数组元素开辟空间
st[i] = new STUdent();
st[i].id = i + 1;
st[i].state = (int)(Math.random() * 6 + 1);
st[i].score = (int)(Math.random() * 100 + 1);
// 查看共有哪些数据
System.out.print(st[i].id+" "+st[i].state+" "+st[i].score);
System.out.println(" ");
}
System.out.println("=======================");
STUdent s = new STUdent();
s.search(st,3);//查找并输出
System.out.println("=======================");
s.sort(st);//冒泡排序
s.print(st);//输出
}
}注意：对象数组的内存解析
引用类型的变量只存储两类值：null 或者 地址值 ；
