ICode9

精准搜索请尝试: 精确搜索
首页 > 编程语言> 文章详细

JAVA基础

2021-01-19 23:59:09  阅读:125  来源: 互联网

标签:语句 JAVA int 基础 循环 数组 Java 方法


JAVA基础

2020年11月27日

21:01

1 预科

a. 什么是计算机

  • 能够按照程序运行,自动、高速处理海量数据的现代化智能电子设备。

  • 由硬件常见的形式有台式计算机、笔记本计算机、大型计算机等。和软件所组成

  • 广泛应用在︰科学计算,数据处理,自动控制,计算机辅助设计,人工智能,网络等领域

b. 硬件及冯诺依曼结构(CPU 内存,主板)

c . 计算机软件

​ 1. 系统软件:DOS(Disk Operating System)Windows,Linux,Unix,Android,IOS

​ 2. 应用软件:WPS,QQ,微信,联盟,绝地求生

d. 基本DOS命令

常用的Dos命令

  1. 开始+系统+命令提示符
  2. Win键+R输入cmd 打开控制台(推荐使用)
  3. 在任意的文件夹下面,按住shift键+鼠标右键点击,在此处打开命令行窗口
  4. 资源管理器的地址栏前面加上cmd路径管理员方式运行:选择以管理员方式运行

常用的Dos命令

 盘符切换

 查看当前目录下的所有文件 dir

#切换目录 cd change directory

cd..

#清理屏幕c1s(clear screen)

#退出终端exit

#查看电脑的ip ipconfig

#打开应用

calc

mspaint

notepad

#ping 命令

ping [www.baidu.com](http://www.baidu.com)


#文件操作

md 目录名

rd目录名

cd>文件名

del文件名

e. 计算机语言发展史

​ 第一代语言

​ ◆机器语言

​ ◆我们都知道计算机的基本计算方式都是基于二进制的方式。

​ ◆二进制:010111001010110010110100

​ ◆这种代码是直接输入给计算机使用的,不经过任何的转换!

​ 第二代语言

​ ◆汇编语言

​ ◆解决人类无法读懂机器语言的问题

​ ◆指令代替二进制

​ ◆目前应用:

​ ◆逆向工程

​ ◆机器人

​ ◆病毒

​ ◆…

​ 第三代语言

​ ◆摩尔定律

​ ◆当价格不变时,集成电路上可容纳的晶体管数目,约每隔18个月便会增加一倍,性能也将提升一倍。换言之,每一美元所能买到的电脑性能,将每隔18个月翻两倍以上

​ ◆高级语言

​ ◆大体上分为:面向过程和面向对象两大类。

​ ◆C语言是典型的面向过程的语言。C++、JAVA是典型的面向对象的语言。

​ ◆聊聊各种语言:

​ ◆C语言

​ ◆C++语言

​ ◆JAVA语言

​ ◆C#语言

​ ◆Python、PHP、JavaScript

​ ◆…

2 Java入门

01:Java帝国的诞生

02:Java特性和优势

​ ◆简单性

​ ◆面向对象

​ ◆可移植性

​ ◆高性能

​ ◆分布式

​ ◆动态性

​ ◆多线程

​ ◆安全性

​ ◆健壮性

03:Java三大版本

​ ◆Write Once、Run Anywhere

​ ◆JavaSE:标准版(桌面程序,控制台开发.……)

​ ◆JavaME:嵌入式开发(手机,小家电.……)

​ ◆JavaEE:E企业级开发(web端,服务器开发.…)

04:JDK, JRE、JVM

​ ◆JDK:Java Development Kit

​ ◆JRE:Java Runtime Environment

​ ◆JVM:JAVA Virtual Machine

05:Java开发环境搭建

​ ◆JDK下载与安装

​ ◆配置环境变量

​ ◆JDK目录介绍

​ ◆HelloWorld 及简单语法规则

​ ◆Notepad++安装和使用

卸载JDK

​ 1.删除Java的安装目录

​ 2.删除AVA_HOME

​ 3.删除path下关于Java的目录

​ 4.java -version

安装JDK

​ 1.百度搜索JDK8,找到下载地址

​ 2.同意协议

​ 3.下载电脑对应的版本

​ 4.双击安装JDK

​ 5.记住安装的路径

​ 6.配置环境变量

​ 1.我的电脑->右键->属性

​ 2.环境变量->JAVAHOM日

​ 3.配置path变量

​ 7.测试JDK是否安装成功

​ 1.打开cmd

​ 2.java -version

06:HelloWorld详解

​ HelloWorld

​ 1.随便新建一个文件夹,存放代码

​ 2.新建一个java文件

​ 文件后缀名为.java

​ Hello.java

​ 【注意点】系统可能没有显示文件后缀名,我们需要手动打开

​ 3.编写代码

public class Hello{

	public static void main(string[]args){

		system.out.print("Hello,world!");

}

​ 4.编译 javac java文件,会生成一个class文件

​ 5.运行class文件,java class文件

07: Java程序运行机制

​ ◆编译型

​ ◆解释型
​ ◆程序运行机制

08: 使用IDEA开发

3. Java基础

01:注释

​ ◆Javoa中的注释有三种:

​ ◆单行注释
​ ◆多行注释
​ ◆文档注释

02: 标识符

​ ◆关键字

​ ◆单行注释

标识符注意点

  • 所有的标识符都应该以字母(A-z或者a-z),美元符($)、或者下划线()开始

  • 首字符之后可以是字母(A-z或者a-z),美元符($)、下划线()或数字的任何字符组合

  • 不能使用关键字作为变量名或方法名。

  • 标识符是大小写敏感

  • 合法标识符举例:age、$salary、_value、_1_value

  • 非法标识符举例:123abc、-salary、#abc

    public static void main(String[]args){
        string 王者荣耀 = "最强王者";
        System.out.println(王者荣耀);
         }
    
  • 可以使用中文命名,但是一般不建议这样去使用,也不建议使用拼音,很Low

03: 数据类型

  • 强类型语言
    ◆要求变量的使用要严格符合规定,所有变量都必须先定义才能使用

  • 弱类型语言
    ◆Java的数据类型分为两大类
    ◆基本类型(primitive type)

    ◆引用类型(reference type)

    什么是字节
    ◆位(bit):是计算机内部数据储存的最小单位,11001100是一个八位二进制数。
    ◆字节(byte):是计算机中数据处理的基本单位,习惯上用大写B来表示,
    ◆1B(byte,字节)=8bit(位)
    ◆字符:是指计算机中使用的字母、数字、字和符号

1bit表示1位,
1Byte表示一个字节1B=8b。
1024B=1KB1024KB=1M1024M=1G.

04: 数据类型扩展及面试题讲解

​ 浮点数据类型不能完全用来比较。

05: 类型转换

◆由于Java是强类型语言,所以要进行有些运算的时候的,需要用到类型转换。

低------------------------------------>高
byte,short,char->int->long->float->double

◆运算中,不同类型的数据先转化为同一类型,然后进行运算。
◆强制类型转换

◆运算中,不同类型的数据先转化为同一类型,然后进行运算。
◆强制类型转换

◆自动类型转换

注意点:
1.不能对布尔值进行转换

2.不能把对象类型转换为不相干的类型
3.在把高容量转换到低容量的时候,强制转换
4.转换的时候可能存在内存溢出,或者精度问题!

06: 变量、常量、作用域

变量
◆变量是什么:就是可以变化的量!
◆Java是一种强类型语言,每个变量都必须声明其类型。
◆Java变量是程序中最基本的存储单元,其要素包括变量名,变量类型和作用域

type varName[=value][{,varName[=value]}];
//数据类型变量名=值;可以使用逗号隔开来声明多个同类型变量。

◆注意事项:
· 每个变量都有类型,类型可以是基本类型,也可以是引用类型。
· 变量名必须是合法的标识符。
· 变量声明是一条完整的语句,因此每一个声明都必须以分号结束

变量作用域
◆类变量 static 定义在类中,方法块外直接引用
◆实例变量 定义在类中,方法块外,引用时用new进行实例化,若不初始化,默认值为0.(除了基本类型,其余默认值都是null)

//变量类型  变量名字 = new 变量名();

◆局部变量 定义在方法块中,必须声明和初始化值,直接引用

public class Variable{
static int allClicks=e;//类变量
    String str="hello world";//实例变量
    public void method(){
		inti=e;//局部变量
}

常量
◆常量(Constant):初始化(initialize)后不能再改变值!不会变动的值。
◆所谓常量可以理解成一种特殊的变量,它的值被设定后,在程序运行过程中不允许被改变。(修饰符不存在先后顺序 final static)

final 常量名=值;
final double PI=3.14;

◆常量名一般使用大写字符。

变量的命名规范
◆所有变量、方法、类名:见名知意
◆类成员变量:首字母小写和驼峰原则:monthSalary
◆局部变量:首字母小写和驼峰原则常量:大写字母和下划线:MAX VALUE

◆类名:首字母大写和驼峰原则:Man,GoodMan

◆方法名:首字母小写和驼峰原则:run(),runRun0

07: 基本运算符

◆Java 语言支持如下运算符:

·算术运算符:+,,,/,%,++,–
·赋值运算符=
·关系运算符:>,<,>=,<=,==,!=instanceof
·逻辑运算符:&&,l,!
·位运算符:&,|,A,~,>>,<<,>>>(了解!!!)
·条件运算符?:
·扩展赋值运算符:+=,=,
=,/=

二元运算时自动低转高(a%b 对a取余)

08: 自增自减运算符初识Math类

​ a++ 执行后加一先赋值后自增

​ ++a 加一后执行先自增后赋值

09:逻辑运算符、位运算符

//与(and)或(or)非(取反)
boolean a=true;
boolean b=false;
System.out.print1n("a 8&b:"+(a&&b));//逻辑与运算:两个变量都为真,结果才为true 
System.out.print1n("a || b:"+(allb));//逻辑或运算:两个变量有一个为真,则结果才为true 
System.out.print1n("!(a&&b):"+!(a&&b));//如架是真,则变为假,如果是假则变为真
//短路运算

​ 位运算

/*
A=00111100
B=00001101
===================
A&B=0000 1100
A/B=0011 1101
A^B=0011 0001
~B=1111  0010
===========================================================
2*8=16    2*2*2*2

<<   *2
>>	 /2
    
    0000 0000  0
     0000 0001  1
     0000 0010  2
     0000 0011  3
     0000 0100  4
     0000 1000  5
     0001 0000  6
*/
System.out.println(2<<3);

10:三元运算符及小结

	int a=10;
    int b=20;
        
    a+=b;//a=a+b
    a-=b;//a=a-b 
    System.out.println(a);
     //字符串连接符+,string 
    System.out.printin(""+a+b);//拼接
	System.out.println(a+b+"") ;//运算
===========================================================
	//三元运算符
	//	x?y:z
	//如果x==true,则结果为y,否则结果为z

10:包机制

◆为了更好地组织类,Java提供了包机制,用于区别类名的命名空间。
◆包语句的语法格式为:

package pkg1[.pkg2[.pkg3..J];

一般利用公司域名倒置作为包名;
◆为了能够使用某一个包的成员,我们需要在Java 程序中明确导入该包。使用“import”语句可完成此功能

import package1[.package2..].(classnamel*);

11:包JavaDoce生成文档

◆javadoc命令是用来生成自己API文档的
◆参数信息
◆@author作者名
◆@version 版本号
◆@since 指明需要最早使用的jdk版本
◆@param参数名
◆@return 返回值情况
◆@throws 异常抛出情况

package com. kuang. base;
/**
*@ author sha
*@ version 1.e
*@ since 1.8
*/
public class Doc{
String name;
/**
*@ author sha
*@ param name
*@ return
*@ throws Exception */
public string test(string name) throws Exception{
return name;
}

4. Java流程控制

01:用户交互Scanner

Scanner对象

◆之前我们学的基本语法中我们并没有实现程序和人的交互,但是Java给我们提供了这样一个工具类,我们可以获取用户的输入。之前我们学的基本语法中我们并没有实现程序和人的交互,但是Java给我们提供了这样一个工具类,我们可以获取用户的输入。java.util.Scanner是Java5的新特征,我们可以通过Scanner类来获取用户的输入。

◆基本语法:

scanner s =new Scanner(System.in);

◆通过Scanner类的next()与nextLine()方法获取输入的字符串,在读取前我们一般需要使用hasNext()与hasNextLine()判断是否还有输入的数据。

//凡是属于属于IO流的数如果不关闭会一直占用资源,要养成好习惯用完关掉。

◆next():

  • 1、一定要读取到有效字符后才可以结束输入。
  • 2、对输入有效字符之前遇到的空白,next(方法会自动将其去掉。
  • 3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
  • 4、next0不能得到带有空格的字符串。

◆nextLine():

  • 1、以Enter为结束符,也就是说nextLine()方法返回的是输入回车之前的所有字符。
  • 2、可以获得空白。

02:Scanner进阶使用

package text;
import java.util.Scanner;
public class Demo03 {
    public static void main(String[] args) {
        //输入多个数字,,并求其和与平均数,没输入一个数字用回车确认,通过输入非数字来结束输入并输出执行结果。
        Scanner input = new Scanner(System.in);
        //和
        double sum = 0;
        //计算输入了多少个数字
        int m = 0;
        //要通过循环判断每一次输入并在里面对每一次进行求和和统计
        while (input.hasNextDouble()) {
            double x = input.nextDouble();
            m = m + 1;
            sum = sum + x;
        }
        System.out.println(m + "个数的和为" + sum);
        System.out.println(m + "个数的平均值是" + sum / m);
        input.close();
    }
}

03:顺序结构

  • JAVA的基本结构就是顺序结构,除非特别指明,否则就按照顺序一句一句执行。

  • 顺序结构是最简单的算法结构。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IPMnoClS-1611071177064)(C:\Users\luoluo\AppData\Roaming\Typora\typora-user-images\image-20210116100409781.png)]

  • 语句与语句之间,框与框之间是按从上到下的顺序进行的,它是由若干个依次执行的处理步骤组成的,它是任何一个算法都离不开的一种基本算法结构。

04:if选择结构

  1. if单选择结构

    • 我们很多时候需要去判断一个东西是否可行,然后我们才去执行,这样一个过程在程序中用if语句来表示

      [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bd5OINKI-1611071177066)(C:\Users\luoluo\AppData\Roaming\Typora\typora-user-images\image-20210116101212337.png)]

    • 语法:

       if(布尔表达式){
          //如果布尔表达式为true将执行的语句 
       }
       
      
  2. if双选择结构

    • 那现在有个需求,公司要收购一个软件,成功了,给人支付100万元,失败了,自己找人开发。这样的需求用一个if就搞不定了,我们需要有两个判断,需要一个双选择结构,所以就有了if-else结构。

      [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-suiynJ7c-1611071177067)(C:\Users\luoluo\AppData\Roaming\Typora\typora-user-images\image-20210116103851605.png)]

    • 语法:

      if(布尔表达式){
      //如果布尔表达式的值为true}else{
      }else{
      //如果布尔表达式的值为false
      }
      
  3. if多选择结构

      • 我们发现刚才的代码不符合实际情况,真实的情况还可能存在ABCD,存在区间多级判断。比如90-100就是A,80-90 就是B…等等,在生活中我们很多时候的选择也不仅仅只有两个,所以我们需要一个多选择结构来处理这类问题!

        [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-m198QhX7-1611071177070)(C:\Users\luoluo\AppData\Roaming\Typora\typora-user-images\image-20210116105833743.png)]

      • 语法:

        if(布尔表达式1){
        //如果布尔表达式1的值为true执行代码
        }else if(布尔表达式2){
        //如果布尔表达式2的值为true执行代码
        }else if(布尔表达式3){
        //如果布尔表达式3的值为true执行代码
        }else {
        //如果以上布尔表达式都不为true执行代码
        }
        
  4. 嵌套的if结构

    • 使用嵌套的if…else 语句是合法的。也就是说你可以在另一个if或者else if语句中使用if 或者else if 语句。你可以像if语句一样嵌套else if…else.

    • 语法:

      if(布尔表达式*1){
      //如果布尔表达式1的值为true执行代码
      if(布尔表达式2){
      //如果布尔表达式2的值为true执行代码)
      	}
      }
      

05:Switch选择结构

  1. switch多选择结构

    • 多选择结构还有一个实现方式就是switch case语句。

    • switch case语句判断一个变量与一系列值中某个值是否相等,每个值称为一个分支。

      switch(expression){
      	case value :
      		//语句
      	break;//可选
          case value :
      		//语句
       		 break; //可选      
           //你可以有任意数量的case语句
          default : //可选
         //语句     
         }     
      
    • switch 语句中的变量类型可以是:

      • byte、short、int或者char。
      • 从Java SE 7开始
      • switch支持字符串String类型了
      • 同时case标签必须为字符串常量或字面量。

06:While循环详解

  1. while循环

    • while是最基本的循环,它的结构为:

      while(布尔表达式 ) {
      //循环内容
      }
      
    • 只要布尔表达式为true,循环就会一直执行下去。

    • 我们大多数情况是会让循环停止下来的,我们需要一个让表达式失效的方式来结束循环。

    • 少部分情况需要循环一直执行,比如服务器的请求响应监听等。

    • 循环条件一直为true就会造成无限循环【死循环】,我们正常的业务编程中应该尽量避免死循环。会影响程序性能或者造成程序卡死奔溃!

    • 思考:计算1+2+3+…+100=?

      package text;
      public class WhileDemo01 {
          public static void main(String[] args) {
              //计算1+2+3+...100=?
              int sum = 0;
              int i = 0;
              while (i <= 100) {
                  sum = sum + i;
                  i++;
              }
              System.out.println(sum);
          }
      }
      
      

07:Do…While循环

  • 对于while语句而言,如果不满足条件,则不能进入循环。但有时候我们需要即使不满足条件,也至少执行一次。

  • do…while循环和while循环相似,不同的是,do…while循环至少会执行一次。

    do {
    //代码语句
    }while(布尔表达式);
    
  • While和do-While的区别:

    • while先判断后执行。dowhile是先执行后判断!
    • Do…while总是保证循环体会被至少执行一次!这是他们的主要差别。

08:For循环

  • 虽然所有循环结构都可以用while 或者do…while表示,但Java提供了另一种语句——for循环,使一些循环结构变得更加简单。

  • for循环语句是支持迭代的一种通用结构,是最有效、最灵活的循环结构。

  • for循环执行的次数是在执行前就确定的。语法格式如下:

    for(初始化;布尔表达式;更新){
    代码语句
    }
    /*
    关于for循环有以下几点说明:
    	最先执行初始化步骤。可以声明一种类型,但可初始化一个或多个循环控制变量,也可以是空语句。
    	然后,检测布尔表达式的值。如果为 true,循环体被执行。如果为false,循环终止,开始执行循环体后面的语句。
    	执行一次循环后,更新循环控制变量(迭代因子控制循环变量的增减)。
    	再次检测布尔表达式。循环执行上面的过程。
     */
    
  • 练习1:计算0到100之间的奇数和偶数的和

    package text;
    public class F0oDemo02 {
        public static void main(String[] args) {
           int sum1=0;
           int sum2=0;
            for(int i=1;i<=100;i++){
                if(i%2==0){
                    sum1=sum1+i;
                }else{
                    sum2=sum2+i;
                }
            }
            System.out.println("0到100之间的偶数和为:"+sum1);
            System.out.println("0到100之间的奇数和为:"+sum2);
        }
    }
    
    
  • 练习2:用while或for循环输出1-1000之间能被5整除的数,并且每行输出3个

    package text;
    public class ForDemo03 {
        public static void main(String[] args) {
            int k=0;
            for (int i = 1; i <=1000; i++) {
                if(i%5==0){
                    System.out.print(i+" ");
                    k++;
                    if(k>2){
                        System.out.println("");
                        k=0;
                    }
                }
            }
        }
    }
    

    09: 打印九九乘法表

    package text;
    public class ForDemo03 {
        public static void main(String[] args) {
            int k=0;
            for (int i = 1; i <=1000; i++) {
                if(i%5==0){
                    System.out.print(i+" ");
                    k++;
                    if(k>2){
                        System.out.println("");
                        k=0;
                    }
                }
            }
        }
    }
    
    

10:增强for循环

  • 这里我们先只是见一面,做个了解,之后数组我们重点使用

  • Java5引入了一种主要用于数组或集合的增强型for循环。

  • Java增强for循环语法格式如下:

    for(声明语句:表达式){
    //代码句子
    }
    
  • 声明语句:声明新的局部变量,该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块,其值与此时数组元素的值相等。

  • 表达式:表达式是要访问的数组名,或者是返回值为数组的方法。

    package text;
    public class ForDemo05 {
        public static void main(String[] args) {
            int[] numbers = {10,20,30,40,50};
            for(int i=0;i<5;i++){
                System.out.println(numbers[i]);
            }
            System.out.println("===================");
            //遍历数组元素
            for(int x:numbers){
                System.out.println(x);
            }
        }
    }
    

11: break、continue、goto

  • break在任何循环语句的主体部分,均可用break控制循环的流程。break用于强行退出循环,不执行循环中剩余的语句。(break语句也在switch语句中使用)

  • continue语句用在循环语句体中,用于终止某次循环过程,即跳过循环体中尚未执行的语句,接着进行下一次是否执行循环的判定。

    //break在任何循环语句的主体部分,均可用break控制循环的流程。break用于强行退出循环,不执行循环中剩余的语句。(break语句也在switch语句中使用)
    //continue语句用在循环语句体中,用于终止某次循环过程,即跳过循环体中尚未执行的语句,接着进行下一次是否执行循环的判定。
    
  • 关于goto关键字

    • goto关键字很早就在程序设计语言中出现。尽管goto仍是Java的一个保留字,但并未在语言中得到正式使用;Java没有goto。然而,在break和continue这两个关键字的身上,我们仍然能看出一些goto的影子—带标签的break和continue。

    • “标签”是指后面跟一个冒号的标识符,例如: label:

    • 对Java来说唯一用到标签的地方是在循环语句之前。而在循环之前设置标签的唯一理由是:我们希望在其中嵌套另个循环,由于break和continue关键字通常只中断当前循环,但若随同标签使用,它们就会中断到存在标签的地方。

      package text;
      
      public class LablelDemo {
          public static void main(String[] args) {
              //打印101-150之间所有的质数
              //质数是指在大于1的自然数中,除了一和它本身以外不再有其他因数的自然数。
              int count = 0;
              outer:
              for (int i = 101; i <= 150; i++) {
                  for (int j = 2; j <= i / 2; j++) {
                      if (i % j == 0) {
                          continue outer;
                      }
                  }
                  System.out.print(i + " ");
              }
          }
      }
      
      

12: 打印三角形及Debug

package text;
public class TestDemo01 {
    //打印三角形
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            for (int j = 5; j >= i; j--) {
                System.out.print(" ");
            }
            for (int j = 1; j <= i; j++) {
                System.out.print("*");
            }
            for (int j = 1; j < i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

5. Java方法

01: 什么是方法

  • System.out.printIn(),那么它是什么呢?
  • Java方法是语句的集合,它们在一起执行一个功能。
    • 方法是解决一类问题的步骤的有序组合
    • 方法包含于类或对象中
    • 方法包含于类或对象中
  • 设计方法的原则:方法的本意是功能块,就是实现某个功能的语句块的集合。我们设计方法的时候,最好保持方法的原子性,就是一个方法只完成1个功能,这样利于我们后期的扩展

02: 方法的定义和调用

  • Java的方法类似于其它语言的函数,是一段用来完成特定功能的代码片段,一般情况下,定义一个方法包含以下语法:

  • **方法包含一个方法头和一个方法体。**下面是一个方法的所有部分:

    • 修饰符:修饰符,这是可选的,告诉编译器如何调用该方法。定义了该方法的访问类型。

    • 返回值类型∶方法可能会返回值。returnValueType是方法返回值的数据类型。有些方法执行所需的操作,但没有返回值。在这种情况下,returnvalueType是关键字void.

    • 方法名:是方法的实际名称。方法名和参数表共同构成方法签名。

    • 参数类型:参数像是一个占位符。当方法被调用时,传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的,方法可以不包含任何参数。

      • 形式参数:在方法被调用时用于接收外界输入的数据。
      • 实参:调用方法时实际传给方法的数据。
    • 方法体:方法体包含具体的语句,定义该方法的功能。

      修饰符返回值类型方法名(参数类型参数名){
      ...
      方法体
      ...
      return返回值;
      }
      
    • 方法调用

      • 调用方法:对象名.方法名(实参列表)

      • Java支持两种调用方法的方式,根据方法是否返回值来选择。当方法返回一个值的时候,方法调用通常被当做一个值。例如:

        int larger = max(30,40);
        
      • 如果方法返回值是void,方法调用一定是一条语句。

        System.out.println( "Hello,World! ");
        

03: 方法的重载

  • 重载就是在一个类中,有相同的函数名称,但形参不同的函数。
  • 方法的重载的规则:
    • 方法名称必须相同。
    • 参数列表必须不同(个数不同、或类型不同、参数排列顺序不同等).
    • 方法的返回类型可以相同也可以不相同。
    • 仅仅返回类型不同不足以成为方法的重载.
  • 实现理论:
    • 方法名称相同时,编译器会根据调用方法的参数个数、参数类型等去逐个匹配,以选择对应的方法,如果匹配失败,则编译器报错。

04: 命令行传递参数

  • 有时候你希望运行一个程序时候再传递给它消息。这要靠传递命令行参数给main()函数实现。

    public class CommandLine {
    	public static void main(String args[]){
    		for(int i=6; i<args.length; i++){
    		system.out.println( "args[" +i + "]: " + args[i]);
    		}
    	}
    }
    

    05: 可变参数

    • JDK 1.5开始,Java支持传递同类型的可变参数给一个方法。

    • 在方法声明中,在指定参数类型后加一个省略号(.…).

    • 一个方法中只能指定一个可变参数,它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

      public static void printMax( double. . . numbers) {
          if (numbers.length == 0) {
              System.out.println( "No argument passed");
              return;
              }
          double result = numbers[0];
          //排序!
          for (int i = 1; i <numbers.length; i++){
              result = numbers[i];
              }
          System.out.println("The max value is"+ result);
      }
      

06: 递归讲解

  • A方法调用B方法,我们很容易理解!
  • 递归就是:A方法调用A方法!就是自己调用自己
  • 利用递归可以用简单的程序来解决一些复杂的问题。它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解,递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算,大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。
  • 递归结构包括两个部分:
    • 递归头:什么时候不调用自身方法。如果没有头,将陷入死循环。
    • 递归体:什么时候需要调用自身方法。

​ 写一个计算器,要求实现加减乘除功能,并且能够循环接收新的数据,通过用户交互实现。
​ 思路推荐:
​ 写4个方法:加减乘除
​ 利用循环+switch进行用户交互传递需要操作的两个数
​ 输出结果

6. Java数组

01:什么是数组

​ 数组的定义

  • 数组是相同类型数据的有序集合.

  • 数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。

  • 其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们.

02:数组声明创建

  • 首先必须声明数组变量,才能在程序中使用数组。下面是声明数组变量的语法;

    dataType[] arrayRefVar; //首选的方法
    或
    dataType arrayRefVar[];//效果相同,但不是首选方法
    
    • Java语言使用new操作符来创建数组,语法如下:

      dataType[] arrayRefVar = new dataType[arraysize];
      
    • 数组的元素是通过索引访问的,数组索引从О开始。

    • 获取数组长度:

      arrays.length
      

03:三种初始化及内存分析

  1. 内存分析

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MtLCSI8Q-1611071177072)(C:\Users\luoluo\AppData\Roaming\Typora\typora-user-images\image-20210119221804390.png)]

  2. 三种初始化

    1. 静态初始化

      int[ ] a = {1,2,3};
      Man[ ] mans = {new Man(1,1),new Man(2,2)};
      
    2. 动态初始化

      int[] a = new int[2];
      a[0]=1;
      a[1]=2;
      
    3. 数组的默认初始化

      • 数组是引用类型,它的元素相当于类的实例变量,因此数组一经分配空间,其中的每个元素也被按照实例变量同样的方式被隐式初始化。

04:下标越界及小结

  1. 数组的四个基本特点

    • 其长度是确定的。数组一旦被创建,它的大小就是不可以改变的。
    • 其元素必须是相同类型,不允许出现混合类型。
    • 数组中的元素可以是任何数据类型,包括基本类型和引用类型。
    • 数组变量属引用类型,数组也可以看成是对象,数组中的每个元素相当于该对象的成员变量。数组本身就是对象,Java中对象是在堆中的,因此数组无论保存原始类型还是其他对象类型,数组对象本身是在堆中的。
  2. 数组边界

    • 下标的合法区间:[0, length-1],如果越界就会报错;

      public static void main(String[] args) {
      	int[] a=new int[2];
      	system.out.println(a[2]);
      }
      
    • ArrayIndexOutOfBoundsException:数组下标越界异常!

    • 小结:

      • 数组是相同数据类型(数据类型可以为任意类型)的有序集合
      • 数组也是对象。数组元素相当于对象的成员变量
      • 数组长度的确定的,不可变的。如果越界,则报:ArrayIndexOutofBounds

05:数组的使用

  • 普通的For循环
  • For-Each 循环
  • 数组作方法入参
  • 数组作返回值

06:多维数组

  • 多维数组可以看成是数组的数组,比如二维数组就是一个特殊的一维数组,其每一个元素都是一个一维数组。

  • 二维数组

    int a[][] = new int[2][5];
    
  • 解析:以上二维数组a可以看成一个两行五列的数组。

  • 思考:多维数组的使用。

    num[1][0];
    

07:Arrays类讲解

  • 数组的工具类java.util.Arrays
  • 由于数组对象本身并没有什么方法可以供我们调用,但API中提供了一个工具类Arrays供我们使用,从而可以对数据对象进行一些基本的操作。
  • 查看JDK帮助文档
  • Arrays类中的方法都是static修饰的静态方法,在使用的时候可以直接使用类名进行调用,而"不用"使用对象来调用(注意:是"不用”而不是“不能")
  • 具有以下常用功能:
    • 给数组赋值: 通过fill方法。
    • 对数组排序: 通过sort方法,按升序。
    • 比较数组: 通过equals 方法比较数组中元素值是否相等。
    • 查找数组元素: 通过binarySearch方法能对排序好的数组进行二分查找法操作。

08:冒泡排序

同类型,不允许出现混合类型。

  • 数组中的元素可以是任何数据类型,包括基本类型和引用类型。
  • 数组变量属引用类型,数组也可以看成是对象,数组中的每个元素相当于该对象的成员变量。数组本身就是对象,Java中对象是在堆中的,因此数组无论保存原始类型还是其他对象类型,数组对象本身是在堆中的。
  1. 数组边界

    • 下标的合法区间:[0, length-1],如果越界就会报错;

      public static void main(String[] args) {
      	int[] a=new int[2];
      	system.out.println(a[2]);
      }
      
    • ArrayIndexOutOfBoundsException:数组下标越界异常!

    • 小结:

      • 数组是相同数据类型(数据类型可以为任意类型)的有序集合
      • 数组也是对象。数组元素相当于对象的成员变量
      • 数组长度的确定的,不可变的。如果越界,则报:ArrayIndexOutofBounds

05:数组的使用

  • 普通的For循环
  • For-Each 循环
  • 数组作方法入参
  • 数组作返回值

06:多维数组

  • 多维数组可以看成是数组的数组,比如二维数组就是一个特殊的一维数组,其每一个元素都是一个一维数组。

  • 二维数组

    int a[][] = new int[2][5];
    
  • 解析:以上二维数组a可以看成一个两行五列的数组。

  • 思考:多维数组的使用。

    num[1][0];
    

07:Arrays类讲解

  • 数组的工具类java.util.Arrays
  • 由于数组对象本身并没有什么方法可以供我们调用,但API中提供了一个工具类Arrays供我们使用,从而可以对数据对象进行一些基本的操作。
  • 查看JDK帮助文档
  • Arrays类中的方法都是static修饰的静态方法,在使用的时候可以直接使用类名进行调用,而"不用"使用对象来调用(注意:是"不用”而不是“不能")
  • 具有以下常用功能:
    • 给数组赋值: 通过fill方法。
    • 对数组排序: 通过sort方法,按升序。
    • 比较数组: 通过equals 方法比较数组中元素值是否相等。
    • 查找数组元素: 通过binarySearch方法能对排序好的数组进行二分查找法操作。

08:冒泡排序

标签:语句,JAVA,int,基础,循环,数组,Java,方法
来源: https://blog.csdn.net/qq_46244146/article/details/112855130

本站声明: 1. iCode9 技术分享网(下文简称本站)提供的所有内容,仅供技术学习、探讨和分享;
2. 关于本站的所有留言、评论、转载及引用,纯属内容发起人的个人观点,与本站观点和立场无关;
3. 关于本站的所有言论和文字,纯属内容发起人的个人观点,与本站观点和立场无关;
4. 本站文章均是网友提供,不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属;如您发现该文章侵犯了您的权益,可联系我们第一时间进行删除;
5. 本站为非盈利性的个人网站,所有内容不会用来进行牟利,也不会利用任何形式的广告来间接获益,纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

专注分享技术,共同学习,共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有