3.java基础

java基础

java入门

java特性和优势

简单性
面向对象
可移植性
高性能
分布式
动态性
多线程
安全性
健壮性

java三大版本

javase标准版 (桌面程序、控制台开发.......)
javame嵌入式开发（手机、小家电......） 注意：已经很少使用
javaee企业级开发（web、服务器端开发.......）

卸载jdk

删除Java的安装目录
删除JAVA_HOME
删除path下关于Java的目录
java-version

安装jdk

百度搜索JDK8，找到下载地址。
同意协议
下载电脑相应版本
双击安装jdk
记住安装的路径
配置环境变量
1. 我的电脑-->右键-->属性
2. 环境变量-->JAVA_HOME
3. 配置path变量（bin、jre）
测试jdk是否安装

1.打开cmd

2.java -version

HelloWorld

随便新建一个文件夹，存放代码
新建一个文件夹
- 文件后缀名为.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文件

[注意]1.cmd在文件目录下打开

2.无法加载主类删除环境变量中classpath

链接： 无法加载主类

可能遇到的情况

每个单词的大小写不能出现问题，java的大小写是敏感的
尽量使用英文
文件名和雷鸣必须保持一致，并且首字母大写
符号不要使用英文

java运行机制

编译型（整个程序编译完执行）
解释性（边写边执行）

IDEA

快捷键

1. psvm 头语句
1. sout   输出语句

1.新建empt project

2.project structure 选择jdk1.8

java基础

注释

单行注释
多行注释

文档注释

//单行注释
/*多行注释*/
/**文档注释*/

注意：书写代码是一个非常好的习惯

标识符

关键字

注意：Java所有的组成部分都需要名字，类名、变量名以及方法名都被成为标识符

标识符注意

所有的标识符以字母、美元符、下划线开头。
首字符之后可以为字母、美元符、下划线或数字。
不能使用关键字作为变量名或方法名
标识符大小写敏感
支持中文命名

数据类型

1.强类型语言：变量的使用要严格符合规定，所有变量必须先定义后才能使用
（弱类型语言）

基本数据类型：byte,short,int,long;float,double;char;boolean

引用数据类型：类、接口、数组

public class Demo2 {
    public static void main(String[] args) {
        //八大基础数据类型

        //整数
        int num1 = 10;  //最常用
        byte num2 = 20;
        short num3 = 30;
        long num4 =30L;  //Long类型要在数字后面价格L

        //小数，浮点数
        float num5 = 50.1F;  //float类型要在数字后面加个F
        double num6=3.5464544541416516515151;

        //字符
        char name = '国';  //1.使用单引号，双引号报错  2.只能是单个字

        //字符串，String不是关键字，类
        //String namea = "徐攀";

        //布尔值：是非
        boolean flag = true;
        //boolean flag = false;
        System.out.println(num4);
    }
}

字节

数据类型扩展及其面试题

public class Demo3 {
    public static void main(String[] args) {
        //整数扩展：     进制      二进制0b   十进制    八进制0    十六进制0x

        int i = 10;
        int i2 = 010;
        int i3 = 0x10;
        System.out.println(i);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println("==========================================");
        //==========================================================
        //浮点数扩展？   银行业务怎么表示？
        //==========================================================
        //flout     有限  离散  舍入误差  大约  接近但不等于
        //double
        //最好完全使用浮点数比较
        //最好完全使用浮点数比较
        //最好完全使用浮点数比较

        float f = 0.1f;   //0.1
        double d = 1.0 / 10; //0.1

        System.out.println(f == d);   //false

        float d1 = 232322323233212f;
        float d2 = d1 + 1;
        System.out.println(d1 == d2);  //true

        //==========================================
        //字符扩展？
        //==========================================
        char c1 = 'a';
        char c2 = '中';
        System.out.println(c1);
        System.out.println((int) c1);  //强制换行
        System.out.println(c2);
        System.out.println((int) c2);  //强制换行

        //所有字符本质上还是数字
        // 编码  Unicode 表：（97 = a  65 = A）    2字节   0-65536    Excel  2  16  =65536

        // U0000  UFFFF

        char c3 = '\u0061';

        System.out.println(c3);  //a

        //转义字符
        // \t    制表符
        // \n    换行符
        //.......
        System.out.println("Hello\nWorld");

        System.out.println("================================");
        String sa = new String("hello world");
        String sb = new String("hello world");
        System.out.println(sa == sb);

        String sc = "hello world";
        String sd = "hello world";
        System.out.println(sc == sd);
        //对象   从内存分析   一个new开辟一个内存，内存和内存之间不一样的

        //布尔值扩展
        boolean flag = true;
        if (flag == true) {}  //新手
        if (flag) {}          //老手
        //代码要精简易读
    }
}

类型转换

分为强制类型转换和自动类型转换。前者是低到高，后者是高到低。
从低到高为：
byte,short,char=>int=>long=>float=>double
1.不能对Boolean值进行转换
2.不能把对象类型转换为不相干的类型
3.把高容量转换到低容量的时候强制转换
4.转换的时候可能存在内存溢出，或是精度问题

package com.xupanstudy.javajc;

public class Demo4 {
    public static void main(String[] args) {
        int i = 128;
        byte b =(byte)i;             //内存溢出

        //强制转换   （类型）变量名    高--低
        //自动装换     低--高
        System.out.println(i);
        System.out.println(b);
        System.out.println("===========================");
        System.out.println((int)23.7);  //23
        System.out.println((int)-45.89f);   //-45
        char c = 'a';
        int d = c+1;
        System.out.println(d);
        System.out.println((char)d);

        //操作比较大的数的时候，注意溢出问题
        //JDK7新特性，数字之间可以用下划线分割
        int money = 10_0000_0000;
        int years = 20;
        int total = money*years;  //-1474836480
        long total2 = money*years;  //-1474836480
        System.out.println(total);
        System.out.println(total2); //默认是int，转换之前就存在问题了
        long total3 = money*((long)years);
        System.out.println(total3);  //2000000000

    }
}

变量

声明：数据类型变量名 = 值
变量作用域：类变量、实例变量和局部变量
常量：初始化之后不会再改变的值。常量名一般使用大写字符。

package com.xupanstudy.javajc;

public class Demo5 {

    //类变量  static
    static double salary = 2500;

    //属性：变量
    //实例变量：从属于对象;如果不自行初始化，这个类型的默认值0  0.0
    //布尔值：默认是false
    //除了基本类型，其余的默认值都是null
    String name;
    int age;


    public static void main(String[] args) {

        //局部变量:必须声明和初始化值
        int i = 10;
        System.out.println(i);

        //变量类型  变量名字  =new com.xupanstudy.javajc.Demo5
        Demo5 deno5 = new Demo5();
        System.out.println(deno5.age);
        System.out.println(deno5.name);

        //类变量  static
        System.out.println(salary);

    }
    //其他方法
    public void add(){
    }
}

常量

package com.xupanstudy.javajc;

public class Demo6 {

        //修饰符，不存在先后顺序
        static final double PI = 3.14;

        public static void main(String[] args) {
            System.out.println(PI);
        }

    }

变量的命名规范

java运算符

Java语言支持如下运算符

算术运算符：+、-、*、/、%、++、— 。“%”运算符叫模运算（取余数）
赋值运算符=。例：a=10,意思为把10赋值给a。
关系运算符：>、<、>=、<=、!=instanceof 。注意：java的等于需要用两个等于号表示。“!=”符号的意思是不等于。
逻辑运算符：&&、||、!（与、或、非）
位运算符：&、|、^、~、>>、<<、>>>（了解掌握）
条件运算符：？：
扩展赋值运算符：+=、-=、*=、/=

算术运算符、赋值运算符、关系运算符

public class Demo05 {
    public static void main(String[] args) {
        //二元运算符
        //ctrl+D：复制当前行到下一行。
        int a=10;
        int b=20;
        System.out.println(a+b);//输出结果30
        System.out.println(a-b);//输出结果-10
        System.out.println(a*b);//输出结果200
        System.out.println(a/(double)b);//输出结果0.5，结果出现小数需要先强制转换
        long c=123123123123123L;
        int d=123;
        short e=10;
        byte f=8;
        System.out.println(c+d+e+f);//输出结果是123123123123264，long类型。
        System.out.println(d+e+f);//输出结果是141，int类型。
        System.out.println(e+f);//输出结果是18，int类型。
        //将e+f结果强制转换成字符串，显示错误，提示为Inconvertible types; cannot cast 'int' to 'java.lang.String'，证明结果是int类型。
        //关系运算符返回的结果：正确、错误
        System.out.println(a>b);//输出结果false
        System.out.println(a<b);//输出结果true
        System.out.println(a!=b);//输出结果true
        System.out.println(d%a);//模运算（取余数），输出结果3
    }
}

注意事项：

运算时如有数字的类型高于int，计算的结果是高于int的那个类型，如：c赋值是long类型输出结果是long类型。
运算时如有数字是int或低于int的类型，计算的结果则都为int，如e是short类型，f是byte类型结果是int类型。

自增自减运算符、Math工具类初步了解。

//++自增运算，--自减运算，一元运算符。
int a=10;
int b=a++;//执行完这行代码后自增1。先进行b=a赋值，然后a自增1
System.out.println(a);//输出结果11
int c=++a;//执行完这行代码前自增1。先进行a自增1赋值，然后c=a赋值
System.out.println(a);//输出结果12
System.out.println(b);//输出结果10
System.out.println(c);//输出结果12
//注意事项自增，自减赋值时需要使用变量，不能直接使wei用数字。如int b=a++;不能写成int b=10++;
//幂运算2^3 相当2*2*2=8，很多运算，会使用一些工具类来操作。
double pow=Math.pow(2,3);//Java是没有幂运算符号的写法,是要使用Math.pow（a,b）这个方法。
System.out.println(pow);//输出结果8.0

逻辑运算符、位运算符

//逻辑运算符，与（and）、或（or）、非（取反）
 boolean a=true;
 boolean b=false;
 System.out.println("a&&b:"+(a&&b));//输出结果false，逻辑与运算，两个变量都为真,结果才为true。
 System.out.println("a||b:"+(a||b));//输出结果true，逻辑或运算，两个变量一个为真，结果为true。
 System.out.println("!(a&&k):"+!(a&&b));//输出结果true，逻辑非运算，如果是真则变为假，如果是假则变为真。
 //短路运算，逻辑与运算的特殊情况，如果逻辑判断第一个变量为假，则整个运算结束返回结果假，不再进行运算。
 int c=5;
 boolean d=(c<4)&&(d++<4);
 System.out.println(d);//输出结果false
 System.out.println(c);//输出结果5
 //第一个变量结果为false，运算终止c输出还是5没有自增。
 /*位运算符，&（与）、|（或）、^（异或）、~（非）、<<（左移）、>>（右移）
 A=0011 1100
 B=0000 1101
 A&B=0000 1100 ，A与B对应的位上都是1结果才是1，否则为0。
 A|B=0011 1101 ，A与B对应的位上都是0结果才是0，否则为1。或
 A^B=0011 0001 ，A与B对应的位上数字相同结果才是0，否则为1。异或
 ~B=1111 0010  ，B对应位上数字取反。
位运算计算效率极高！
 <<,左移相当*2
 >>,右移相当/2
 二进制     十进制
 0000 0000 = 0
 0000 0001 = 1
 0000 0010 = 2
 0000 0011 = 3
 0000 0100 = 4
 0000 1000 = 8
 0001 0000 = 16
  */
 System.out.println(2<<3);//结果16

扩展运算符、三元运算符

int a=20;
int b=10;
a+=b;//相当a=a+b;输出结果30
a-=b;//相当a=a-b;输出结果10
a*b=o;//相当a=a*b;输出结果200
a/=b;//相当a=a/b;输出结果2
//字符串链接符"+"
System.out.println(a+b);//输出结果30
System.out.println(""+a+b);//输出结果2010
System.out.println(a+b+"");//输出结果30
//在运算符+两侧，任何一侧出现按String类型（字符串），这时+为字符串链接符，两侧的数字变为字符串然后链接一起。
//注意事项字符串在+的顺序，如果字符串在+号后面，则+号之前的数字还是正常运算得到的结果转化为字符串然后链接。
//三元运算符?:
//x?y:z,如果x**true,则结果为y，否则结果为z
int score = 80;
String type=score<60?"不及格":"及格";
System.out.println(type);//输出结果及格

java入门

scanner

package com.xupanstudy.scanner;

import java.util.Scanner;

public class Demo01 {
    public static void main(String[] args) {

        //创建一个扫描器对象，用于接收键盘数据
        Scanner scanner = new Scanner(System.in);
        System.out.println("使用next方式接收");

        //判断用户有没有输入字符串
        if (scanner.hasNext()) {
            String str = scanner.next();
            System.out.println("输出的内容为："+str);
        }
        //凡是属于IO流的类如果不关闭会一直占用资源，要养成良好习惯
        scanner.close();
    }
}

注意：输入Hello world，只输出了Hello

package com.xupanstudy.scanner;

import java.sql.SQLOutput;
import java.util.Scanner;

public class Demo02 {

    public static void main(String[] args) {
        //创建一个扫描器对象，用于接收数据
        Scanner scanner = new Scanner(System .in);
        System.out.println("使用nextLine方式接收：");

        //判断是否还有输入
        if (scanner.hasNext());{
            String str = scanner.nextLine();
            System.out.println("输出的内容为："+str);
        }
        scanner.close();

    }
}

注意：输入Hello world，输出Hello world

next()

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

nextLine():

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

所以一般使用nextLine（）
不要忘了 scanner.close();

scanner输出具体数

package com.xupanstudy.scanner;

import java.util.Scanner;

public class Demo04 {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        //从键盘接受数据
        int i = 0;
        float f = 0.0f;
        System.out.println("请输入整数：");
        //如果。。那么
        if (scanner.hasNextInt()){
            i = scanner.nextInt();
            System.out.println("整数数据：" + i);
        }else{
            System.out.println("输出的不是整数数据！");
        }
        System.out.println("请输入小数：");
        //如果。。那么
        if (scanner.hasNextFloat()){
            f = scanner.nextFloat();
            System.out.println("小数数据：" + f);
        }else{
            System.out.println("输出的不是小数数据！");
        }
        scanner.close();
    }
}

25也被判定为一个小数，所以程序应该需要改进一点

scanner求和练习

package com.xupanstudy.scanner;

import java.util.Scanner;

public class Demo05 {
    public static void main(String[] args) {
        //我们可以输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字来结束输入并输出执行结果。
        Scanner scanner = new Scanner(System.in);
        //和
        double sum = 0;
        //计算输入了多少个数字
        int m = 0;

        //通过循环判断是否还有输入，并在里面对每一次求和和统计
        while (scanner.hasNextDouble()){
            double x = scanner.nextDouble();
            m = m+1;  //m++
            sum = sum + x;
            System.out.println("你输入了第"+m+"个数据，然后当前结果为"+sum);
        }
        System.out.println(m+"个数的和为"+sum);
        System.out.println(m+"个数的平均数为"+(sum/m));

    }
}

if选择结构

if单选择结构

```java
if(布尔表达式){
    //如果布尔表达式为true将执行的语句
}
```

package com.xupanstudy.struct;
import java.util.Scanner;
public class IfDemo01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入内容");
        String s = scanner.nextLine();

        //equals：判断字符串是否相等
        if (s.equals("hello")){
            System.out.println(s);
        }
        System.out.println("End");
        scanner.close();
    }
}

if双选择结构

if(布尔表达式){
    //如果布尔表达式为true将执行的语句
}else{
    //如果布尔表达式的值为false
}

package com.xupanstudy.struct;

import java.util.Scanner;

public class IfDemo2 {
    public static void main(String[] args) {
        //考试分数大于60分就及格，小于60分就不及格。
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入成绩");
        int score = scanner.nextInt();
        if (score>60){
            System.out.println("及格");
        }else {
            System.out.println("不及格");
        }
        scanner.close();
    }
}

if多选择结构

if(布尔表达式1){
    //如果布尔表达式为true将执行的语句
}else if(布尔表达式2){
    //如果布尔表达式2的值为true执行语句
}else if(布尔表达式3){
    //如果布尔表达式3的值为true执行语句
}else{
    //如果以上布尔表达式的值都为false
}

package com.xupanstudy.struct;

import java.util.Scanner;

public class IfDemo03 {
    public static void main(String[] args) {
        Scanner scanner =new Scanner(System.in);
        System.out.println("请输入成绩");
        int score = scanner.nextInt();

        if (score==100){
            System.out.println("恭喜满分");
        }else if(score<100 && score>=90){
            System.out.println("A级");
        }else if(score<90 && score>=80){
            System.out.println("B级");
        }else if(score<80 && score>=70){
            System.out.println("C级");
        }else if(score<70 && score>=60){
            System.out.println("D级");
        }else if(score<60 && score>=0){
            System.out.println("不及格");
        }else{
            System.out.println("成绩不合法");
        }
        scanner.close() ;
    }
}

if语句至多有1个else语句，else语句在所有的else if语句之后。
if语句可以有若干个else if语句，它们必须在else语句之前。
一旦其中一个else if语句检测为true,其他的else if以及else语句都将跳过执行。
嵌套的if结构

if(布尔表达式){
    //如果布尔表达式为true将执行的语句
    if(布尔表达式2){
    //如果布尔表达式为true将执行的语句
	}
}

switch多选择结构

switch case 语句判断一个变量与一系列值中的某个值是否相等，每一个值称为一个分支。
switch语句中的变量类型可以是：

1.byte、short、int或者char

2.从Java SE 7开始 switch支持字符串String类型了

3.同时case标签必须为字符串常量或字面量

swith(expression){
    case value :
    	//语句
    	break； //可选
    case value :
    	//语句
    	break； //可选
    default ：//可选
        //语句
}

package com.xupanstudy.struct;

public class SwitchDemo04 {
    public static void main(String[] args) {
        //case穿透  //swith   匹配一个具体的数值
        char grade = 'C';
        switch (grade){
            case 'A':
                System.out.println("优秀");
                break;  //可选
            case 'B':
                System.out.println("良好");
                break;  //可选
            case 'C':
                System.out.println("及格");
                break;  //可选
            case 'D':
                System.out.println("再接再厉");
                break;  //可选
            case 'E':
                System.out.println("挂科");
                break;  //可选
            default:
                System.out.println("未知等级");
        }
    }
}

package com.xupanstudy.struct;

public class SwitchDemo05 {
    public static void main(String[] args) {
        String name = "徐攀";
        //JDK7新特性，表达式结果可以是字符串
        //字符的本质还是数字
        //反编译
        switch(name){
            case"徐攀":
                System.out.println("徐攀");
                break;
            case"狂神":
                System.out.println("狂神");
                break;
            default:
                System.out.println("啥也不是");
        }
    }
}

循环结构

while循环结构

while(布尔表达式){
    //循环内容
}

只要布尔表达式为true,循环就会一直执行下去。
大多数情况下需要让循环停下来，需要一个让表达式失效的方式来结束循环。
少部分情况需要循环一直执行，比如服务器的请求响应监听等。
循环条件一直为true就会造成无限循环，其会影响程序性能或者造成程序卡死崩溃，需避免死循环

package com.xupanstudy.struct;

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

do......while循环

do{
    //代码语句
}while（布尔表达式）;

对于while语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。
do…while循环和while循环相似，不同的是，do…while循环至少会执行一次。

While和do-while的区别：

while先判断后执行。do-while先执行后判断
do-while总是保证循环体被至少执行一次

package com.xupanstudy.struct;

public class DoWhileDemo07 {
    public static void main(String[] args) {
        int a = 0;
        while (a<0){
            System.out.println(a);
            a++;
        }
        System.out.println("=========================");
        do {
            System.out.println(a);
            a++;
        }while (a<0);
    }
}

for循环

for(初始化；布尔表达式；更新){
    //代码语句
}
//注意：在idea中输入数字加点for  例如100.for回车，即可出现1-100的循环结构

for循环可以使一些循环结构变得更简单
for循环是支持迭代的一种通用格式，是最有效、最灵活的循环结构
for循环执行的次数是在执行前就确定的。语法格式如上

package com.xupanstudy.struct;

public class ForDemo08 {
    public static void main(String[] args) {
        int a = 1;  //初始化条件

        while(a<=100){  //条件判断
            System.out.println(a);  //循环体
            a+=2;
        }
        System.out.println("while循环结束");

        //初始化//条件判断//迭代
        for (int i=1;i<=100;i++){
            System.out.println(i);
        }
        System.out.println("for循环结束");
    }
}

关于for循环有以下几点说明：

1.最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。

2.然后检测布尔表达式的值。如果为true,循环体被执行。如果为false,循环终止，开始执行循环体后面的语句。

3.执行一次循环后，更新循环控制变量；

再次检测布尔表达式。循环执行上面的过程。

练习一：计算0-100之间的奇数和和偶数和

package com.xupanstudy.struct;

public class ForDemo09 {
    public static void main(String[] args) {
        //练习1：计算0-100之间的奇数和偶数的和

        int oddSum = 0;
        int evenSum =0;

        for (int i = 0; i < 100; i++){
            if (i%2!=0){
                oddSum+=i;
            }else{
                evenSum+=i;
            }
        }
        System.out.println("奇数的和："+oddSum);
        System.out.println("偶数的和："+evenSum);
    }
}

练习2：用while或for循环输出1-1000之间能被5整除的数，并且每行输出3个

package com.xupanstudy.struct;

public class ForDemo10 {
    public static void main(String[] args) {
        //练习二：用while或for循环输出1-1000之间能被5整除的数，并且每行输出3个
        for (int i = 1; i < 1000; i++) {
            if (i%5==0){
                System.out.print(i+"\t");
            }
            if (i%(5*3)==0){
                System.out.println();
                //System.out.println("\n");
            
        }
        //println输出完会换行
    }
}

练习3：打印九九乘法表

package com.xupanstudy.struct;
/*
1*1=1
2*1=2	2*2=4
3*1=3	3*2=6	3*3=9
4*1=4	4*2=8	4*3=12	4*4=16
5*1=5	5*2=10	5*3=15	5*4=20	5*5=25
6*1=6	6*2=12	6*3=18	6*4=24	6*5=30	6*6=36
7*1=7	7*2=14	7*3=21	7*4=28	7*5=35	7*6=42	7*7=49
8*1=8	8*2=16	8*3=24	8*4=32	8*5=40	8*6=48	8*7=56	8*8=64
9*1=9	9*2=18	9*3=27	9*4=36	9*5=45	9*6=54	9*7=63	9*8=72	9*9=81
 */
public class ForDemo11 {
    public static void main(String[] args) {
        //1.我们先打印第一列，这个大家应该都会
        //2.我们把国定的1再用一个循环包起来
        //3.去掉重复项，i<=j
        //4.调整样式
        for (int j = 1; j <= 9; j++) {
            for (int i = 1; i <= j; i++ ){
                System.out.print(j+"*"+i+"="+(j*i)+"\t");
            }
            System.out.println();
       }
    }
}

增强for循环

for(声明语句：表达式)
	{
    //代码句子
}

申明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
表达式：表达式是要访问的数组名，或者是返回值为数组的方法-
增强for循环的数组没有下标

package com.xupanstudy.struct;

public class ForDemo12 {
    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);
        }
    }
}

break,continue,goto

break

package com.xupanstudy.struct;

public class BreakDemo13 {
    public static void main(String[] args) {
        int i = 0;
        while (i<100){
            i++;
            System.out.println(i);
            if (i==30){
                break;
            }
        }
    }
}

continue

package com.xupanstudy.struct;

public class ContinueDemo14 {
    public static void main(String[] args) {
        int i = 0;
        while (i<100){
            i++;
            if (i%10==0){
                System.out.println();
                continue;
            }
            System.out.print(i);
        }
    }
}

goto(了解)

public static void main(String[] args) {
    //打印101-150之间所有的质数
    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+"\t");
    }

打印三角形以及debug

打印三角形

package com.xupanstudy.struct;

public class TestDemo15 {
    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();
        }


    }
}

debug

posted @ 2022-04-24 16:38 称霸狗熊岭阅读(43) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 1.Markdown学习

· 2.快捷键和DOS命令

· Java入门笔记

· 01 java基础

· 3.Java特性和优势

公告

昵称：称霸狗熊岭
园龄： 2年10个月
粉丝： 0
关注： 2

+加关注

2025年3月

日

一

二

三

四

五

六

随笔档案

2022年4月(3)

xp20010520java

3.java基础

java基础

java入门

java特性和优势

java三大版本

卸载jdk

安装jdk

HelloWorld

可能遇到的情况

java运行机制

IDEA

快捷键

java基础

注释

标识符

关键字

标识符注意

数据类型

字节

数据类型扩展及其面试题

类型转换

变量

常量

变量的命名规范

java运算符

算术运算符、赋值运算符、关系运算符

自增自减运算符、Math工具类初步了解。

逻辑运算符、位运算符

扩展运算符、三元运算符

java入门

scanner

scanner输出具体数

scanner求和练习

if选择结构

if单选择结构

if双选择结构

if多选择结构

switch多选择结构

循环结构

while循环结构

do......while循环

for循环

增强for循环

break,continue,goto

break

continue

goto(了解)

打印三角形以及debug

debug

公告

搜索

常用链接

随笔档案

阅读排行榜