• 第六章：面向对象编程（基础部分）

    目录

    一、类与对象

    1.定义：

    2.案例：使用面向对象解决养猫问题

    3.对象的内存：

    4.属性的概念：

    5.如何创建对象：

    6.访问对象：

    7.对象分配机制：

    8.java创建对象的流程分析：

    9.练习：输出的是   小明、200、空指针报错

    二、成员方法

    1.定义：

    2.有参方法，无参方法，带返回值方法：

    3.方法的调用机制(重要):

    4.方法的妙用：

    5.成员方法注意点：

    6.案例：

    7.方法的传参机制：

    ​编辑 8.案例:

    三、方法的递归

    1.定义：

    2.递归的调用机制，实践小案例：一定要认真看图 ：栈先进后出

    ​编辑 四、递归案例

    1.递归斐波那契数：1 1 2 3 5 8 13，给你一个数求他对应的斐波那契数是多少；

     2.有一堆桃子，猴子每天吃其中的一半，在多吃一个，到第十天，还没吃发现就剩1个了，求一共有多少桃子？  1534

    3.走迷宫：出迷宫

    4.汉诺塔的实现：把所有盘子放到b盘

    5.八皇后啊：两个皇后不能在同一个列于同一个斜线上（没解决）

    五、方法的重载

    1.定义：

    2.可变参数：

    六、作用域

    七、构造器

    1.定义：

    2.细节：

    八、对象的创建流程（面试题）很重要这个图

     九、this的用法

     1.定义：

    2.this的本质：

    3.注意：

    十、课后作用

    一、类与对象

    判断对象是否为同一个：使用hashCode方法

    1.定义：

            类是抽象的，概念的，代表一类人一类事物。对象是具体的，实际的代表一个具体事物，即实例。类是对象模板，对象是类的一个个体。

    2.案例：使用面向对象解决养猫问题

    1. public class Hello {
    2.     public static void main(String[] args) {
    3.         //实例化一只猫  cat1就是一个对象
    4.         Cat cat1 = new Cat();
    5.         cat1.name="kitti";
    6.         cat1.age=3;
    7.         cat1.color="white";
    8.         //创建第二只猫，并赋值给cat2
    9.         Cat cat2 = new Cat();
    10.         cat2.name="qiqi";
    11.         cat2.age=100;
    12.         cat2.color="red";
    13.         //访问属性
    14.         System.out.println("first cat name is:"+cat1.name+"age is"+cat1.age+"color is"+cat1.color);
    15.         System.out.println("second cat name is:"+cat1.name+"age is"+cat2.age+"color is"+cat2.color);
    16.     }
    17. }
    18.  
    19. //定义一个猫类 Cat -> 自定义数据类型
    20. class Cat{
    21.     //属性
    22.     String name;
    23.     int age;
    24.     String color;
    25. }

    3.对象的内存：

    4.属性的概念：

    定义：成员变量 = 属性 =filed(字段) 。属性可以是基本数据，也可以是引用数据类型。

    声明：访问修饰符 属性类型  属性名；如果不赋初始值，就会和数组一样有默认值

    5.如何创建对象：

            1.先声明在创建； Cat cat;声明对象        cat = new Cat();//创建 

            2.直接创建        Cat cat = new Cat();

    6.访问对象：

            对象名.属性名；

    7.对象分配机制：

    • 栈：一般存放基本数据类型(局部变量)
    • 堆：存放对象(Cat cat,数组等等)
    • 方法区：常量池(常量，字符串)，类加载信息

    8.java创建对象的流程分析：

    Person p = new Person()    p.name="jack"   p.age =10

    1. 先加载Person类信息（属性和方法信息，只会加载一次）
    2. 在堆中分配空间，进行初始化赋值(看规则)
    3. 把地址赋值给p,p就指向对象
    4. 进行指定初始化，比如 p.name="jack"   p.age =10

    9.练习：输出的是   小明、200、空指针报错

    二、成员方法

    1.定义：

            Person的成员方法speak，触发输出I can speak;

    1. public class Hello {
    2.     public static void main(String[] args) {
    3.         Person  p = new Person();
    4.         p.speak();
    5.     }
    6. }
    7.  
    8. class Person{ 
    9.     String name;
    10.     //public:公开 void：无返回值 speak()：方法名+形参列表  {}：方法体写执行的带啊吗 
    11.     public void speak(){
    12.         System.out.println("i can speak");
    13.     }
    14. }

    2.有参方法，无参方法，带返回值方法：

    1. class Person {
    2.     String name;
    3.     //public:公开 void：无返回值 speak()：方法名+形参列表  {}：方法体写执行的带啊吗
    4.     public void speak() {
    5.         System.out.println("i can speak");
    6.     }
    7.     public void grade(int n) {
    8.         System.out.println("grade is " + n);
    9.     }
    10.     public int  getAge() {
    11.         return age;
    12.     }
    13. }

    3.方法的调用机制(重要):

    4.方法的妙用：

            案例：输出打印数组

    1. public class Hello {
    2.     public static void main(String[] args) {
    3.         int[][] arr = {{1, 23, 5}, {6, 2, 4}, {2, 8}, {10}};
    4.         Tools tools = new Tools();
    5.         tools.map(arr);
    6.     }
    7. }
    8. class Tools {
    9.     public void map(int[][] arr) {
    10.         for (int i = 0; i < arr.length; i++) {
    11.             for (int j = 0; j < arr[i].length; j++) {
    12.                 System.out.print(arr[i][j] + "\t");
    13.             }
    14.             System.out.println();
    15.         }
    16.     }
    17. }

            好处：提高代码复用性，将实现细节封装起来。

    5.成员方法注意点：

    1. 访问修饰符 返沪数据类型 方法名 (形参列表){ 方法体 }

    2.  返回数据类型需要与return返回的数据兼容或相同

    3. 方法名采用小驼峰命名

    4. 参数列表，一个方法可以有零个参数，也可以有多个参数，中间用逗号隔开，参数也是兼容或相等即可（byte可以传给int）

    5. public void sum(int a) a:形参    sum(10)  10:实参

    6. 同一个类当中，方法调用直接写"方法名()"，不同类，先实例化对象，然后 对象.方法名();

    6.案例：

            1.判断一个数为奇数还是偶数：

    1. import java.util.*;
    2.  
    3. public class Hello {
    4.     public static void main(String[] args) {
    5.         Scanner sc = new Scanner(System.in);
    6.         System.out.println("please input number");
    7.         boolean ood = new Tools().isOod(sc.nextInt());
    8.         if (ood) {System.out.println("it is odd");}else{System.out.println("it isn't odd");}
    9.     }
    10. }
    11.  
    12. class Tools {
    13.     public boolean isOod(int num) {
    14.         return num % 2 == 0 ? false : true;
    15.     }
    16. }

            2.输入几行几列就打印几行几列的#

    1. import java.util.*;
    2.  
    3. public class Hello {
    4.     public static void main(String[] args) {
    5.         Scanner sc = new Scanner(System.in);
    6.         System.out.println("please input rows col");
    7.         new Tools().print(sc.nextInt(), sc.nextInt());
    8.     }
    9. }
    10.  
    11. class Tools {
    12.     public void print(int rows, int cols) {
    13.         for (int i = 0; i < rows; i++) {
    14.             for (int j = 0; j < cols; j++) {
    15.                 System.out.print("#\t");
    16.             }
    17.             System.out.println();
    18.         }
    19.     }
    20. }

    7.方法的传参机制：

            值传递：

            引用传递： 

             对象传递：

     8.案例:

            1.克隆一个对象的属性，但是两个是独立的

    1. public class Hello {
    2.     public static void main(String[] args) {
    3.         Person p1 = new Person();
    4.         p1.name = "jack";
    5.         p1.age = 18;
    6.         Person p2 =new Tools().copyPerson(p1);
    7.         // hashCode可以判断对象是否为同一个
    8.         System.out.println(p1.name+"---"+p1.age+"---"+p1.hashCode());
    9.         System.out.println(p2.name+"---"+p2.age+"---"+p2.hashCode());
    10.     }
    11. }
    12.  
    13. class Person {
    14.     String name;
    15.     int age;
    16. }
    17.  
    18. class Tools {
    19.     public Person copyPerson(Person p) {
    20.         Person p2 = new Person();
    21.         p2.name=p.name;
    22.         p2.age = p.age;
    23.         return p2;
    24.     }
    25. }

    三、方法的递归

    1.定义：

            自己调用自己的方法，要准备出口哦

    2.递归的调用机制，实践小案例：一定要认真看图 ：栈先进后出

            打印问题

            阶乘：自己画个图很清晰啊：

     四、递归案例

    1.递归斐波那契数：1 1 2 3 5 8 13，给你一个数求他对应的斐波那契数是多少；

    1. import java.util.*;
    2.  
    3. public class Hello {
    4.     public static void main(String[] args) {
    5.         Scanner sc = new Scanner(System.in);
    6.         System.out.println("please inpu a number");
    7.         int feibonaqie = new Tools().feibonaqie(sc.nextInt());
    8.         System.out.println(feibonaqie);
    9.     }
    10. }
    11.  
    12. class Tools {
    13.     public int feibonaqie(int i) {
    14.         if (i == 1 || i == 2) {
    15.             return 1;
    16.         } else {
    17.             return feibonaqie(i - 1) + feibonaqie(i - 2);
    18.         }
    19.     }
    20. }

     2.有一堆桃子，猴子每天吃其中的一半，在多吃一个，到第十天，还没吃发现就剩1个了，求一共有多少桃子？  1534

    1. public class Hello {
    2.     public static void main(String[] args) {
    3.         int peaches = new Tools().eatPeach(10);
    4.         System.out.println(peaches);
    5.     }
    6. }
    7.  
    8. class Tools {
    9.     public int eatPeach(int day) {
    10.         if (day <= 1) {
    11.             return 1;
    12.         } else {
    13.             return (eatPeach(day - 1) + 1) * 2;
    14.         }
    15.     }
    16. }

    3.走迷宫：出迷宫

    1. public class Noot {
    2.     public static void main(String[] args) {
    3.         //二维数组表示迷宫 int[][] map = new int[8][7];
    4.         //规定map的元素值：0表示可以走，1表示障碍物
    5.         int[][] map = new int[8][7];
    6.         //将最上面一行和最下面一行都变成1
    7.         for (int i = 0; i < map.length; i++) {
    8.             for (int j = 0; j < map[i].length; j++) {
    9.                 if (i == 0 || i == map.length-1){
    10.                     map[i][j] = 1
    11.                 }
    12.             }
    13.         }
    14.  
    15.         //遍历数组，看效果
    16.         for (int i = 0; i < map.length; i++) {
    17.             for (int j = 0; j < map[i].length; j++) {
    18.                 System.out.print(map[i][j]+"\t");
    19.             }
    20.             System.out.println();
    21.         }
    22.     }
    23. }
    24.  
    25. class T {
    26.     //使用递归回溯的思想来解决老鼠出迷宫
    27.     //如果找到就返回true，否则返回false
    28.     //map为地图，i，j为初始位置，初始化位置为（1，1）
    29.     //因为我们是递归找路，所以我先规定 map数组的各个值的含义
    30.     //map的元素 0表示可以走，1表示障碍物， 2表示可以走，3表示走过是死路
    31.     //当（6，5）位置为2时就说明找到通路了
    32.     //先确定老属找路的策略 下->右->上->左
    33.     public boolean findWay(int[][] map, int i, int j) {
    34.         if (map[6][5] == 2) {
    35.             return true;
    36.         } else {
    37.             if (map[i][j] == 0) { //假设这个走得通就看他的下一个点
    38.                 map[i][j] = 2;
    39.                 if (findWay(map, i + 1, j)) { //下
    40.                     return true;
    41.                 } else if (findWay(map, i, j + 1)) { //右
    42.                     return true;
    43.                 } else if (findWay(map, i - 1, j)) { //上
    44.                     return true;
    45.                 } else if (findWay(map, i, j - 1)) { //左
    46.                     return true;
    47.                 }else{
    48.                     map[i][j] = 3;
    49.                     return false;
    50.                 }
    51.             } else {
    52.                 return false;
    53.             }
    54.         }
    55.     }
    56. }

    4.汉诺塔的实现：把所有盘子放到b盘

    1. public class Hello {
    2.     public static void main(String[] args) {
    3.         new Tower().move(5, 'A', 'B', 'C');
    4.     }
    5. }
    6.  
    7. class Tower {
    8.     public void move(int num, char a, char b, char c) {
    9.         if (num == 1) {
    10.             System.out.println(a + "-->" + b);
    11.         } else {
    12.             move(num - 1, a, c, b);
    13.             System.out.println(a + "-->" + b);
    14.             move(num - 1, c, b, a);
    15.         }
    16.     }
    17. }

    5.八皇后啊：两个皇后不能在同一个列于同一个斜线上（没解决）

    五、方法的重载

    1.定义：

            方法名必须相同，参数列表：必须不同，要么类型不同，要么顺序不同，参数名无要求，返回值类型无要求

    1. public class Hello {
    2.     public static void main(String[] args) {
    3.     }
    4. }
    5.  
    6. class Calculation{
    7.     //两个整数的和
    8.     public int calculate(int n1,int n2){
    9.         return n1+n2;
    10.     }
    11.     //一个整数，一个double的和
    12.     public double calculate(int n1,double n2){
    13.         return n1+n2;
    14.     }
    15.  
    16.     //一个double的和,一个整数，
    17.     public double calculate(double n1,int n2){
    18.         return n1+n2;
    19.     }
    20.  
    21.     //三个整数
    22.     public int calculate(int n1,int n2,int n3){
    23.         return n1+n2+n3;
    24.     }
    25. }

    2.可变参数：

            1.定义：(int... num)，传递的参数可以为数组，可变参数实质为数组，可以和普通参数放在一起，可变参数放在最后。最多只有一个可变参数。

            案例：使用可变参数返回，1姓名2课程（总分），1姓名3课程（总分）。。。

    1. public class Hello {
    2.     public static void main(String[] args) {
    3.         new HspMethods().showScore("jack",60,10,90);
    4.     }
    5. }
    6.  
    7. class HspMethods {
    8.     public void showScore(String name, int... score) {
    9.         double totalScore = 0.0;
    10.         for (int i = 0; i < score.length; i++) {
    11.             totalScore += score[i];
    12.         }
    13.         System.out.println("he name is " + name + ';' + score.length + "class totalScore is " + totalScore);
    14.     }
    15. }

    六、作用域

    全局变量：也就是属性，作用域为整个类体；属性在定义时可以直接赋值。全局变量可以直接使用，不需要赋值，因为有默认值。

    局部变量：在成员方法中定义或者是传递的形参，作用域在整个方法中，必须赋值才能使用，因为没有默认值，不能加修饰符

    就近原则：局部变量可以和全局变量重名，谁离的近变量指的就是谁，两个局部变量不能重名

    1. public class Hello {
    2.     public static void main(String[] args) {
    3.         new HspMethods().showScore("jack", 60, 10, 90);
    4.     }
    5. }
    6.  
    7. class Person {
    8.     String name; //全局变量
    9.  
    10.     public void showName(String name) { //局部变量
    11.         name = 10; //局部变量
    12.     }
    13. }

    七、构造器

    1.定义：

            [修饰符] 方法名(形参列表){ 方法体  }   ===》1.修饰符可以默认，2构造器没有返回值，3.方法名与类名一样，4.参数列表和成员方法一样的规则，5.构造器由系统调用。构造器是初始化对象，而不是创建对象

            案例1.创建对象时指定人的姓名与年龄

    1. public class Hello {
    2.     public static void main(String[] args) {
    3.         new Person("Smith", 19).show();
    4.     }
    5. }
    6.  
    7. class Person {
    8.     String name;
    9.     int age;
    10.  
    11.     public Person(String pName, int pAge) {
    12.         name = pName;
    13.         age = pAge;
    14.     }
    15.  
    16.     public void show() {
    17.         System.out.println("name " + name + " age " + age);
    18.     }
    19. }

    2.细节：

    1. 构造器也可以重载哦
    2. 如果不写构造器，系统默认生成一个空参构造器
    3. 如果写了构造器，默认构造器就会消失，要用只能自己定义
    4. 一般写类，就创建一个全参构造器和一个无参构造器
    5. javap  文件名.class 就是反编译你就可以看到他的源文件
    1. public class Hello {
    2.     public static void main(String[] args) {
    3.         new Person().show();//使用无参构造器 null 18
    4.         new Person("Smith", 19).show();//使用有参构造器 Smith  19
    5.     }
    6. }
    7.  
    8. class Person {
    9.     String name;
    10.     int age;
    11.  
    12.     public Person(String pName, int pAge) {
    13.         name = pName;
    14.         age = pAge;
    15.     }
    16.  
    17.     public Person(){
    18.         age=18;
    19.     }
    20.  
    21.     public void show() {
    22.         System.out.println("name " + name + " age " + age);
    23.     }
    24. }

    八、对象的创建流程（面试题）很重要这个图

     九、this的用法

     1.定义：

            解决变量名的命名问题，一个笑话，赵本山问奥尼尔，你知道我爸爸的爸爸是谁吗，奥尼尔说不知道，赵本山说是我爷爷。然后奥尼尔回美国问科比你只我我爸爸的爸爸是谁吗？科比说我不知道啊，奥尼尔说是赵本山爷爷。

    2.this的本质：

    那个调用this就指向谁

    1. public class Hello {
    2.     public static void main(String[] args) {
    3.         new Person("Smith", 19).show();
    4.     }
    5. }
    6.  
    7. class Person {
    8.     String name;
    9.     int age;
    10.  
    11.     public Person(String pName, int pAge) {
    12.         this.name = pName;
    13.         this.age = pAge;
    14.     }
    15. }

    3.注意：

    1. this访问成员属性   this.属性名
    2. 调用本类的方法 this.f1()
    3. 调用构造器 this(),只能在构造器中用，而且只能写在构造器第一行

    案例：比较类的大小：

    1. public class Hello {
    2.     public static void main(String[] args) {
    3.         System.out.println(new Person("Smith", 19).comparaTo(new Person("Smith",19))+"");
    4.     }
    5. }
    6.  
    7. class Person {
    8.     String name;
    9.     int age;
    10.  
    11.     public Person(String name,int age){
    12.         this.name = name;
    13.         this.age = age;
    14.     }
    15.  
    16.     public boolean comparaTo(Person p){
    17.         return this.name.equals(p.name)&&this.age == p.age;
    18.     }
    19. }

    十、课后作用

     1.定义类，方法max，实现求某个double数组的最大值，并返回

    1. public class Hello {
    2.     public static void main(String[] args) {
    3.         double[] arr = {1,2,3,3,1,2};
    4.         System.out.println(new A01().max(arr));
    5.     }
    6. }
    7.  
    8. class A01 {
    9.     public double max(double[] arr){
    10.         double max = arr[0];
    11.         for (int i = 1; i < arr.length; i++) {
    12.             if (max
    13.         }
    14.         return max;
    15.     }
    16. }

    2.定义方法find，实现字符串数组的查找，并返回索引，没找到返回-1

    1. public class Hello {
    2.     public static void main(String[] args) {
    3.         String[] arr ={"apple","banana","pear"};
    4.         String str = "apple";
    5.         System.out.println(new A02().find(str,arr));
    6.     }
    7. }
    8.  
    9. class A02 {
    10.     public int find(String str ,String[] arr){
    11.         int index = -1;
    12.         for (int i = 0; i < arr.length; i++) {
    13.             if (arr[i].equals(str)) index = i;
    14.         }
    15.         return index;
    16.     }
    17. }

     3.定义书本方法，超过150就显示那个，没过150显示100

    1. public class Hello {
    2.     public static void main(String[] args) {
    3.         Book book = new Book();
    4.         book.updatePrice(160);
    5.         book.showInfo();
    6.     }
    7. }
    8.  
    9. class Book {
    10.     int price;
    11.  
    12.     public void updatePrice(int price) {
    13.         this.price = 100;
    14.         if (price>150) this.price = price;
    15.     }
    16.  
    17.     public void showInfo() {
    18.         System.out.println("book's price is " + this.price);
    19.     }
    20. }
  • 相关阅读:
    自己本地写完代码后，不要直接git pull拉远程代码，会导致代码丢失
    【录用案例】CCF-C类，1/2区SCI&EI，3个月14天录用，30天见刊，11天检索
    开源交流丨一站式大数据平台运维管家ChengYing安装原理剖析
    WebSocket消息推送
    springMvc54-简单异常处理二
    YCSB and TPC-C on MySQL（避免重复load）
    推荐搜索中各类排序算法综述
    数据结构高阶--二叉搜索树（原理+实现）
    Git
    【Nginx 原理】进程模型、HTTP 连接建立和请求处理过程、高性能、高并发、事件处理模型、模块化体系结构
  • 原文地址：https://blog.csdn.net/m0_61927991/article/details/126843806