目录：

类及对象

方法的重载

可变个数的形参的方法

java的值传递机制

面对对象的特征之一：封装性

构造器

this关键字

package/import

JAVA 知识图解

面向对象

Q：如何理解面向对象编程呢？
理解一：人开门
面向过程：人打开门
面向对象：

人{打开(门){门.开开();}
}门{开开(){从前往后转90度...}
}

理解二：人把大象装进冰箱
面向过程：1）打开冰箱 2）把大象放进去 3）关闭冰箱
面向对象：

人{打开(冰箱){冰箱.开开()}操作(大象){大象.进入(冰箱)}关闭(冰箱){冰箱.合上()}
}
大象{进入(冰箱){}
}
冰箱{打开(){}合上(){}
}

1.类与对象

关于于类的设计

类的组成成分

1）属性（成员变量，Field）
2）方法（成员方法，函数，Method）

【属性】
成员变量 vs 局部变量
相同点：

1.遵循变量声明的格式：数据类型变量名 = 初始化值
2.都有作用域

不同点：

1.声明的位置的不同：成员变量：声明在类里，方法外
局部变量：声明在方法内，方法的形参部分，代码块内
2.成员变量的修饰符有四个：public private protected 缺省
局部变量没有修饰符，与所在的方法修饰符相同。
3.初始化值：一定会有初始化值。
成员变量:如果在声明的时候，不显式的赋值，那么不同数据类型会有不同的默认初始化值。
byte short int long ==>0
float double ==>0.0
char ==>空格
boolean ==>false
引用类型变量==>null
局部变量：一定要显式的赋值。（局部变量没有默认初始化值）
4.二者在内存中存放的位置不同:成员变量存在于堆空间中；局部变量：栈空间中

总结：关于变量的分类：
1）按照数据类型的不同：基本数据类型（8种） & 引用数据类型
2）按照声明的位置的不同：成员变量 & 局部变量

【方法】：提供某种功能的实现
1）实例：
public void eat(){//方法体}
public String getName(){}
public void setName(String n){}

2）关于返回值类型：
void：表明此方法不需要返回值
有返回值的方法：在方法的最后一定有return + 返回值类型对应的变量
记忆：void 与return不可以同时出现一个方法内。像一对“冤家”。

3）方法内可以调用本类的其他方法或属性，但是不能在方法内再定义方法！

面向对象编程的思想的落地法则一

1）设计并创建类及类的成分
2）实例化类的对象
3）通过“对象.属性”或”对象.方法”的形式完成某项功能

类的初始化的内存解析

4.1 内存划分的结构：
栈(stack):局部变量、对象的引用名、数组的引用名
堆(heap):new 出来的“东西”（如：对象的实体，数组的实体），含成员变量
方法区:含字符串常量
静态域：声明为static的变量

4.2 理解的基础上，学会基本的创建的类的对象在内存中的运行。

2.方法的重载

方法的重载（overload）
要求：1.同一个类中 2.方法名必须相同 3.方法的参数列表不同
（①参数的个数不同②参数类型不同）
补充：方法的重载与方法的返回值类型没有关系！

//如下的四个方法构成重载
//定义两个int型变量的和
public int getSum(int i,int j){return i + j;
}
//定义三个int型变量的和
public int getSum(int i,int j,int k){return i + j + k;
}
//定义两个double型数据的和
public double getSum(double d1,double d2){return d1 + d2;
}//定义三个double型数组的和
public void getSum(double d1,double d2,double d3){System.out.println(d1 + d2 + d3);
}
//不能与如上的几个方法构成重载
//  public int getSum1(int i,int j,int k){
//      return i + j + k;
//  }
//  public void getSum(int i,int j,int k){
//      System.out.println(i + j + k);
//  }//以下的两个方法构成重载。
public void method1(int i,String str){}
public void method1(String str1,int j){}

3.可变个数的形参的方法

可变个数的形参的方法：
1.格式：对于方法的形参：数据类型 … 形参名
2.可变个数的形参的方法与同名的方法之间构成重载
3.可变个数的形参在调用时，个数从0开始，到无穷多个都可以。
4.使用可变多个形参的方法与方法的形参使用数组是一致的。
5.若方法中存在可变个数的形参，那么一定要声明在方法形参的最后。
6.在一个方法中，最多声明一个可变个数的形参。

//如下四个方法构成重载
//在类中一旦定义了重载的可变个数的形参的方法以后，如下的两个方法可以省略
//  public void sayHello(){
//      System.out.println("hello world!");
//  }
//  public void sayHello(String str1){
//      System.out.println("hello " + str1);
//  }//可变个数的形参的方法public void sayHello(String ... args){for(int i = 0;i < args.length;i++){System.out.println(args[i] + "$");}//System.out.println("=====");}public void sayHello(int i,String ... args){//public void sayHello(String ... args,int i){System.out.println(i);for(int j = 0;j < args.length;j++){System.out.println(args[j] + "$");}}public void sayHello1(String[] args){for(int i = 0;i < args.length;i++){System.out.println(args[i]);}
}

4.java的值传递机制

方法的参数传递（重点、难点）
1. 形参：方法声明时，方法小括号内的参数
实参：调用方法时，实际传入的参数的值
2. 规则：java中的参数传递机制：值传递机制
1）形参是基本数据类型的：将实参的值传递给形参的基本数据类型的变量
2）形参是引用数据类型的：将实参的引用类型变量的值（对应的堆空间的对象实体的首地址值）传递给形参的引用类型变量。

【典型例题1】

public static void main(String[] args) {TestArgsTransfer tt = new TestArgsTransfer();       int i = 10;int j = 5;System.out.println("i:" + i + " j:" + j);//i : 10  j : 5//      //交换变量i与j的值
//      int temp = i;
//      i = j;
//      j = temp;tt.swap(i, j);//将i的值传递给m，j的值传递给nSystem.out.println("i:" + i + " j:" + j);//i : 10  j : 5}
//定义一个方法，交换两个变量的值
public void swap(int m,int n){int temp = m;m = n;n = temp;System.out.println("m:" + m + " n:" + n);}

使用swap方法以后：

【典型例题2】

public class TestArgsTransfer1 {public static void main(String[] args) {TestArgsTransfer1 tt = new TestArgsTransfer1();DataSwap ds = new DataSwap();System.out.println("ds.i:" + ds.i + " ds.j:" + ds.j);tt.swap(ds);System.out.println(ds);System.out.println("ds.i:" + ds.i + " ds.j:" + ds.j);}//交换元素的值public void swap(DataSwap d){int temp = d.i;d.i = d.j;d.j = temp;System.out.println(d);//打印引用变量d的值}
}class DataSwap{int i = 10;int j = 5;
}

5.面向对象的特征之一：封装性

一、面向对象的特征一：封装与隐藏
问题：当创建了类的对象以后，如果直接通过”对象.属性”的方式对相应的对象属性赋值的话，可能会出现不满足实际情况的意外，我们考虑不让对象来直接作用属性，而是通过”对象.方法”的形式，来控制对象对属性的访问。实际情况中，对属性的要求就可以通过方法来体现。

二、面向对象思想的落地法则二：
（封装性的思想）①将类的属性私有化，②提供公共的方法（setter & getter）来实现调用。

三、四种权限修饰符
1.权限从大到小为：public protected 缺省 private
2.四种权限都可以用来修饰属性、方法、构造器
3.修饰类的话：public 缺省

6.构造器(构造函数)

一、类的第三个成员：构造器(constructor 构造方法) construction CCB ICBC oop
constructor:建造者
构造器的作用：①创建对象 ②给创建的对象的属性赋值
1.设计类时，若不显式声明类的构造器的话，程序会默认提供一个空参的构造器.
2.一旦显式的定义类的构造器，那么默认的构造器就不再提供。
3.如何声明类的构造器。格式：权限修饰符类名(形参){ }
4.类的多个构造器之间构成重载

二、类对象的属性赋值的先后顺序：
①属性的默认初始化
③通过构造器给属性初始化
④通过”对象.方法”的方式给属性赋值

7.this关键字

this：
1.使用在类中，可以用来修饰属性、方法、构造器
2.表示当前对象或者是当前正在创建的对象
3.当形参与成员变量重名时，如果在方法内部需要使用成员变量，必须添加this来表明该变量时类成员
4.在任意方法内，如果使用当前类的成员变量或成员方法可以在其前面添加this，增强程序的阅读性
5.在构造器中使用“this(形参列表)”显式的调用本类中重载的其它的构造器

5.1 要求“this(形参列表)”要声明在构造器的首行！

5.2 类中若存在n个构造器，那么最多有n-1构造器中使用了this。

public class TestPerson {public static void main(String[] args) {Person p1 = new Person();System.out.println(p1.getName() + ":" + p1.getAge());Person p2 = new Person("BB",23);int temp = p2.compare(p1);System.out.println(temp);}
}
class Person{private String name;private int age;public Person(){this.name = "AA";this.age = 1;}public Person(String name){this();this.name = name;}public Person(String name,int age){this(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 eat(){System.out.println("eating");}public void sleep(){System.out.println("sleeping");this.eat();}//比较当前对象与形参的对象的age谁大。public int compare(Person p){if(this.age > p.age)return 1;else if(this.age < p.age)return -1;elsereturn 0;}
}

8.package/import

package:
声明源文件所在的包，写在程序的第一行。
每“.”一次，表示一层文件目录。
包名都要小写。

import:
1)显式导入指定包下的类或接口
2)写在包的声明和源文件之间
3)如果需要引入多个类或接口，那么就并列写出
4)如果导入的类是java.lang包下的，如：System String Math等，就不需要显式的声明。
5)理解.的概念。比如java.util.;
6)如何处理同名类的导入。如：在util包和sql包下同时存在Date类。
7)import static 表示导入指定类的static的属性或方法
8)导入java.lang.*只能导入lang包下的所有类或接口，不能导入lang的子包下的类或接口

//import java.util.Scanner;
//import java.util.Date;
//import java.util.List;
//import java.util.ArrayList;
import java.lang.reflect.Field;
import java.util.*;
import static java.lang.System.*;
public class TestPackageImport {public static void main(String[] args) {out.println("helloworld");Scanner s = new Scanner(System.in);s.next();Date d = new Date();List list = new ArrayList();java.sql.Date d1 = new java.sql.Date(522535114234L);Field f = null;}
}

第三章：Java_面向对象编程（一）相关推荐

Java_第08章_面向对象编程(高级)
第08章_面向对象编程(高级) 本章专题与脉络 1. 关键字:static 回顾类中的实例变量(即非static的成员变量) class Circle{private double radius;pu ...
python归一化增大差异_简学Python第六章__class面向对象编程与异常处理
Python第六章__class面向对象编程与异常处理欢迎加入Linux_Python学习群群号:478616847 目录: 面向对象的程序设计类和对象封装继承与派生多态与多态性特性pr ...
【Golang第8章：面向对象编程】Go语言的结构体是什么，怎么声明；Golang方法的调用和声明；go语言面向对象实例，go语言工厂模式；golang面向对象的三大特性：继承、封装、多态
介绍这个是在B站上看边看视频边做的笔记,这一章是Glang面向对象编程这一章内容较多,内容有Go语言的结构体是什么,怎么声明:Golang方法的调用和声明:go语言面向对象实例,go语言工厂模式: ...
第13章　面向对象编程
第13章面向对象编程 JavaScript是基于原型继承的机制来实现面向对象编程的.例如,对象直接量继承于Object.prototype,函数对象继承于Function.prototype,而pr ...
【编程实践】第二章 C++面向对象编程《C++程序设计语言》 / By 禅与计算机程序设计艺术ChatGPT
[编程实践]第二章 C++面向对象编程<C++程序设计语言> / By 禅与计算机程序设计艺术&ChatGPT 第二章 C++面向对象编程在C++中,面向对象编程主要通过类和对象 ...
java学习笔记-第七章：面向对象编程（基础部分）
第七章:面向对象编程(基础部分) 总体内容类与对象引出类与对象类与对象概述类与对象的关系示意图属性概念及其细节类与对象快速入门案例对象内存布局类与对象内存分配机制引申:java内存的 ...
《Kotlin 程序设计》第五章 Kotlin 面向对象编程（OOP）
第五章 Kotlin 面向对象编程(OOP) 正式上架:<Kotlin极简教程>Official on shelves: Kotlin Programming minimalist tut ...
第06章_面向对象编程（基础）
本章专题与脉络学习面向对象内容的三条主线 Java类及类的成员:(重点)属性.方法.构造器:(熟悉)代码块.内部类面向对象的特征:封装.继承.多态.(抽象) 其他关键字的使用:this.super ...
Linux/Unix系统编程手册第三章：系统编程概念
本章介绍系统编程的基础概念和一些后续章节用到的函数及头文件,并说明了可移植性问题. 系统调用是受控的内核入口,通过系统调用,进程可以请求内核以自己的名义去执行某些动作,比如创建子进程,执行I/O操作, ...

第三章：Java_面向对象编程（一）