Java学习笔记_第一阶段_1.8 面向对象编程（基础）
1.8 面向对象编程（基础）
类与对象
-
类与对象的关系
-
类就是数据类型
-
对象就是一个具体的实例
public class Object01 { public static void main(String[] args) { //1. new Cat() 创建一只猫 //2. Cat cat1 = new Cat(); 把创建的猫赋给 cat1 //3. cat1 就是一个对象 Cat cat1 = new Cat(); cat1.name = "小白"; cat1.age = 3; cat1.color = "白色"; cat1.weight = 10; //创建了第二只猫，并赋给 cat2 //cat2 也是一个对象 Cat cat2 = new Cat(); cat2.name = "小花"; cat2.age = 100; cat2.color = "花色"; cat2.weight = 20; //使用 访问对象的属性 System.out.println("第一只猫信息：" + cat1.name + " " + cat1.age + " " + cat1.color + " " + cat1.weight); System.out.println("第二只猫信息：" + cat2.name + " " + cat2.age + " " + cat2.color + " " + cat2.weight); } } //定义一个猫类 Cat -> 自定义的数据类型 class Cat { //属性 String name;//名字 int age;//年龄 String color;//颜色 double weight;//体重 }- 类是抽象的，概念的，代表一类事物，是数据类型
- 对象是具体的，实际的，代表一个具体事物，是实例.
- 类是对象的模板，对象是类的一个个体，对应一个实例
-
-
对象在内存中存在形式
-
属性/成员变量
-
基本介绍
- 从概念或叫法上看：成员变量 = 属性 = field字段（即 成员变量是用来表示属性的）
- 属性是类的一个组成部分，一般是基本数据类型，也可是引用类型（对象，数组）
-
注意事项和细节说明
-
属性的定义语法同变量，示例：访问修饰符 属性类型 属性名;
访问修饰符：控制属性的访问范围
有四种访问修饰符：public protected 默认 private
-
属性的定义类型可以为任意类型，包含基本类型或引用类型
-
属性如果不赋值，有默认值，规则和数组一致
数据类型 默认值 数据类型 默认值 数据类型 默认值 int 0 short 0 byte 0 long 0 float 0.0 double 0.0 char \u0000 boolean false String null
-
-
-
如何创建对象
-
先声明再创建
Cat cat;//声明对象 cat cat = new Cat();//创建 -
直接创建
Cat cat = new Cat();
-
-
如何访问属性
基本语法：
对象名.属性名;
-
类和对象的内存分配机制（重要）
看一个思考题
定义一个人类(Person)（包括 名字，年龄）
Person p1 = new Person(); p1.age = 10; p1.name = "小明"; Person p2 = p1;//把p1赋给p2，让p2指向p1 System.out.println(p2.age);
-
Java内存的结构分析
- 栈：一般存放基本数据类型（局部变量）
- 堆：存放对象（Cat cat，数组等）
- 方法区：常量池（常量，比如字符串），类加载信息
-
Java创建对象的流程简单分析
Person p = new Person(); p.name = "jack"; p.age = 10;- 先加载Person类信息（属性和方法信息，只会加载一次）
- 在堆中分配空间，进行默认初始化（看规则）
- 把堆中地址赋给p，p就指向堆中的对象
- 进行指定初始化，比如 p.name = "jack"; p.age = 10;
Person a = new Person(); a.age = 10; a.name = "小明"; Person b; b = a; System.out.println(b.name);//小明 b.age = 200; b = null; System.out.println(a.age);//200 System.out.println(b.age);//出现异常 -
成员方法
-
基本介绍
在某些情况下，我们需要定义成员方法（简称方法）。比如人类：除了有一些属性外（年龄，姓名...），我们人类还有一些行为比如：可以说话、跑步...，通过学习，还可以做算术题。这时就要用成员方法才能实现。
public class Method01 { public static void main(String[] args) { //方法使用 //1. 方法写好后，如果不去调用（使用），不会输出 //2. 先创建对象，然后调用方法即可 Person p1 = new Person(); p1.speak();//调用方法 p1.cal01();//调用cal01方法 p1.cal02(5);//调用cal02方法，同时给n=5 //调用getSum方法，同时num1=10，num2=20 //把方法getSum返回的值，赋给变量returnRes int resturnRes = p1.getSum(10, 20); System.out.println("getSum方法返回的值=" + resturnRes); } } class Person { String name; int age; //方法（成员方法） //添加speak 成员方法，输出“我是一个好人” //1. public：表示方法是公开的 //2. void：表示方法没有返回值 //3. speak()：speak是方法名，()形参列表 //4. {}：方法体，可以写我们要执行的代码； //5. System.out.println("我是一个好人"); 表示我们的方法就是输出一句话 public void speak() { System.out.println("我是一个好人"); } //添加cal01 成员方法，可以计算从1+...+1000的结果 public void cal01() { //循环完成 int res = 0; for (int i = 1;i <= 1000;i++) { res += i; } System.out.println("计算结果=" + res); } //添加cal02 成员方法，该方法可以接受一个数n，计算从1+...+n的结果 //1. (int n) 形参列表，表示当前有一个形参n，可以接受用户输入 public void cal02(int n) { int res = 0; for (int i = 1;i <= n;i++) { res += i; } System.out.println("计算结果=" + res); } //添加getSum成员方法，可以计算两个数的和 //1. public：表示方法是公开的 //2. int：表示方法执行后，返回一个int值 //3. getSum：方法名 //4. (int num1, int num2) 形参列表，2个形参，可以接受用户传入的两个数 //5. return res; 表示把res值，返回 public int getSum(int num1, int num2) { int res = num1 + num2; return res; } } -
成员方法的定义
访问修饰符 返回数据类型 方法名(形参列表...) { 语句; return 返回值; }- 形参列表：表示成员方法输入
- 数据类型（返回类型）：表示成员方法输出，void表示没有返回值
- 方法主体：表示为了实现某一功能代码块
- return 语句不是必须的
-
方法的调用机制原理
-
成员方法的好处
- 提高代码的复用性
- 可以将实现的细节封装起来，然后供其他用户来调用即可
-
注意事项和使用细节
-
访问修饰符（作用是控制方法使用的范围）
有四种：public protected 默认 private
-
返回数据类型
- 一个方法最多有一个返回值，如果返回多个，返回数组
- 返回类型可以为任意类型，包含基本类型或引用类型（数组，对象）
- 如果方法要求有返回数据类型，则方法体中最后的执行语句必须为return值，而且要求返回值类型必须和return的值类型一致或兼容
- 如果方法是void，则方法体中可以没有return语句，或者只写return
-
方法名
遵循驼峰命名法，最好见名知意，表达出该功能的意思即可，比如得到两个数的和getSum，开发中按照规范
-
形参列表
- 一个方法可以有0个参数，也可以有多个参数，中间用逗号隔开
- 参数类型可以为任意类型，包含基本类型或引用类型
- 调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型的参数
- 方法定义时的参数称为形式参数，简称形参；方法调用时的传入参数称为实际参数，简称实参；实参和形参的类型要一直或兼容，个数、顺序必须一致
-
方法体
里面写完成功能的具体的语句，可以为输入、输出、变量、运算、分支、循环、方法调用，但里面不能再定义方法。即：方法不能嵌套定义
-
方法调用细节说明
- 同一个类中的方法调用：直接调用即可
- 跨类中的方法A类调用B类方法：需要通过对象名调用
- 跨类的方法调用和方法的访问修饰符相关
-
成员方法传参机制
-
基本数据类型的传参机制
public class MethodParameter01 { public static void main(String[] args) { int a = 10; int b = 20; A obj = new A(); obj.swap(a,b); System.out.println("main方法 a=" + a + " b=" + b);//a=10 b=20 } } class A { public void swap(int a, int b) { System.out.println("\na和b交换之前的值\na=" + a + "\tb=" + b);//a=10 b=20 //完成了a和b的交换 int temp = a; a = b; b = temp; System.out.println("\na和b交换之后的值\na=" + a + "\tb=" + b);//a=20 b=10 } }基本数据类型，传递的是值（值拷贝），形参的任何改变不影响实参
-
引用数据类型的传参机制
引用类型传递的是地址（传递的也是值，但是值是地址），可以用过形参影响实参
例：编写一个方法copyPerson，可以赋值一个Person对象，返回复制的对象。克隆对象，注意要求得到新对象和原来的对象是两个独立的对象，只是他们的属性相同。
public class MethodEx02 {
public static void main(String[] args) {
Person p = new Person();
p.name = "milan";
p.age = 100;
//创建tools
MyTools tools = new MyTools();
Person p2 = tools.copyPerson(p);
//到此p和p2是Person对象，但是是两个独立的对象，属性相同
System.out.println("p的属性 name=" + p.name + " age=" + p.age);
System.out.println("p2的属性 name=" + p2.name + " age=" + p2.age);
//可以通过对象比较看看是否为同一个对象
System.out.println(p == p2);
//也可以通过输出对象的hashCode看看对象是否是一个
System.out.println("p的hashCode="+ p.hashCode());
System.out.println("p2的hashCode="+ p2.hashCode());
}
}
class Person {
String name;
int age;
}
class MyTools {
public Person copyPerson(Person p) {
//创建一个新的对象
Person p2 = new Person();
p2.name = p.name;//把原来对象的名字赋给p2.name
p2.age = p.age;//把原来对象的年龄赋给p2.age
return p2;
}
}
方法递归调用
-
递归就是方法自己调用自己，每次调用时传入不同的变量
递归有助于编程者解决复杂问题，同时可以让代码变得简洁
-
递归能解决什么问题
- 各种数学问题如：8皇后问题，汉诺塔，阶乘问题，迷宫问题，球和篮子的问题（google编程大赛）
- 各种算法中也会使用到递归，比如快排，归并排序，二分查找，分治算法等
- 将用栈解决的问题-->递归代码比较简洁
例1：打印问题
public class Recursion01 {
public static void main(String[] args) {
T t1 = new T();
t1.test(4);//n=2 n=3 n=4
}
}
class T {
public void test(int n) {
if (n > 2) {
test(n-1);
}
System.out.println("n=" + n);
}
}
例2：阶乘问题
public class Recursion01 {
public static void main(String[] args) {
int res = t1.factorial(5);
System.out.println("res=" + res);//120
}
}
class T {
public int factorial(int n) {
if (n == 1) {
return 1;
} else {
return factorial(n-1) * n;
}
}
}
- 递归重要规则
- 执行一个方法时，就创建一个新的受保护的独立空间（栈空间）
- 方法的局部变量是独立的，不会相互影响
- 如果方法中使用的是引用类型变量（比如数组、对象），就会共享该引用类型的数据
- 递归必须向退出递归的条件逼近，否则就是无限递归，出现StackOverflowError，死龟了
- 当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，谁将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕
例1：请使用递归的方法求出斐波那契数1，1，2，3，5，8，13...，给你一个整数n求出它的值是多少
public class RecursionExe01 {
public static void main(String[] args) {
T1 num = new T1();
System.out.println(num.getFibonacciNum(7));
}
}
class T1 {
public int getFibonacciNum(int n) {
if (n >= 1) {
if (n == 1 || n == 2) {
return 1;
} else {
return getFibonacciNum(n-1) + getFibonacciNum(n-2);
}
} else {
System.out.println("要求输入的n>=1的整数");
return -1;
}
}
}
例2：猴子吃桃子问题：有一堆桃子，猴子第一天吃了其中的一半，并再多吃了一个，以后每天猴子都吃其中的一半，然后再多吃一个。当到第10天时，想再吃时（即还没吃），发现只有1个桃子了。问题：最初共多少个桃子？
public class RecursionExe02 {
public static void main(String[] args) {
T2 t = new T2();
System.out.println(t.getPeachNum(1));
}
}
class T2 {
public int getPeachNum(int day) {
if (day == 10) {
return 1;
} else if (day >= 1 && day <= 9) {
return (getPeachNum(day + 1) + 1) * 2;
} else {
System.out.println("day在1-10");
return -1;
}
}
}
方法重载(overload)
-
基本介绍
java中允许用一个类中，多个同名方法的存在，但要求形参列表不一致
比如：System.out.println(); out是PrintStream类型
public class OverLoad01 { public static void main(String[] args) { System.out.println(100); System.out.println("hello, world"); System.out.println(true); } } -
重载的好处
- 减轻了起名的麻烦
- 减轻了记名的麻烦
例：
public class MyCalculator {
public static void main(String[] args) {
Calculator mc = new Calculator();
System.out.println(mc.calculate(1,2));
System.out.println(mc.calculate(1.1,2));
System.out.println(mc.calculate(1,2.2));
System.out.println(mc.calculate(1,2,3));
}
}
class Calculator{
//下面的四个calculate方法构成了重载
public int calculate(int n1, int n2){//两个整数的和
System.out.println("calculate(int n1, int n2) 被调用");
return n1 + n2;
}
public double calculate(int n1, double n2){//一个整数，一个double的和
System.out.println("calculate(int n1, double n2) 被调用");
return n1 + n2;
}
public double calculate(double n1, int n2){//一个double,一个整数的和
System.out.println("calculate(double n1, int n2) 被调用");
return n1 + n2;
}
public int calculate(int n1, int n2, int n3){//三个整数的和
System.out.println("calculate(int n1, int n2, int n3) 被调用");
return n1 + n2 + n3;
}
}
- 注意事项和使用细节
- 方法名：必须相同
- 形参列表：必须不同（形参类型或个数或顺序，至少有一样不用，参数名无要求）
- 返回类型：无要求
可变参数
-
基本概念
java允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法
就可以通过可变参数实现
-
基本语法
访问修饰符 返回类型 方法名(数据类型... 形参名){ }例：
public class VarParameter01 { public static void main(String[] args) { Methods03 m = new Methods03(); System.out.println(m.sum(1,5,100)); } } class Methods03{ //可以计算2个数的和，3个数的和，4，5... //可以使用方法重载 // public int sum(int n1, int n2) {//2个数的和 // return n1 + n2; // } // public int sum(int n1, int n2, int n3) {//3个数的和 // return n1 + n2 + n3; // } // public int sum(int n1, int n2, int n3, int n4) {//4个数的和 // return n1 + n2 + n3 + n4; // } //上面的三个方法名称相同，功能相同，参数个数不同->使用可变参数优化 //1. int...表示接收的是可变参数，类型是int，即可以接收多个int(0-多) //2. 使用可变参数时，可以当作数组来使用，即 nums 可以当作数组 public int sum(int... nums) { //System.out.println("接收的参数个数=" + nums.length); int res = 0; for (int i = 0; i < nums.length;i++){ res += nums[i]; } return res; } } -
注意事项和使用细节
-
可变参数的实参可以为0个或任意多个
-
可变参数的实参可以为数组
public class VarParameter01 { public static void main(String[] args) { int[] arr = {1,5,100}; Methods03 m = new Methods03(); System.out.println(m.f1(arr)); } } class Methods03{ public void f1(int... nums) { System.out.println("接收的参数个数=" + nums.length);//3 } } -
可变参数的本质就是数组
-
可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
public class VarParameter01 { public static void main(String[] args) { int[] arr = {1,5,100}; Methods03 m = new Methods03(); System.out.println(m.f2(arr)); } } class Methods03{ public void f2(String str, double... nums) { System.out.println("接收的参数个数=" + nums.length);//3 } } -
一个形参列表中只能出现一个可变参数
-
例：有三个方法，分别实现返回姓名和两门课程成绩（总分），返回姓名和三门课成绩（总分），返回姓名和五门课成绩（宗门），封装成一个可变参数的方法
public class VarParameterExe {
public static void main(String[] args) {
Methods04 m = new Methods04();
System.out.println(m.showScore("李明",60.5,80,75));
}
}
class Methods04 {
public String showScore(String name, double... score) {
double totalScore = 0;
for (int i = 1; i < score.length;i++) {
totalScore += score[i];
}
return name + "的" + score.length + "门课总共成绩=" + totalScore;
}
}
作用域
-
基本使用
面向对象中，变量作用域是非常重要的知识点
-
在Java编程中，主要的变量就是属性（成员变量）和局部变量
-
我们说的局部变量一般是指在成员方法中定义的变量
-
Java中作用域的分类
全局变量：也就是属性，作用域为整个类体
局部变量：也就是除了属性之外的其他变量，作用域为定义它的代码块中
-
全局变量可以不赋值，直接使用，因为有默认值，局部变量必须赋值后，才能使用，因为没有默认值
public class VarScope { public static void main(String[] args) { } } class Cats { //全局变量：也就是属性，作用域为整个类体 Cats 类：cry eat等方法使用属性 //属性在定义时，可以直接赋值 int age = 10;//指定的值是 10 //全局变量可以不赋值，直接使用，因为有默认值 double weight;//默认值是0.0 public void hi() { //局部变量必须赋值后，才能使用，因为没有默认值 int num = 1; int address; System.out.println("num=" + num); System.out.println("address=" + address);//错误 System.out.println("weight=" + weight); } public void cry() { //1. 局部变量一般是指在成员方法中定义的变量 //2. n 和 name 就是局部变量 //3. n 和 name 的作用域在 cry 方法中 int n = 10; String name = "jack"; System.out.println("在cry中使用属性 age=" + age); } public void eat() { System.out.println("在eat中使用属性 age=" + age); System.out.println("在eat中使用cry的变量 name=" + name);//错误 } } -
-
注意事项和使用细节
-
属性和局部变量可以重名，访问时遵循就近原则
public class VarScopeDetail { public static void main(String[] args) { Persons p1 = new Persons(); p1.say();//king } } class Persons { String name = "jack"; public void say() { String name = "king"; System.out.println("say() name=" + name); } } -
同一个作用域中，比如在同一个成员方法中，两个局部变量，不能重名
-
属性生命周期较长，伴随着对象的创建而创建，伴随着对象的销毁而销毁。局部变量，生命周期短，伴随着它的代码块的执行而创建，伴随着代码块的结束而销毁，即在一次方法调用过程中生效。
-
作用域范围不同、
全局变量/属性：可以被本类使用，或其他类使用
局部变量：只能在本类中对应的方法中使用
-
修饰符不同
全局变量/属性可以加修饰符（public protected private...）
局部变量不可以加修饰符
-
构造器
前面在创建人类的对象时，是先把一个对象创建好后，再给他的年龄和姓名属性赋值，如果现在要求，在创建人类的对象时，就直接指定这个对象的年龄和姓名，这时候就可以使用构造器
-
基本介绍
构造方法又叫构造器（constructor），是类的一种特殊的方法，它的主要作用是完成对新对象的初始化。
它有几个特点：
- 方法名和类名相同
- 没有返回值
- 在创建对象时，系统会自动的调用该类的构造器完成对对象的初始化
-
基本语法
[修饰符] 方法名(形参列表){ 方法体; }- 构造器的修饰符可以默认，也可以是public protected private
- 构造器没有返回值
- 方法名和类名字必须一样
- 参数列表和成员方法一样的规则
- 构造器的调用由系统完成
例：
public class Constructor01 {
public static void main(String[] args) {
//当我们new一个对象时，直接通过构造器指定名字和年龄
Person01 p1 = new Person01("smith", 80);
System.out.println("p1的信息如下");
System.out.println("p1对象name=" + p1.name);
System.out.println("p1对象age=" + p1.age);
}
}
class Person01 {
String name;
int age;
//构造器
//1. 构造器没有返回值，也不能写void
//2. 构造器的名称和类名Person01一样
//3. (String pName, int pAge) 是构造器形参列表，规则和成员方法一样
public Person01(String pName, int pAge) {
System.out.println("构造器被调用");
name = pName;
age = pAge;
}
}
-
注意事项和使用细节
-
一个类可以定义不同的构造器，即构造器重载
比如：我们可以在给Person类定义一个构造器，用来创建对象的时候，只指定人名，不需要指定年龄
public class ConstructorDetail { public static void main(String[] args) { Person03 p1 = new Person03("king", 40); Person03 p2 = new Person03("tom"); } } class Person03 { String name; int age; //第一个构造器 public Person03(String pName, int pAge) { name = pName; age = pAge; } //第二个构造器，只指定人名，不需要指定年龄 public Person03(String pName) { name = pName; } } -
构造器名和类名要相同
-
构造器没有返回值
-
构造器是完成对象的初始化，并不是创建对象
-
在创建对象时，系统自动的调用该类的构造方法
-
如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造器（也叫默认构造器）
比如Dog(){}，使用javap指令，反编译看看
class Dog{ /* 默认构造器 Dog() { } */ }注：javap的使用
-
javap是JDK提供的一个命令行工具，javap能对给定的class文件提供的字节代码进行反编译
-
通过它，可以对照源代码和字节码，从而了解很多编译器内部的工作，对更深入地理解如何提高程序执行的效率等问题由极大的帮助
-
使用格式：
javap <options> <classes>
常用：javap -c -v 类名
指令 含义 -help --help -? 输出此用法信息 -version 版本信息 -v -verbose 输出附加信息 -l 输出行号和本地变量表 -public 仅显示公共类和成员 -protected 显示受保护的/公共类和成员 -package 显示程序包/受保护的/公共类和成员（默认） -p -private 显示所有类和成员 -c 对代码进行反汇编 -s 输出内部类型签名 -sysinfo 显示正在处理的类
-
-
一旦定义了自己的构造器，默认的构造器就覆盖了，就不能再使用默认的无参构造器。除非显式的定义以下，即：Dog(){}（这点很重要）
-
-
对象创建的流程分析
class Person { int age = 90; String name; Person(String n, int a) { name = n; age = a; } }-
加载Person类信息(Person.class)，只会加载一次
-
在堆中分配空间（地址）
-
完成对象初始化
-
默认初始化
age = 0; name = null;
-
显式初始化
age = 90; name = null;
-
构造器的初始化
age = 20; name = "小倩";
-
-
把对象在堆中的地址返回给p（p是对象名，也可以理解成是对象的引用）
-
this
public class This01 {
public static void main(String[] args) {
Dog01 d = new Dog01("大黄", 2);
}
}
class Dog01 {
String name;
int age;
// public Dog01(String dName, int dAge) {
// name = dName;
// age = dAge;
// }
//如果我们构造器的形参，能够直接写成属性名，就更好了
//但是出现了一个问题，根据变量的作用域原则
//构造器的name，age 是局部变量，而不是属性
//==>引出this关键字来解决
public Dog01(String name, int age) {
this.name = name;
this.age = age;
}
public void info() {
System.out.println(name + "\t" + age + "\t");
}
}
-
什么是this
java虚拟机会给每个对象分配this，代表当前对象。
-
哪个对象调用，this就代表哪个对象
-
注意事项和使用细节
-
this关键字可以用来访问本类的属性、方法、构造器
-
this用于区分当前类的属性和局部变量
public class ThisDetal { public static void main(String[] args) { T0 t = new T0(); t.f2(); } } class T0 { String name = "jack"; int num = 100; public void f3() { String name = "smith"; //传统方法 System.out.println("name=" + name + " num=" + num);//smith 100 //也可以使用this访问属性 System.out.println("name=" + this.name + " num=" + this.num);//jack 100 } } -
访问成员方法的语法：this.方法名(参数列表);
public class ThisDetal { public static void main(String[] args) { T0 t = new T0(); t.f2(); } } class T0 { public void f1() { System.out.println("f1() 方法.."); } public void f2() { System.out.println("f2() 方法.."); //调用本类的 f1 //第一种方式 f1(); //第二种方式 this.f1(); } } -
访问构造器语法：this(参数列表); 注意只能在构造器中使用（即只能在构造器中访问另外一个构造器，且必须放在第一条语句）nu
public class ThisDetal { public static void main(String[] args) { T0 t = new T0(); } } class T0 { public T0() { //这里去访问 T0(String name, int age) 构造器 this("jack",100); System.out.println("T() 构造器"); } public T0(String name, int age) { System.out.println("T0(String name, int age) 构造器"); } } -
this不能在类定义的外部使用，只能在类定义的方法中使用
-
