坚定不移学Java-Day05

最新推荐文章于 2024-07-15 22:27:12 发布
最新推荐文章于 2024-07-15 22:27:12 发布
阅读量698 收藏 21
点赞数 33
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73569500/article/details/139458305
版权

 整理自 韩顺平零基础30天学Java

【零基础 快速学Java】韩顺平 零基础30天学会Java_哔哩哔哩_bilibili

类与对象

对象的分配机制

Person p1 = new Person();
p1.age = 10;
p1.name = "小明";
Person p2 = p1; //把p1赋给了p2，或让p2指向p1
System.out.println(p2.age); //10

内存的结构分析

  1. 栈：一般存放基本数据类型（局部变量）。
  2. 堆：存放对象（Cat cat，数组等）。
  3. 方法区：常量池（常量，比如字符串），类加载信息。
  4. 示意图 [Cat (name, age, price)]

创建对象的流程

Person p = new Person();
p.name = "jack";
p.age = 10;
  1. 加载Person类信息（属性和方法信息，只会加载一次）
  2. 在堆中分配空间，进行默认初始化。
  3. 把堆中的地址赋给p，p指向对象。
  4. 进行指定初始化。

练习 

Person a = new Person();
a.age = 10;
a.name = "小明";
Person b;
b = a;
System.out.Println(b.name); //小明
b.age = 200;
b = null; //将b所存的地址置空
System.out.Println(a.age); //200
System.out.Println(b.age); //异常

成员方法

public class D5 {
    public static void main(String[] args) {
        Person person = new Person();
        person.speak();
        person.cal01();
        person.cal02(10);
        int sum = person.getSum(40,50);
        System.out.println("计算结果=" + sum);
    }
}

class Person{
    String name;
    int age;
    public void speak(){
        System.out.println("I'm a nice guy.");
    }
    public void cal01(){
        int res = 0;
        for (int i = 0; i <= 100; i++){
            res += i;
        }
        System.out.println("计算结果=" + res);
    }
    public void cal02(int n){
        int res = 0;
        for (int i = 0; i <=n; i++){
            res +=i;
        }
        System.out.println("计算结果=" + res);
    }
    public int getSum(int num1,int num2){
        int res = num1 + num2;
        return res;
    }
}

调用机制

  1. 当程序执行到方法时，就会开辟一个独立的（栈）空间。
  2. 当方法执行完毕，或执行到return语句时，就会返回。
  3. 返回到调用方法的地方，继续执行方法后面的代码。
  4. 当main方法（栈）执行完毕，整个程序退出。
好处
  1. 提高代码的复用性。
  2. 可以将实现的细节封装起来，供其他用户来调用即可。（工作之后做项目开发时）

定义

访问修饰符 返回数据类型 方法名 (形参列表){

        语句;

        return 返回值;    //不是必须的

}

 细节

访问修饰符

作用：控制方法使用的范围。

有：public、protected、private、默认。如果不写，默认访问。

返回类型
  1. 一个方法最多有一个返回值。（返回数组，可以实现返回多个值）
  2. 返回类型可以为任意类型，包含基本类型或引用类型（数组，对象）。
  3. 如果方法要求有返回数据类型，则方法体中最后的执行语句必须为return值；而且要求返回值类型必须和return的值类型一致或兼容。
  4. 如果方法是void，则方法体中可以没有return语句，或者只写 return;
方法名

驼峰命名法，见名知义。如getSum

形参列表
  1. 一个方法可以有0个参数，也可以有多个参数，中间用逗号隔开。比如getSum(int n1, int n2)。
  2. 参数类型可以为任意类型，包含基本类型或引用类型。比如printArr(int[][] map)。
  3. 调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型的参数。
  4. 方法定义时的参数称为形式参数，简称形参；方法调用时的参数称为实际参数，简称实参。实参和形参的类型要一致或兼容，个数、顺序必须一致。
方法体

里面写完成功能的具体语句，可以为输入、输出、变量、运算、分支、循环、方法调用，但是不能再定义方法。即不能嵌套。

方法细节的调用说明
  1. 同一个类中：直接调用即可。
  2. 跨类的方法A类调用B类方法：需要通过对象名调用。e.g.对象名.方法名(参数);
    跨类的方法调用和方法的访问修饰符相关。

传参机制

除byte,short,int,long,char,boolean,float,double外，其余都是引用数据类型。

基本数据类型
public class D5 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        AA obj = new AA();
        obj.swap(a, b);
        System.out.println("a=" + a + "b=" + b);  // 10 20
    }
}
class AA{
    public void swap(int a, int b){
        System.out.println("a和b交换前的值\na=" + a + "\tb=" + b) // 10 20
        int tmp = a;
        a = b;
        b = tmp;
        System.out.println("a和b交换后的值\na=" + a + "\tb=" + b) //20 10
    }
}

 基本数据类型，传递的是值（值拷贝），形参的任何改变不影响实参。

引用数据类型
public class D5 {
    public static void main(String[] args) {
        B b = new B();
        int[] arr = {1, 2, 3};
        b.test100(arr);
        System.out.println("main方法中的数组");
        for (int i = 0; i < arr.length; i++){
            System.out.print(arr[i] + "\t"); //200 2 3
        }
        System.out.println();
    }
}
class B{
    public void test100(int[] arr){
       arr[0] = 200;
       System.out.println("test100方法中的数组");
       for (int i = 0; i < arr.length; i++){
            System.out.print(arr[i] + "\t"); //200 2 3
       }
       System.out.println();
    }
}

引用数据类型，传递的是地址（地址拷贝），可以通过形参影响实参。

克隆对象
public class D5 {
    public static void main(String[] args) {
//        克隆对象
        Person p = new Person();
        p.name = "milan";
        p.age = 30;
        MyTools tools = new MyTools();
        Person p2 = tools.copyPerson(p);
//        p和p2是Person对象，但是是两个独立的对象，属性相同
        System.out.println("p的属性 age=" + p.age + "名字 name=" + p.name);
        System.out.println("p2的属性 age=" + p2.age + "名字 name=" + p2.name);
//        可以通过输出对象的hashCode看看对象是否是同一个 或 通过对象比较看看是不是同一个
        System.out.println(p == p2);
    }
}

class Person{
    String name;
    int age;
}
class MyTools{
    public Person copyPerson(Person p){
        Person p2 = new Person();
        p2.name = p.name; //传递的参数与原函数的参数没有关系,即两个对象是独立的
        p2.age = p.age;
        return p2;
    }
}

递归调用

递归：方法自己调用自己，每次调用时传入不同的变量。递归有助于编程者解决复杂问题，同时可以让代码变得简洁。

那迭代呢？两者有差别吗？

阶乘
public class D5 {
    public static void main(String[] args) {
//        阶乘
        T t1 = new T();
        int res = t1.factorial(5);
        System.out.println("res=" + res);
    }
}

class T{
    public int factorial(int n){
        if (n == 1){
            return 1;
        }else {
            return factorial(n - 1) * n;
        }
    }
}
规则
  1. 执行一个方法时，就创建一个新的受保护的独立空间（栈空间）。
  2. 方法的局部变量是独立的，不会相互影响。
  3. 如果方法中使用的是引用类型变量（比如数组、对象），就会共享该引用类型的数据。
  4. 递归必须向退出递归的条件逼近，否则就是无限递归，出现StackOverflowError（死鬼）。
  5. 当一个方法执行完毕，或者遇到return，就会返回，遵守“谁调用就将结果返回谁”。同时当方法执行完毕或者返回时，该方法也就执行完毕。
习题
斐波拉契数
public class D5 {
    public static void main(String[] args) {
//        斐波那契数列1，1，2，3，5，8，13...
        F f = new F();
        int res = f.fibonacci(9);
        if(res != -1){
            System.out.println("当n=7时，对应的斐波那契数是："+ res);
        }else{
            System.out.println("输入的数字有误");
        }
    }
}
class F{
    public int fibonacci(int n){
        if (n >= 1){
            if(n == 1 || n == 2){
                return 1;
            }else{
                return fibonacci(n-1) + fibonacci(n-2);
            }
        }else{
            return -1;
        }
    }
}

从确切的数据入手找规律！

老鼠走迷宫
package chapter01;

import com.sun.source.tree.NewArrayTree;

public class MiGong {
    public static void main(String[] args) {
//        1.创建迷宫，用二维数组表示 int[][] map = new int[8][7];
//        2.先规定 map 数组的元素值：0表示可以走；1表示障碍物
        int[][] map = new int[8][7];
//        3.将最上面和最下面的两行设置为1
        for(int i = 0; i < 7; i++){
            map[0][i] = 1;
            map[7][i] = 1;
        }
//        4.最左和最右两列也要置成1
        for(int i = 0;i < 8; i++){
            map[i][0] = 1;
            map[i][6] = 1;
        }
//        5.[3,1]和[3,2]也是障碍
        map[3][1] = 1;
        map[3][2] = 1;

//        输出当前地图
        System.out.println("当前地图情况");
        for (int i = 0; i < map.length; i++){
            for (int j = 0; j < map[i].length; j++){
                System.out.print(map[i][j] + " ");
            }
            System.out.println();
        }
//        使用findWay给老鼠找路
        Mouse mouse = new Mouse();
        mouse.findWay(map,1,1);
        System.out.println("找路的情况：");
        for (int i = 0; i < map.length; i++){
            for (int j = 0; j < map[i].length; j++){
                System.out.print(map[i][j] + " ");
            }
            System.out.println();
        }
    }
}
class Mouse {
//    使用递归回溯
//    i,j是老鼠的位置，初始位置为（1，1）
//    规定：map数组各个值的含义
//    0：可以走,未测试，1：障碍物，2：可以走，已测试，3：走过，但走不通
//    当 map[6][5] == 2，就说明找到通路了退出，否则就继续找
//    确定老鼠找路的策略：下 右 上 左
    public boolean findWay(int[][] map, int i, int j){
        if (map[6][5] == 2){
            return true;
        }else{
            if (map[i][j] == 0){
//                先假定可以走通
                map[i][j] = 2;
//                使用找路策略，来确定该位置是否真的可以走通
                if (findWay(map, i + 1, j)){ //下
                    return true;
                }else if (findWay(map, i, j + 1)){  //右
                    return true;
                }else if (findWay(map, i - 1, j)){  //上
                    return true;
                }else if (findWay(map, i, j - 1)){  //左
                    return true;
                }else {
                    map[i][j] = 3;
                    return false;
                }
            }else{
                return false;
            }
        }
    }
}
汉诺塔
package chapter01;

public class HanoiTower {
    public static void main(String[] args) {
        Tower tower = new Tower();
        tower.move(5, 'A', 'B', 'C');
    }
}
class Tower{
    public void move(int num, char a, char b, char c){
//        如果只有一个盘
        if (num == 1){
            System.out.println(a + "->" + c);
        }else {  //如果有多个盘,可以看成两个盘：最下面的 和 上面的所有盘
//            先移动上面所有的盘到 b，借助 c
            move(num - 1, a, c, b);
//            最下面的盘，移动到c
            System.out.println(a + "->" + c);
//            再把 b塔的所有盘移动到 c，借助 a
            move(num - 1, b, a, c);
        }
    }
}

方法重载（OverLoad）

Java中允许同一个类中，多个同名方法的存在，但要求 形参列表不一致（类型、个数、顺序），形参命名、返回类型无所谓。

比如：System.out.println(100);   System.out.println("hello");    System.out.println('h');
out是PrintStream类型。

好处
  1. 减轻了起名的麻烦。
  2. 减轻了记名的麻烦。
package chapter01;

import java.util.Scanner;

public class D5 {
    public static void main(String[] args) {
        MyCalculator myCalculator = new MyCalculator();
        System.out.println(myCalculator.calculate(1, 2));
        System.out.println(myCalculator.calculate(1.0,2));
        System.out.println(myCalculator.calculate(1, 2.0));
        System.out.println(myCalculator.calculate(1, 2, 3));
    }
}

//重载
class MyCalculator{
    public int calculate(int n1, int n2){
        return n1 + n2;
    }
    public double calculate(int n1, double n2){
        return n1 + n2;
    }
    public double calculate(double n2, int n1){
        return n1 + n2;
    }
    public int calculate(int n1, int n2, int n3){
        return n1 + n2 + n3;
    }
}
习题

巧用三目运算符，减少代码量。

package chapter01;

import java.util.Scanner;

public class D5 {
    public static void main(String[] args) {
//        重载2
        Methods methods = new Methods();
        methods.m(2);
        methods.m(3,4);
        methods.m("Let's do it! DuoRuimi");
//        重载3
        System.out.println(methods.max(1,2));
        System.out.println(methods.max(1.0,2.0));
        System.out.println(methods.max(1.0,2.0,3.0));
    }
}

class Methods{
    public void m (int n){
        System.out.println(n * n);
    }
    public void m (int n1, int n2){
        System.out.println(n1 * n2);
    }
    public void m (String n){
        System.out.println(n);
    }
    public int max(int n1, int n2){
//        if (n1 < n2){
//            return n2;
//        }else{
//            return n1;
//        }
        return  n1 > n2 ? n1 : n2;
    }
    public double max(double n1, double n2){
//        if (n1 < n2){
//            return n2;
//        }else{
//            return n1;
//        }
        return  n1 > n2 ? n1 : n2;
    }
    public double max(double n1, double n2, double n3){
//        if (n1 > n2){
//            if (n3 >n1){return n3;}
//            return n1;
//        }else {
//            if (n3 >n2){return n3;}
//            return n2;
//        }
        double max1 = n1 > n2 ? n1 : n2;
        return max1 > n3 ? max1 : n3;
    }
}

可变参数

Java允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。

访问修饰符 返回类型 方法名(数据类型... 形参名){

}

package chapter01;

import java.util.Scanner;

public class D5 {
    public static void main(String[] args) {
//        可变参数
        HspMethod hspMethod = new HspMethod();
        System.out.println(hspMethod.sum(1,2,4));
    }
}

class HspMethod {
//    int... 可以接收0-多个int
//    使用时，可以当作数组来使用
    public int sum (int... nums){
        int sum = 0;
        for (int i = 0; i < nums.length; i++){
            sum += nums[i];
        }
        return sum;
    }
}
细节
  1. 可变参数的实参可以为0个或任意多个。
  2. 可变参数的实参可以为数组。
  3. 可变参数的本质就是数组。
  4. 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后。
  5. 一个形参列表中只能出现一个可变参数。
兜瑞米
关注
  • 33
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
创客学-苹果公司也在偷师的创新课
09-11
资深创客麦肯尼传授了FIRE四步法与高产高效的头脑风暴术。在他多年的工作经历中积累起来且经过实践检验的100多条“绝杀式提问”，将在本书中首次展现全貌，例如未来5年内，客户...对于客户的需求，你有哪些坚定不移...
学习Java必须弄懂的几个问题
11-25
在深入学习Java编程的过程中，经常会遇到一些关键概念和问题，这些问题的理解与掌握是成为熟练Java开发者的基础。以下是我从"学习Java必须弄懂的几个问题"这个主题中提炼出的一些重要知识点： 1. **Java基础语法**...
坚定不移学Java-Day06
m0_73569500的博客
06-06 1178
整理自 韩顺平零基础30天学Java。
core java作者_coreJava_Day2（基础Java学习第二天）
weixin_33554514的博客
02-28 109
目标：1. 标识符、关键字和类型介绍2. 如何构建类1.java代码中的注释作用：使部分内容只为程序员可见，不为编译器所编译、虚拟机所执行位置：类声明前后、方法声明前后、属性声明前后、方法体中。几乎可以在一个源文件任意位置，但不能在一个关键字字符中插入注释类型:1) 单行注释：//text ——从 // 到本行结束的所有字符均作为注释而被编译器忽略2) 多行注释：/*text*/ ——从...
林浩然与杨凌芸的Java奇缘：final关键字的三次浪漫邂逅
howard2005的专栏
02-07 871
在一个名叫“编程乐园”的世界里，住着两位才子佳人——男主角林浩然和女主角杨凌芸。他们不仅是程序设计的大咖，也是Java语言王国中的翘楚。他们的爱情故事，就像Java语法中final关键字那般独特且不可变。
Java自学日记 day 17
cous_0的博客
03-22 177
day 17 今天早上起床就发现头痛，然后我发现今天都看不进去书籍， 下午去了今年的秋季招聘会，然后发现自己有很多不足，需要学的东西太多了，也算是受到了不小的打击吧！我要坚定自己的判断，走下去会很累 很焦虑 但那时我的选择 自己选的路无论怎样也要坚定不移的走下去。
java自学日记 day 24
cous_0的博客
03-29 170
day24  在了解很多信息和自己判断后，自自己做出了选择就得坚定不移的走下去，这是我妈6多前给我讲的，有两个很重要 一是梦想 而是执行力。 明天开始 今天看了String类 没有看完，我会走先去 今天早睡。
基于Flink建设流批一体实时数仓
过往记忆大数据
11-30 1872
双十一流量洪峰已经过去，身为大数据工程师的你，还在苦学Spark、Hadoop、Storm，却还没搞过Flink？每年双十一，阿里都在Flink实时计算技术的驱动下全程保持了“如丝...
Apache Flink 在双十一流量洪峰下的最佳实践
过往记忆大数据
11-09 1033
双十一流量洪峰将至，身为大数据工程师的你，还在苦学Spark、Hadoop、Storm，却还没搞过Flink？去年双十一，阿里在Flink实时计算技术的驱动下全程保持了“如丝般顺滑...
基于 Flink 构建全场景多维度实时计算数仓
过往记忆大数据
11-16 1561
双十一流量洪峰将至，身为大数据工程师的你，还在苦学Spark、Hadoop、Storm，却还没搞过Flink？去年双十一，阿里在Flink实时计算技术的驱动下全程保持了“如丝般顺滑...
陆奇给工程师们的5个建议
嵌入式Linux
11-19 283
大家好，我是写代码的篮球球痴今天分享的文章是陆奇以前在百度一次内部演讲给工程师们提的5点要求，个人觉得对很多人非常有益，大家可以耐心一读。至于陆奇是谁，可以直接搜索，借微软CEO斯蒂芬·鲍...
坚定不移的推进改革要点PPT学习教案.pptx
10-10
坚定不移的推进改革要点PPT学习教案.pptx
卜算子咏梅讲课学习课程.pptx
10-01
"零落成泥碾作尘，只有香如故"，即使最后凋零，被碾成尘土，梅花的香气依然不变，象征着诗人坚定不移的信念和高尚的品格。 3. 托物言志手法的应用：陆游通过梅花的形象，表达了自己在南宋朝廷中屡遭挫折，但仍坚持...
配置Java开发环境
Broken_x的博客
07-10 1591
Java开发环境配置
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 545
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
Java方法练习-双色球彩票系统
T1798218285的博客
07-11 292
红色球号码从1-33中选择；蓝色球号码从1-16中选择。投注号码由6个红色球号码和1个蓝色球号码组成。三等奖 5+1 / 5+0 3000。四等奖4+1 / 4+0 200。六等奖1+1 / 1+0 5。一等奖6+1 1000w。二等奖6+0 500w。五等奖3+1 / 2+1。
day04：Redis和店铺营业状态设置
最新发布
m0_69266818的博客
07-15 374
介绍了Redis命令和用java操作redis还有营业额状态接口的书写
写一首关于学习的诗歌
02-10
学习是一条长途旅行 要勇敢地踏上去 沿途风景无限好 路边桃李满天花 不怕路途遥远 不怕山高水阔 只要心怀求知欲 就能到达人生的顶峰 学习是一道窄门 需要用心去推开 里面有无限的知识 让我们的智慧得以延伸 不怕知识的海洋深 不怕难题的山峦高 只要坚持不懈 就能破解生命的密码 学习是一座城堡 让我们的心灵得以安宅 让我们的精神得以升华 让我们的人生得以辉煌 不怕学习的路途艰辛 不怕学习的山峰险峻 只要坚定不移 就能翻越人生的高山

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值