首页 > 编程语言 >Java从零到1的开始-Day06

Java从零到1的开始-Day06

时间：2025-01-08 13:58:51浏览次数：3  
标签：Java int void System Day06 零到 println public out

一、方法

1.参数和返回值使用的时机

1.参数:
  当想将一个方法中的数据传递到另外一个方法中,那么被调用方法需要定义参数,调用时传递想要传递过去的数据
2.返回值:
  调用方法时,想要此方法的结果,去参与其他操作,那么被调用的方法需要将自己的结果返回

public class Demo01Method {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        /*
           此时a代表的10
           以及b代表的20
           就传递到了method方法中
         */
        method(a,b);

        System.out.println("=====================");
        /*
          想在main方法中使用method02的结果
         */
        int i = method02();
        System.out.println(i);
    }

    public static void method(int i,int j){
        System.out.println(i+j);
    }

    public static int method02(){
        int a = 10;
        int b = 20;
        int sum = a+b;
        return sum;
    }
}

1.大家要注意:将来开发我们不可能将所有的代码放到一个main方法中;同理我们不能将所有的方法放到同一个类中;再同理,我们不能将所有的类放到同一个包中

所以为了好维护,我们应该"分包分层" -> 说白了就是通过创建不同的package,将不同的class分别存放

所以我们需要一个思想"三层架构思想"

com.atguigu.controller(表现层):专门放接收请求回响应的类
com.atguigu.service(业务层):专门放写业务逻辑的类
com.atguigu.dao(持久层):专门放和数据库打交道的类
com.atguigu.utils:专门放工具类
com.atguigu.pojo:专门放javabean

2.方法注意事项终极版

1.方法不调用不执行,main方法是jvm调用的
2.方法之间是平级关系,不能互相嵌套
3.方法的执行顺序只和调用顺序有关
4.[void]不能和[return 结果]共存,但是[void]能和[return]共存
  a.void:代表方法无返回值
  b.return 结果:代表有返回值 -> 先将结果返回,然后结束方法
  c.return:仅仅代表结束方法   
      
5.一个方法中只能有一个返回值,不能连续写多个return
6.调用方法的时候,如果没有此方法会报错      

作为初学者:

1.先定义,再调用

2.没有返回值的-> 直接调用

3.有返回值的 -> 赋值调用

二、方法练习

1.方法练习1(判断奇偶性)

需求:
   键盘录入一个整数,将整数传递到另外一个方法中,在此方法中判断这个整数的奇偶性
   如果是偶数,方法返回"偶数"  否则返回"奇数"
       
方法名:要
参数:要
返回值:要

public class Demo03Method {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int data = sc.nextInt();
        String result = method(data);
        System.out.println("result = " + result);
        sc.close();
    }

    public static String method(int n) {
        if (n % 2 == 0) {
            return "偶数";
        } else {
            return "奇数";
        }
    }
}

2.方法练习2(1-100的和)

需求 :  求出1-100的和,并将结果返回
方法名:要
参数:不要
返回值:要

public class Demo04Method {
    public static void main(String[] args) {
        int method = method();
        System.out.println("method = " + method);
    }

    public static int method(){
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            sum+=i;
        }
        return sum;
    }
}

3.方法练习3(不定次数打印)

需求:
   定义一个方法,给这个方法传几,就让这个方法循环打印几次"我是一个有经验的JAVA开发工程师"
 方法名:要
 参数:要
 返回值:不要

public class Demo05Method {
    public static void main(String[] args) {
        method01(10);
    }

    public static void method01(int n){
        for (int i = 0; i < n; i++) {
            System.out.println("我是一个有经验的java开发工程师");
        }
    }
}

4.方法练习4(遍历数组)

需求:
  在main方法中定义一个数组,将数组传递到方法中,在此方法中遍历数组
 

public class Demo06Method {
    public static void main(String[] args) {
        int[] arr1 = {1,2,3,4,5};
        method(arr1);//实参传递的是一个int型的数组int[]
    }
    public static void method(int[] arr2){
        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i]);
        }
    }
}

三、方法的重载(Overload)

1.概述:
  方法名相同,参数列表不同的方法,叫做重载方法
2.什么叫做参数列表不同:
  a.参数个数不同
  b.参数类型不同
  c.参数类型的顺序不同
3.和什么无关:
  a.和返回值无关
  b.和参数名无关

1.需求:定义三个方法,分别求2个整数相加,三个整数相加,四个整数相加

public class Demo01OverLoad {
    public static void main(String[] args) {
        sum(10,20);
        sum(10,20,30);
        sum(10,20,30,40);
    }

    public static void sum(int a, int b){
        int sum = a+b;
        System.out.println("sum = " + sum);
    }

    public static void sum(int a, int b,int c){
        int sum = a+b+c;
        System.out.println("sum = " + sum);
    }

    public static void sum(int a, int b,int c,int d){
        int sum = a+b+c+d;
        System.out.println("sum = " + sum);
    }
}

什么时候定义重载方法:功能一样,但是实现细节不一样

四、类和对象

1.面向对象的介绍

1.面向对象是什么:是Java语言的核心编程思想 -> 自己的事情别人(对象)做    
  面向过程:C语言的编程思想 -> 自己的事情自己做
      
2.为啥要使用面向对象思想编程:为了让事情变的简单(为了少写代码) -> 懒
                         有很多功能别人都提供好了,我们直接拿来用即可,一调用此功能就自动执行,我们想要的功能就完成了,其中的原理其实我们不用知道,我们只会用即可
    
3.什么时候用面向对象思想编程:
  在一个类中想使用别的类中实现好的功能时,就需要使用面向对象思想编程
      
4.怎么使用面向对象思想编程:
  a.new对象,点方法
  b.类名直接点方法名    

public class Demo01Object {
    public static void main(String[] args) {
        /*
           nextInt方法是Scanner类中实现好的方法
           我们想在Demo01Object类中使用Scanner类中的nextInt方法
           就需要使用面向对象思想编程
         */
        Scanner sc = new Scanner(System.in);
        int data1 = sc.nextInt();
        System.out.println("data1 = " + data1);

        /*
           nextInt方法是Random类中实现好的方法
           我们想在Demo01Object类中使用Random类中的nextInt方法
           就需要使用面向对象思想编程
         */
        Random rd = new Random();
        int data2 = rd.nextInt();
        System.out.println("data2 = " + data2);

        System.out.println("======================");
        int[] arr = {1, 2, 3, 4, 5};
        /*
          toString方法是Arrays类中实现好的方法
          我们想在Demo01Object类中使用Arrays类中的方法
          我们就应该使用面向对象思想编程
         */
        System.out.println(Arrays.toString(arr));
    }
}

2.类和对象

1类(实体类)_class

 1.java中的类:
   a.实体类:描述的世间万物的分类,比如:人类,动物类,手机类,猫类,狗类....
   b.测试类:测试代码是否能跑通的类,说白了就是带main方法的类
       
 2.实体类:一类事物的抽象表示形式
     
 3.实体类中的成员:
   属性:这个分类都有啥   -> 成员变量
       a.定义位置:类中方法外
       b.定义格式:数据类型 变量名
       c.成员变量有默认值:
         整数:0
         小数:0.0
         字符:'\u0000'
         布尔:false
         引用:null
       d.作用范围:整个类      
       
   行为:这个分类都能干啥 -> 成员方法
       将之前的方法,去掉static关键字,其他的部分一毛一样

public class Person {
    //成员变量-> 属性
    String name;
    int age;
    
    //成员方法-> 行为
    public void eat(){
        System.out.println("人要干饭");
    }
    
    public void drink(){
        System.out.println("人要喝水");
    }
    
    public void la(){
        System.out.println("人要拉屎");
    }
    
    public void sa(){
        System.out.println("人要嘘嘘");
    }
}


public class Animal {
 //属性
 String name;
 int age;
 //行为
 public void eat(){
     System.out.println("动物要吃饭");
 }
 
 public void drink(){
     System.out.println("动物要喝水");
 }
}

2.对象

1.对象:一类事物的具体体现
2.使用:
  a.导包: import 包名.类名
    如果两个类在同一个包下,想要使用对方的成员无需导包
    如果两个类不在同一个包下,想要使用对方的成员需要导包  
      
  b.创建对象:想要使用哪个类中的成员,就new哪个类的对象
    类名 对象名 = new 类名()
        
  c.调用成员(成员变量,成员方法):想要使用哪个类的成员,就用哪个类的对象去点哪个成员
    对象名.成员变量名 = 值
    对象名.方法名()

public class Person {
    //成员变量-> 属性
    String name;
    int age;

    //成员方法-> 行为
    public void eat(){
        System.out.println("人要干饭");
    }

    public void drink(){
        System.out.println("人要喝水");
    }

    public void la(){
        System.out.println("人要拉屎");
    }

    public void sa(){
        System.out.println("人要嘘嘘");
    }
}


public class Demo02Object {
    public static void main(String[] args) {
        /*
          创建对象:想要使用哪个类中的成员,就new哪个类的对象
                  类名 对象名 = new 类名()
         */
        Person p1 = new Person();
        p1.name = "涛哥";
        p1.age = 18;
        System.out.println(p1.name);
        System.out.println(p1.age);
        
        p1.eat();
        p1.drink();
        p1.la();
        p1.sa();
    }
}


public class Phone {
    String brand;
    String color;
    int price;

    public void call(String name){
        System.out.println("给" + name + "打电话");
    }

    public String message(){
        return "半夜涛哥给柳岩发短信,来呀!";
    }
}









public class Demo03Object {
    public static void main(String[] args) {
        Phone phone = new Phone();
        phone.brand = "华为";
        phone.color = "白色";
        phone.price = 9999;
        System.out.println(phone.brand);
        System.out.println(phone.color);
        System.out.println(phone.price);

        phone.call("张三");
        String message = phone.message();
        System.out.println(message);
    }
}

3.匿名对象的使用

1.int i = 10
int:数据类型
i:变量名
10:具体的数据
   
2.Person p = new Person()
等号左边的Person:数据类型 相当于int
p:变量名
new Person():具体的数据,相当于10

1.匿名对象:new对象的时候没有等号左半边部分,只有new的部分
2.使用:
  new 类名().成员
3.注意:
  如果涉及到为属性赋值,千万不要用匿名对象

public class Person {
    //成员变量-> 属性
    String name;
    int age;

    //成员方法-> 行为
    public void eat(){
        System.out.println("人要干饭");
    }

    public void drink(){
        System.out.println("人要喝水");
    }

    public void la(){
        System.out.println("人要拉屎");
    }

    public void sa(){
        System.out.println("人要嘘嘘");
    }
}


public class Demo04Object {
    public static void main(String[] args) {
        //原始形式new对象
        Person p1 = new Person();
        p1.eat();
        p1.drink();
        p1.name = "涛哥";
        System.out.println(p1.name);

        //匿名对象调用
        new Person().eat();
        System.out.println("=================");

        new Person().name = "柳岩";
        System.out.println(new Person().name);
    }
}

4.一个对象的内存图

public class Phone {
    String brand;
    int price;
    public void call(){
        System.out.println("打电话");
    }
}
public class Demo01Object {
    public static void main(String[] args) {
        Phone p1 = new Phone();
        System.out.println(p1);//地址值
        System.out.println(p1.brand);//null
        System.out.println(p1.price);//0
        p1.brand = "华为";
        p1.price = 9999;
        System.out.println(p1.brand);//华为
        System.out.println(p1.price);//9999
        p1.call();
    }
}

5.两个对象的内存图

p1和p2都是new出来的,所以会开辟不同的空间,地址值也不一样,所以修改一个空间中的数据不会影响另外一个空间中的数据

6.两个对象指向同一片空间内存图

p2是p1直接赋值的,所以p1和p2的地址值是一样的,所以操作p2就会影响p1的数据

五、成员变量和局部变量的区别

1.定义位置不同(掌握)
    a.成员变量:类中方法外
    b.局部变量:方法内部以及参数位置
2.作用范围不同:(掌握)
    a.成员变量:作用于整个类
    b.局部变量:只作用于自己方法内部
3.初始化值不同:(掌握)
    a.成员变量:是有默认值的
    b.局部变量:没有默认值,必须初始化之后才能使用
4.内存位置不同:(了解)
    a.成员变量:在堆中
    b.局部变量:在栈中    
5.生命周期不同:(了解)
    a.成员变量:随着对象的创建而创建,随着对象的消失而消失
    b.局部变量:随着方法的调用而创建,随着方法调用完毕而消失    

public class Person {
    //成员变量
    String name;
    public void eat(){
        int i = 10;//局部变量
        System.out.println(name);
        System.out.println(i);

        int j;
        //System.out.println(j);
    }

    public void drink(){
        System.out.println(name);
        //System.out.println(i);
    }
}

六、总结

记忆汇聚成一条长河，将我们紧紧联系在一起。它流经你，穿过你，带着你不断向前，不断超越。

标签：Java,int,void,System,Day06,零到,println,public,out
From： https://blog.csdn.net/NJG1013/article/details/144998779

相关文章

  • 字节青训入营考核十五题-Java-创意标题匹配问题
    问题问题描述在广告平台中，为了给广告主一定的自由性和效率，允许广告主在创造标题的时候以通配符的方式进行创意提交。线上服务的时候，会根据用户的搜索词触发的bidword对创意中的通配符（通配符是用成对{}括起来的字符串，可以包含0个或者多个字符）进行替换，用来提升广告投放体......
  • 1048 数字加密(java)
    本题要求实现一种数字加密方法。首先固定一个加密用正整数A，对任一正整数B，将其每1位数字与A的对应位置上的数字进行以下运算：对奇数位，对应位的数字相加后对13取余——这里用J代表10、Q代表11、K代表12；对偶数位，用B的数字减去A的数字，若结果为负数，则再加10。这......
  • DVWA靶场JavaScript Attacks漏洞所有级别通关教程及源码审计
    目录标题JavaScriptAttacks(前端攻击)low源码审计medium源码审计high源码审计impossibleJavaScriptAttacks(前端攻击)JavaScriptAttacks（前端攻击）漏洞通常涉及利用Web应用程序中的安全漏洞，特别是在JavaScript代码的使用和实现上，从而对用户或系统造成损害low......
  • 【Java难点解析-9】static
    在Java中，abstract关键字用于定义抽象类和抽象方法。抽象类和抽象方法是Java中实现抽象化的机制，旨在让开发者通过继承来实现特定的功能，同时隐藏不需要关心的实现细节。1.抽象类（AbstractClass）抽象类是不能被实例化的类。它可以包含抽象方法（没有实现的方法）以及普通方法（有......
  • java 服务cpu 100%解决
    online环境发现有个task的微服务白天使用高峰期一直cpu非常高98%-99%用 如下命令在cpu非常高的时候生成了多个dump文件jstack<PID>>thread_dump1.txtjstack<PID>>thread_dump2.txtjstack<PID>>thread_dump3.txtjstack<PID>>thread_dump4.txtjstack<PID>......
  • 【Java】自定义字符串方法——根据开始和结束字符串，截取字符串
    1/**2*根据开始和结束字符串，截取字符串3*@paramstr被截取的字符串4*@paramstartStr起始字符串（最后一次出现的起始值）5*@paramendStr结束字符串（最后一次出现的结束值）6*@return7*/8publicstaticStringsubstring(Stringstr,Stringstar......
  • java中反射的基本使用
    一、参考文档：https://www.cnblogs.com/chanshuyi/p/head_first_of_reflection.htmlchatgpt问答 二、前言反射是java的一个特性，是java提供的一种机制。反射允许程序在运行时查询和操作类的信息。反射对很多高级功能（框架设计、动态代理等）都很有用。反射提供了很多......
  • Java实现回文排列问题的探讨
    Java实现回文排列问题的探讨在编程的世界里，解决一个具体问题往往有多种方法，而选择合适的方法不仅能提高代码的效率，还能让代码更加优雅易懂。今天，我们就来探讨一下如何使用Java语言来解决一个有趣的问题——回文排列问题。问题描述回文排列问题源自LeetCode的第266题，它要求我们......
  • Java中将特征向量转换为矩阵的实现
    哈喽，各位小伙伴们，你们好呀，我是喵手。运营社区：C站/掘金/腾讯云/阿里云/华为云/51CTO；欢迎大家常来逛逛  今天我要给大家分享一些自己日常学习到的一些知识点，并以文字的形式跟大家一起交流，互相学习，一个人虽可以走的更快，但一群人可以走的更远。  我是一名后端开发爱好者......
  • Java实现《七星传说》游戏开发详解
    哈喽，各位小伙伴们，你们好呀，我是喵手。运营社区：C站/掘金/腾讯云/阿里云/华为云/51CTO；欢迎大家常来逛逛  今天我要给大家分享一些自己日常学习到的一些知识点，并以文字的形式跟大家一起交流，互相学习，一个人虽可以走的更快，但一群人可以走的更远。  我是一名后端开发爱好者......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99