本文详细讲解了Java面向对象编程的基础，包括类的成员、面向对象三大特性、关键字this和super的用法，以及内存解析、对象数组、匿名对象、方法重载、可变参数和值传递机制等内容。实例演示帮助理解面向对象编程实践。
引言：该内容为作者学习java期间所作笔记，学习参考尚硅谷系列视频。
03 面向对象(上)
3.1 概述
学习面向对象内容的三条主线
1.Java 类及类的成员：属性、方法、构造器、代码块、内部类
2.面向对象的三大特征：封装、继承、多态性、(抽象性)
3.其它关键字：this、super、static、final、abstract、interface、package、import 等
面向对象举例--把大象装进冰箱
1.面向过程:强调的是功能行为，以函数为最小单位，考虑怎么做。
① 打开冰箱
② 把大象装进冰箱
③ 把冰箱门关住
2.面向对象:强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
人{
打开(冰箱){
冰箱.开门();
}操作(大象){
大象.进入(冰箱);
}关闭(冰箱){
冰箱.关门();
}
}
冰箱{
开门(){
}
关门(){
}
}
大象{
进入(冰箱){
}
}
面向对象的两个要素
类:对一类事物的描述，是抽象的、概念上的定义
对象:是实际存在的该类事物的每个个体，因而也称为实 例(instance)。
可以理解为：类= 抽象概念的人；对象= 实实在在的某个人
3.2 内存解析
案例
Person p1= newPerson(); p1.name = "Tom"; p1.isMale = true; Person p2 = new Person(); sysout(p2.name);//null Person p3 = p1; p3.age = 10;//此时p1.age也是10
3.3 属性和方法
类中定义成员和方法，不能直接进行运算，可以写在代码块{}或者静态代码块中static{}中
3.3.1 属性（成员变量）vs 局部变量
1.相同点:
1.1 定义变量的格式:数据类型 变量名 = 变量值
1.2 先声明，后使用
1.3 变量都有其对应的作用域
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
局部变量:没有默认初始化值
意味着:在调用局部变量之前，一定要显式赋值。
特别地:形参在调用时,赋值即可
2.4 在内存中加载的位置，亦各不相同。
属性:加载到堆空间中(非 static)
局部变量:加载到栈空间
3.3.2 带返回值return的方法
返回值类型： 有返回值 vs 没有返回值 1 如果方法有返回值，则必须在方法声明时，指定返回值的类型。 *同时，方法中需要使用return关键字来返回指定类型的变量或常量：“return 数据”。 *如果方法没有返回值，则方法声明时，使用void来表示。通常，没有返回值的方法中，就不需要 使用return.但是，如果使用的话，只能“return;”表示结束此方法的意思。 2 我们定义方法该不该有返回值？ ① 题目要求 ② 凭经验：具体问题具体分析 3 return关键字的使用： 1.使用范围:使用在方法体中 2.作用:① 结束方法 ② 针对于有返回值类型的方法，使用"return 数据"方法返回所要的数据。 3.注意点:return关键字后不可声明执行语句。
3.4 对象数组的内存解析
引用类型的变量，只可能存储量两类值：null或地址值（含变量类型）
示例
public class JustTest {
public static void main(String[] args) {
Car[] car = new Car[5];
System.out.println(car); //[LCar;@723279cf
System.out.println(car[1]);//null
car[1] = new Car();
System.out.println(car[1]);//Car@b4c966a
}
}
class Car{
}
3.5 匿名对象
/*
* 匿名对象的使用
* 1.理解:我们创建的对象，没有显示的赋值给一个变量名。即为匿名对象。
* 2.特征：匿名对象只能调用一次。
* 3.使用:如下
*/
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，前面调用一次，这又是一个新的匿名对象，所以是0.0
//**************************************************
PhoneMall mall = new PhoneMall();
//开发中匿名对象的使用
mall.show(new Phone()); //在这里就相当于用了两次：send和play
}
}
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);
}
}
3.6 方法的重载overload
定义
-
在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
-
两同一不同：同一个类、相同方法名
参数列表不同：参数个数不同，参数类型不同(前后顺序不同也算)
-
与方法的返回值类型、权限修饰符、形参变量名、方法体都无关
示例
public static void main(String[] args) {
OverLoadTest test = new OverLoadTest();
test.getSum(1, 2); //调用的第一个，输出1
}
//如下的四个方法构成了重载
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){
}
3.7 可变个数形参
定义
允许直接定义能和多个实参相匹配的形参。从而，可以用一种更简单的方式，来传递个数可变的实参。
具体使用
-
可变个数形参的格式：数据类型 ... 变量名
-
当调用可变个数形参的方法时，传入的参数的个数可以是：0个，1个，2个...
-
可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载。
-
可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。即二者不可共存。
-
可变个数形参在方法中的形参中,必须声明在末尾。
-
可变个数形参在方法中的形参中，最多只能声明一个可变形参。
示例
//1.不共存
public void show(String ... strs) {
for (int i = 0; i < strs.length; i++) {//也有length属性
System.out.println(strs[i]);
}
}
// 此方法与上一方法不可共存
// public void show(String[] strs){
//
// }
//2.必须末尾
public void show(String ... strs,int i) {//错误，会报错
}
public void show(int i，String ... strs) {//正确
}
3.8 方法参数的值传递机制（重点）
关于变量的赋值
-
如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
-
如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。
3.8.1 对于基本数据类型
/*
* 方法的形参的传递机制：值传递
*
* 1.形参：方法定义时，声明的小括号内的参数
* 实参：方法调用时，实际传递给形参的数据
* 2.值传递机制：
* 如果参数是基本数据类型，此时实参赋值给形参的是实参真是存储的数据值。
*/
public class ValueTransferTest1 {
public static void main(String[] args) {
int m = 10;
int n = 20;
System.out.println("m = " + m + ", n = " + n);
//交换两个变量的值的操作
// int temp = m;
// m = n;
// n = temp;
ValueTransferTest1 test = new ValueTransferTest1();
test.swap(m, n);
System.out.println("m = " + m + ", n = " + n); //发现m与n并未交换
}
public void swap(int m,int n){
int temp = m;
m = n;
n = temp;
}
}
3.8.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和n的值
// int temp = data.m;
// data.m = data.n;
// data.n = temp;
ValueTransferTest2 test = new ValueTransferTest2();
test.swap(data);//因为把地址赋给了形参，一换都换
System.out.println("m = " + data.m + ", n = " + data.n);
}
public void swap(Data data){
int temp = data.m;
data.m = data.n;
data.n = temp;
}
}
class Data{
int m;
int n;
}
3.8.3 相关题目
题目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);
}
public void second(Value v,int i){
i=0;
v.i=20;
Value val=new Value();
v=val;
System.out.println(v.i+" "+i);
}
}
class Value {
int i= 15;
}
题目2
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);//使程序强制结束跳过main中的两个println
}
题目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];
}
//正确写法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;
}
题目4
public class CircleTest {
public static void main(String[] args) {
PassObject p = new PassObject();
p.printAreas(new Circle(), 5);
}
}
class Circle{
double radius;
public double findArea(){
return Math.PI * radius * radius;
}
}
class PassObject{
public void printAreas(Circle c, int time){
System.out.println("Radius\t\t\tArea");
for (int i = 0;i < time;i++){
c.radius = (double)(i+1);
System.out.println(c.radius + "\t\t\t" + c.findArea());
}
}
}
3.9 递归
概念
1.递归方法：一个方法体内调用它自身。
2.方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
3.递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。
示例
// 例1:计算1-n之间所有自然数的和
public int getSum(int n) {
if (n == 1) {
return 1;
} else {
return n + getSum(n - 1);
}
}
// 例2:计算1-n之间所有自然数的乘积
//归求阶乘(n!)的算法
public int getSum1(int n) {
if (n == 1) {
return 1;
} else {
return n * getSum1(n - 1);
}
}
//例4:已知一个数列：f(20) = 1,f(21) = 4,f(n+2) = 2*f(n+1)+f(n),
//其中n是大于0的整数，求f(10)的值。
public int f1(int n){
if(n == 20){
return 1;
}else if(n == 21){
return 4;
}else{
return 2*f1(n-1) + f1(n-2);//关键，把n+改为n-
}
}
3.10 封装和隐藏
把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。
示例
/*
面向对象的特征一:封装与隐藏
一、问题的引入：
当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。这里，赋值操作要受到属性的数据类型和存储范围的制约。但除此之外，没有其他制约条件。但是，实际问题中，我们往往需要给属性赋值加入额外限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行条件的添加。比如说，setLegs同时，我们需要避免用户再使用“对象.属性”的方式对属性进行赋值。则需要将属性声明为私有的(private) ，此时，针对于属性就体现了封装性。
二、封装性的体现：
我们将类的属性私有化(private),同时,提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值。
拓展：封装性的体现：① 如上 ② 单例模式 ③ 不对外暴露的私有方法 ...
*/
public class AnimalTest {
public static void main(String[] args) {
Animal a = new Animal();
a.name = "大黄";
// a.legs = 4;//The field Animal.legs is not visible
a.show();
// a.setLegs(6);
a.setLegs(-6);
// a.legs = -4;//The field Animal.legs is not visible
a.show();
System.out.println(a.name);
System.out.println(a.getLegs());
}
}
class Animal{
String name;
private int age; //加上private则只能在类里使用，所以在main中就没法直接赋值了
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);
}
//提供关于属性 age 的 get 和 set 方法
public int getAge(){
return age;
}
public void setAge(int a){
age = a;
}
}
3.11 四种权限修饰符
封装性的体现，需要权限修饰符来配合。 1.Java 规定的 4 种权限：(从小到大排序)private、缺省、protected、public 2.4 种权限用来修饰类及类的内部结构：属性、方法、构造器、内部类 3.具体的，4 种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类 修饰类的话，只能使用：缺省、public 总结封装性：Java 提供了 4 中权限修饰符来修饰类积累的内部结构，体现类及类的内部结构的可见性的方法。
3.12 构造器
概念
类的结构之三:构造器(构造方法、constructor)
一、构造器的作用:
1.创建对象
2.初始化对象的属性（这样就不必每次实例化时都进行赋值了，出生就有某种属性）
二、说明
1.如果没有显示的定义类的构造器的话，则系统默认提供一个空参的构造器。
2.定义构造器的格式：权限修饰符 类名(形参列表) { }
3.一个类中定义的多个构造器，彼此构成重载。
4.一旦显示的定义了类的构造器之后，系统不再提供默认的空参构造器。
5.一个类中，至少会有一个构造器
示例
public class PersonTest {
public static void main(String[] args) {
//创建类的对象:new + 构造器
Person p = new Person(); //Person()这就是构造器
p.eat();
Person p1 = new Person("Tom");
System.out.println(p1.name);
}
}
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("人学习");
}
}
3.12 总结属性赋值的过程
/*
* 总结:属性赋值的先后顺序
*
* ① 默认初始化值
* ② 显式初始化
* ③ 构造器中赋值
* ④ 通过"对象.方法" 或 “对象.属性”的方式，赋值
*
* 以上操作的先后顺序:① - ② - ③ - ④
*
*/
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);
System.out.println(u1.age);//3
}
}
class User{
String name;
int age = 1;//显式
public User(){}
public User(int a){//构造器
age = a;
}
public void setAge(int a){//对象方法赋值
age = a;
}
}
3.13 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;
}
}
3.14 UML类图
-
+表示 public 类型，-表示 private 类型，#表示 protected 类型
3.15 关键字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();//关键！调了Person（）构造器
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;
}
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("学习");
}
}
3.16 关键字package、import
package
package关键字的使用 1.为了更好的实现项目中类的管理，提供包的概念 2.使用package声明类或接口所属的包，声明在源文件的首行 3.包，属于标识符，遵循标识符的命名规则、规范"见名知意" 4.每“.”一次,就代表一层文件目录。 补充:同一个包下，不能命名同名接口或同名类 不同包下，可以命名同名的接口、类。
improt
import关键字的使用 import:导入 1.在源文件中显式的使用import结构导入指定包下的类、接口 2.声明在包的声明和类的声明之间 3.如果需要导入多个结构，则并列写出即可 4.可以使用"xxx.*"的方式,表示可以导入xxx包下的所有结构。 5.如果导入的类或接口是java.lang包下的，或者是当前包下的，则可以省略此import语句。 6.如果在代码中使用不同包下的同名的类。那么就需要使用类的全类名的方式指明调用的是哪个。 7.如果已经导入java.a包下的类。那么如果需要使用a包的子包下的类的话，仍然需要导入。 8.import static组合的使用：调用指定类或接口下的静态的属性或方法.
扫一扫
916
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
