面向对象（基础二）

最新推荐文章于 2023-07-17 17:40:15 发布

为什么暴躁

最新推荐文章于 2023-07-17 17:40:15 发布

阅读量145

点赞数

分类专栏： java基础

本文链接：https://blog.csdn.net/chenguoao1999/article/details/118990145

版权

java基础专栏收录该内容

42 篇文章 2 订阅

订阅专栏

递归方法
构造方法
this和static
package和import

第一章递归方法

第01节基础理论

什么是递归呢？

在 Java 当中，递归指的是 方法自己调用自己的过程。（备注：递归需要有出口，需要能够终结）
思想：大事化小小事化了。

生活实例： 《和尚讲故事》
	从前有座山，山里有个庙，庙里有个老和尚，老和尚在给小和尚讲故事。
	从前有座山，山里有个庙，庙里有个老和尚，老和尚在给小和尚讲故事。
	从前有座山，山里有个庙，庙里有个老和尚，老和尚在给小和尚讲故事。
	从前有座山，山里有个庙，庙里有个老和尚，老和尚在给小和尚讲故事。
	从前有座山，山里有个庙，庙里有个老和尚，老和尚在给小和尚讲故事。
	。。。。。。。。
	从前有座山，山里有个庙，庙里有个老和尚，老和尚在给小和尚讲故事。
	
生活实例： 《编程的故事》
	我们在学习编程，搞钱，花钱，爽，空虚，寂寞，找对象，生娃。
	让娃去学习编程，搞钱，花钱，爽，空虚，寂寞，找对象，生娃。
	让娃去学习编程，搞钱，花钱，爽，空虚，寂寞，找对象，生娃。
	。。。。。。。
	让娃去学习编程，搞钱，花钱，爽，空虚，寂寞，找对象，生娃。

配图说明

在这里插入图片描述

第02节快速入门

需求

采用递归的方式，计算5的阶乘。
阶乘: 5! = 5x4x3x2x1 = 120

分析

如果想要完成递归的操作，需要有三个步骤:
[1]写个方法  //递归是方法自己调用自己，说到递归，必须有方法
[2]找到规律  //罗列几项内容，通过罗列出来的数据，观察思考，找到规律
[3]找到出口  //什么时候，递归可以结束
===============================================
阶乘: 5! = 5x4x3x2x1 = 120
4! = 4x3x2x1
3! = 3x2x1
2! = 2x1
1! = 1
-------------
5! = 5x4!
4! = 4x3!
通项公式，如果是计算N的阶乘，应该怎么写呢？
N的阶乘 = N*(N-1)的阶乘;
=============================================
怎么找到出口呢？
什么时候结束啊？
当n=1的时候，就是结束，当n=1的时候，它的阶乘是几? 1
结束的时候，不要使用通项公式，其他情况，都是使用通项公式。

代码

//计算5的阶乘
public class Test03 {

    public static void main(String[] args) {
        //直接调用方法
        int jieGuo = jieCheng(5);
        System.out.println("jieGuo = " + jieGuo);
    }

    //写个方法
    public static int jieCheng(int n){
        //什么时候是出口?
        if (n == 1){
            return 1;
        }else{
            return n*jieCheng(n-1);
        }
    }
}

内存图在这里插入图片描述

第03节猴子分桃

题目

海滩上有一堆桃子和一只猴子。
猴子第一天，拿走了桃子的一半，又多拿一个。
猴子第二天，拿走了桃子的一半，又多拿一个。
猴子第三天，拿走了桃子的一半，又多拿一个。
猴子第四天，拿走了桃子的一半，又多拿一个。
猴子第五天，拿走了桃子的一半，又多拿一个。
。。。。。。
猴子第九天，拿走了桃子的一半，又多拿一个。
第十天的时候，最后剩余1个，请问原来第一天是多少个桃子？

代码

public class Test04 {

    public static void main(String[] args) {
        int tz = taozi(1);
        System.out.println("tz = " + tz);
    }

    public static int taozi(int day){
        if(day == 10){
            return 1;
        }else{
            return (taozi(day+1)+1)*2;
        }
    }
}

//猴子第一天，拿走了桃子的一半，又多拿一个。
//假设第10天剩余1个。
//那么第9天  (1+1)x2 = 4
//那么第8天  (4+1)x2 = 10
//那么第7天  (10+1)x2 = 22
// ....
//出口是第10天是1个

第二章构造方法

第01节基础理论

什么是构造方法呢？

构造方法是用来创建对象的方法，每一个Java类，都具有构造方法。
系统默认赠送你一个无参数构造方法，用来创建对象使用。肉眼是看不到的，系统默认赠送的方法。

默认赠送的方法，模样：
public 类名称(){

}

如果我们手动的给出构造方法，系统将不再赠送构造方法。（系统赠送的构造是用来创建对象的）

构造方法有什么特点? 【同时满足】

1. 构造方法的名称必须和类名称完全相同。
2. 没有返回值类型，注意 void 也不要写。

构造方法有什么作用呢？

1. 可以创建对象（创建对象的过程就是调用构造的过程）
2. 可以给成员变量初始化数据。

第02节快速入门

老师类

public class Teacher {

    String name;
    int age;

    //这里存在构造方法
    public Teacher(){
        //帮我们进行初始化数据
        name = "华浩";
        age = 18;
    }

    //再写一个构造方法
    public Teacher(String name,int age){
        this.name = name;
        this.age = age;
    }
}

测试类

public class Test {

    public static void main(String[] args) {
        Teacher one = new Teacher();

        System.out.println(one.name);
        System.out.println(one.age);

        System.out.println("--------");

        Teacher two = new Teacher("花老师",20);
        System.out.println(two.name);
        System.out.println(two.age);
    }
}

第03节注意事项

1. 格式上面的注意：
	A. 构造方法的名称必须和类名称完全一样
	B. 构造方法不要写返回值类型，void也不要写。

2. 使用构造的注意：
	A. 如果没有写构造方法，系统默认赠送一个无参数构造方法
	B. 如果写出了构造方法，系统不再赠送构造方法
	C. 如果只是写了带参数构造方法，没有写无参数构造方法，我们无法采用无参数构造方法创建对象。
	
3. 构造方法和成员方法谁先执行呢?
	构造方法先执行。（因为先要创建对象，创建对象的时候，就是调用构造方法的时候）
	
4. 后期使用构造的方式:
	A. 需要提供无参数构造方法
	B. 需要提供全参数构造方法

快捷键
在这里插入图片描述

第三章 this和static

第01节 this关键字

this关键字的作用？

可以用来区分成员变量和局部变量。
当我们出现了成员变量和局部变量名称相同的情况，可以采用 this 关键字区分，被this关键字修饰的是 成员变量。

this 关键字的三种用法

1. 调用成员变量  this.变量名称
2. 调用成员方法  this.方法名称(参数);
3. 调用构造方法  this(参数);

注意事项：

如果我们采用 this(参数) 这种写法，只能在构造方法的第一行有效语句当中，其他地方写代码都会出错。

快速入门

猫类

//定义一个类
public class Cat {
    String name;
    int age;
    public Cat() {
        this("汤姆",3);
    }
    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //抓老鼠
    public void catchMouse(){
        System.out.println("猫可以抓老鼠");
    }
    //展示功能
    public void function(){
        //这里的 this. 单纯的是一个强调的作用。
        this.catchMouse();
        System.out.println("这是function");
    }
    //直接打印输出 this
    public void show(){
        System.out.println(this);
    }
}

测试类

//测试类
public class Test {

    public static void main(String[] args) {

        //1.创建对象（采用无参数构造方法创建对象）
        Cat one = new Cat();
        System.out.println("one = " + one);  //one = blb.chc05.Cat@1b6d3586
        System.out.println("one.name = " + one.name);  //one.name = 汤姆
        System.out.println("one.age = " + one.age);  //one.age = 3
        one.catchMouse(); //猫可以抓老鼠
        one.function();  //猫可以抓老鼠   这是function
        one.show();  //blb.chc05.Cat@1b6d3586
        System.out.println("---------------");
        //2. 创建对象（采用带参数构造方法创建对象）
        Cat two = new Cat("加菲猫",5);
        System.out.println("two = " + two);  //two = blb.chc05.Cat@4554617c
        System.out.println("two.name = " + two.name); //two.name = 加菲猫
        System.out.println("two.age = " + two.age);  //two.age = 5
        two.catchMouse(); //猫可以抓老鼠
        two.function();  //猫可以抓老鼠  这是function
        two.show();  //blb.chc05.Cat@4554617c
    }
}

内存图
在这里插入图片描述

第02节 static关键字

快速入门

学生类

public class Student {

    String name;
    int age;
    static String school;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void show(){
        System.out.println("name = " + name);
        System.out.println("age = " + age);
        System.out.println("school = " + school);
    }
}

测试类

public class Test {

    public static void main(String[] args) {

        Student.school = "百里半学校";

        Student one = new Student("郭靖",20);
        Student two = new Student("杨康",18);
        Student three = new Student("黄蓉",16);

        one.show();
        System.out.println("-----");
        two.show();
        System.out.println("-----");
        three.show();
    }
}

效果图
在这里插入图片描述

小结：

静态 static 有什么好处呢？

共享（可以被多个对象共享使用）

如果使用静态，会出现什么情况?

A. 静态的内容，优先于对象加载。（先有静态，后有对象）可以省略对象的创建。

B. 可以采用类名称直接打点调用静态。

工具类和工具方法

快捷键

1. 查找源代码的快捷键：  Ctrl + N 输入你要搜索的类名称
2. 查找具体的某个方法：  Alt  + 7 可以直接看方法信息
3. 切换到之前的界面：    Alt  + 1

工具类

import java.util.Random;

//点名器效果
public class MyTool {

    //可以不让外界创建对象。（构造方法不要被外界访问，只能自己玩）
    private MyTool(){

    }

    //点名器
    public static void callName(){
        String[] array = new String[]{
                "粥","粉","面","饭","茶"
        };
        //可以使用随机数
        Random r = new Random();
        int index = r.nextInt(array.length);  //nextInt(5)  0-4
        System.out.println(array[index]);
    }
}

测试类

//测试类
public class Test {

    public static void main(String[] args) {
        MyTool.callName();
    }
}

静态和非静态

1. 静态不可以访问非静态内容。
2. 非静态可以访问静态内容。
3. 静态static方法里面，不能有 this 关键字。（this指的是对象，他是非静态的）

第03节代码块

常见分类

1. 局部代码块
2. 构造代码块
3. 静态代码块 【使用较多】
4. 同步代码块（暂时不讲，介绍多线程的时候，才会讲）

局部代码块（了解）

//局部代码块
public class Test01 {

    public static void main(String[] args) {
        {
            int a = 10;
            System.out.println("这就是局部代码块");
            System.out.println(a);
        }
    }
}

构造代码块

//猪类
public class Pig {
    public Pig(){
        System.out.println("无参数构造方法");
    }
    public Pig(String name){
        System.out.println("带参数构造方法");
    }
    {
        System.out.println("我是相同代码");
    }
}

测试类

//构造代码块
public class Test02 {

    public static void main(String[] args) {

        Pig one = new Pig();
        Pig two = new Pig("佩奇");
    }
}

//构造代码块和构造方法谁先执行啊?
//构造代码块 > 构造方法

构造代码块

//猪类
public class Pig {

    public Pig(){
        System.out.println("无参数构造方法");
    }

    public Pig(String name){
        System.out.println("带参数构造方法");
    }


    {
        System.out.println("我是相同代码构造代码块");
    }

    static{
        System.out.println("我是静态代码块");
    }
}

测试类

//静态代码块
public class Test03 {

    public static void main(String[] args) {
        Pig one = new Pig();
        System.out.println("------");
        Pig two = new Pig("佩奇");
    }
}

//静态代码块的特点?
//1. 只会运行一次
//2. 优先于构造代码块

//三个的优先级:
//静态代码块 > 构造代码块 > 构造方法

第04节单例模式

理论说明

单例模式: 单：一个  例：实例，对象的意思。  也就是说只能创建一个对象。
通过一些特殊的手段，让我们的类，只能创建一个对象。

单例模式分为两种情况:
	(1) 懒汉式： 平常没有，用的时候，才会有。
	(2) 饿汉式： 刚开始就已经存在了。

懒汉式

单例类

//马类（懒汉式）
public class Ma {

    //1. 私有化对象的声明
    private static Ma instance = null;

    //2. 私有构造方法
    private Ma(){

    }

    //3. 提供公共的返回当前对象
    public static Ma getInstance(){
        if(instance == null){
            instance = new Ma(); 
        }
        return instance;
    }
}

测试类

//测试类
public class Test {

    public static void main(String[] args) {

        Ma m1 =  Ma.getInstance();
        Ma m2 =  Ma.getInstance();

        System.out.println("m1 = " + m1);
        System.out.println("m2 = " + m2);
        System.out.println(m1 == m2);

    }
}

饿汉式

单例类

//鹿类（饿汉式）
public class Lu {

    //1. 私有静态对象的，直接创建
    private static Lu instance = new Lu();

    //2. 构造方法私有化修饰
    private Lu(){

    }

    //3. 直接公共的静态的方法，返回对象
    public static Lu getInstance(){
        return instance;
    }
}

测试类

//测试类
public class Test {

    public static void main(String[] args) {

        Lu one = Lu.getInstance();
        Lu two = Lu.getInstance();

        System.out.println("one = " + one);
        System.out.println("two = " + two);
        System.out.println(one == two);

    }
}

第四章 package和import

第01节 package

package : 包。
他只能写在 class 类的上面，而且只能出现 1次。

他有什么作用呢？
可以去分类管理 class 类

com.baidu.service
com.baidu.dao
com.baidu.controller
com.baidu.ui
com.baidu.util

包名称：全部是小写字母。一般不会写大写字母。（如果是大写字母，容易和类名称冲突）
你买了一套房子： 120平米。不能只有一个大厅。否则出现 厨房和卫生间在一起。

第02节 import

import 是导包的意思。
用于说明当前使用的某些类，来自于哪些包当中。（作为位置的声明）  import java.util.Scanner;

注意细节： 先后顺序
	package > import > class

为什么暴躁

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
面向对象（基础二）

递归方法构造方法this和staticpackage和import第一章递归方法第01节基础理论什么是递归呢？在 Java 当中，递归指的是方法自己调用自己的过程。（备注：递归需要有出口，需要能够终结）思想：大事化小小事化了。生活实例：《和尚讲故事》从前有座山，山里有个庙，庙里有个老和尚，老和尚在给小和尚讲故事。从前有座山，山里有个庙，庙里有个老和尚，老和尚在给小和尚讲故事。从前有座山，山里有个庙，庙里有个老和尚，老和尚在给小和尚讲故事。从前有座山，山里有个庙.
复制链接

扫一扫