狂神说笔记-javaSE基础

JavaSE

狂神说java基础视频地址:https://www.bilibili.com/video/BV12J41137hu?p=21

java基础 | java流程控制 java基础

目录:
1.注释、标识符、关键字Scanner
2.数据类型
3.类型转换
4.变量、常量
5.运算符
6.包机制、JavaDoc

1.注释、标识符、关键字Scanner 1.1java中的三种注解

单行注解
多行注解
文档注解

1.2标识符，关键字

**不能使用class等关键字做变量名

2.数据类型

强类型语言

要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用
举个例子：定义了一个整数，如果不进行强制的类型转换，则不可以将该整数转化为字符串。

弱类型语言

弱类型语言是一种弱类型定义的语言，某一个变量被定义类型，该变量可以根据环境变化自动进行转换，不需要经过显性强制转换。弱类型语言包括vb 、PHP、javascript等语言。

var A =5;
var B = "5";
SumResult = A +B;
MinResult = A -B；

java的数据类型分为两大类

基本数据类型
引用数据类型
区别:基本数据类型和引用类型的区别主要在于基本数据类型是分配在栈上的，而引用类型是分配在堆上的

什么是字节

3.类型转换

低到高小数的优先级大于整数。

4.变量和常量 4.1变量

变量作用域

类变量: 有static修饰，称为类变量（静态变量）；
```
 //类变量 static
    static double salary =2500;
```
|-随着类的加载而加载；
|-优先于对象存在；
|-被所有对象所共享；
|-可以直接被类名调用；
实例变量: 定义在类中但在任何方法之外。当一个对象被实例化后，每个实例变量的值就跟着确定。实例变量在对象创建的时候创建，在对象被销毁的时候销毁。
```
 //实例变量:从属于对象:如果不自行初始化，这个类型的默认值 0 0.0
    //布尔值:默认false
    //除了基本类型，其余的默认值都是null;
    String name;
    String age;
```

局部变量

    //局部变量:必须声明和初始化值
        int i = 10;
        System.out.println(i);   //如果不给i赋值会报错

4.2常量

public class Demo09 {
    //修饰符，不存在先后顺序     常量final修饰，值不能在修改
    static final  double A=10.01;
    final  static   double B=10;

    public static void main(String[] args) {
        System.out.println(A); //10.01
        System.out.println(B); //10.0
    }
}

变量的命名规范

◆所有变量、方法、类名:见名知意

◆类成员变量:首字母小写和驼峰原则: monthSalary除了第一个单词以外,后面的单词首字母大写lastName

◆局部变量:首字母小写和驼峰原则

◆常量:大写字母和下划线: MAX_VALUE

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

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

5.运算符

5.1算数运算符

+ - * /

public class Demo01 {
    public static void main(String[] args) {
        // 二元运算符
        //Ctrl + D : 复制当前行到下一行
        int a = 10;
        int b = 20;
        int c = 25;
        int d = 25;
        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
    }
}

public class Demo02 {
    public static void main(String[] args) {
        long a =123123123123L;
        int b =123;
        short c =10;
        byte d =8;
        //short e=c+d;        //short+byte  Int类型
        System.out.println(a+b+c+d);  //Long
        System.out.println(b+c+d);    //Int
        System.out.println(c+d);      //Int
    }
}

++ –

package operator;

public class Demo04 {
    public static void main(String[] args) {
        //++ -- 自增，自减 一元运算符
        int a = 3;

        int b = a++;      //执行完这行代码后，先给b赋值，再自增
        //a++  a = a + 1

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

        int c = ++a;      //执行完这行代码前，先自增，再给b赋值
        //++a  a = a + 1

        System.out.println(a);    //5
        System.out.println(b);    //3
        System.out.println(c);    //5

        //幂运算 2^3  2*2*2 =8   很多运算，我们会使用一些工具类来操作!
        double pow =Math.pow(2,3);           //相当于2的三次方
        System.out.println(pow);   //8.0
    }
}

short+byte Int类型

5.2关系运算符

< > == != %

public class Demo03 {
    public static void main(String[] args) {
        //关系运算符返回的结果:    正确，错误  布尔值

        int a =10;
        int b =20;
        int c =21;

        //取余，模运算
        System.out.println(c%a);     // 结果1           c / a   21 / 10=2......1

        System.out.println(a>b);      //false
        System.out.println(a 
 
5.3逻辑运算符 
public class Demo05 {
    public static void main(String[] args) {
        //与 (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 && b):" +!(a&&b));  //true    如果是真,则变为假,如果是假则变为真

        //短路运算
        System.out.println("a && b:" + (b&&a) );  //如果第一个是假的（b），就不用去看后面的操作就叫做短路，直接返回假
        int q = 5;
        boolean w =(q<4)&&(q++<4);        //因为第一个为假，所以没有执行后面操作
        System.out.println(w);     //false
        System.out.println(q);     //5
        boolean e =(q<6)&&(q++<4);        //以为第一个为真，执行了后面q++的操作
        System.out.println(w);     //false
        System.out.println(q);     //6
    }
}
 
5.4位运算符 
package operator;

public class Demo06 {
    public static void main(String[] args) {
        
        System.out.println(2<<3);              //16
        System.out.println(16>>3);             //2
    }
}
 
5.5条件运算符 
//三元运算符
public class Demo08 {
    public static void main(String[] args) {
        // x ? y : z
        //如果x==true, 则结果为y，否则结果为z

        int score = 80;
        String type = score <60 ?"不及格":"及格";  //掌握
        System.out.println(type);
    }

}
 
6.包机制和JavaDoc 
6.1包机制 
 
6.2JavaDoc 
通过javadoc命令生成API文档 
 
package com.yang.base;


public class Doc {
    String name;

    
    public String test(String name)throws Exception{
      return name;
    }
}

 
找到文件所在位置
 
 打开cmd输入：
  
成功后文件夹会多出很多文件，打开index.html
 
  
通过idea生成javadoc文档 
找到Toole里面的Generate javaDoc打开
  
1.选择单个文件 
2.生成后javadoc文档位置 
3.Locale 选择地区，这个决定了文档的语言，中文就是zh_CN
  
ok后显示如下
 
 生成后
  
index.html打开后
  
java流程控制 
1.用户交互Scanner 
2.顺序结构 
3.选择结构 
4.循环结构 
5.break & continue 
6.练习打印三角形 
1.用户交互Scanner,Scanner对象 
 
1.1next()和nextLine() 
next() 
 一定要读权到有效字符后才可以结束输入。
 
 对输入有效字符之前遇到的空白, next()方法会自动将其去掉。
 
 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
 
 next()不能得到带有空格的字符串。
  
public class Demo01 {
    public static void main(String[] args) {

        //创建一个扫描器对象，用于接收键盘数据
        Scanner scanner=new Scanner(System.in);         //System.in 输入

        System.out.println("使用next方法接收: ");

        //判断用户有没有输入字符串
        if(scanner.hasNext()){      
            //使用next方式接收
            String str =scanner.next();   //程序会等待用户输入完毕
            System.out.println("输入的内容为: "+str);
        }

        //凡是属于IO流的类如果不关闭会一直占用资源，要养成习惯用完关掉
        scanner.close();
    }
}
 
nextLine() 
以Enter为结束符,也就是说nextLine()方法返回的是输入回车之前的所有字符。
可以获得空白。 
public class Demo03 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入数据: ");
        String str = scanner.nextLine();
        System.out.println("输出的内容为: "+str);
        scanner.close();
    }
}
 
scanner.hasNext()输入值才能下一步 
1.2 int 和 float 
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();
    }
}

 
1.3 我们可以输入多个数字，并求其总和与平均数，没输入一个数字用回车确认，通过输入非数字来结束并输出执行结果: 
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++;
            sum=sum+x;
            System.out.println("输入了第"+m+"个数据，"+"数据为:"+x);
        }
        System.out.println("输入了"+m+"个数,"+"平均值是:"+(sum/m)+"总和为:"+sum);
        
        scanner.close();

    }
}
 
2.顺序结构 
 
2.1 从上到下依次执行 
 
3.选择结构 
3.1 if单选择结构 
 
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();
    }
}
 
3.2 if双选择结构 
 
public class IfDemo02 {
    public static void main(String[] args) {
        //考试分数大于60就是及格，小于60就是不及格。
        System.out.print("请输入你的成绩:");
        Scanner scanner = new Scanner(System.in);
        int score=scanner.nextInt();
        if (score>=60){
            System.out.println("及格");
        }else{
            System.out.println("不及格");
        }
        scanner.close();
    }
}

 
3.3 if多选择结构 
 
public class IfDemo03 {
    public static void main(String[] args) {
        
        System.out.print("请输入你的成绩:");
        Scanner scanner = new Scanner(System.in);
        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("恭喜你，E级!");
        }else if (score<60&&score>0){
            System.out.println("不合格，F级!");
        }else {
            System.out.println("不在审评分数内！");
        }
        scanner.close();
    }
}
 
3.4 嵌套的if结构 
 
3.5 switch多选择结构 
 
public class SwitchDemo01 {
    public static void main(String[] args) {

        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("不存在的等级!");
        }
    }
}
 
public class SwitchDemo02 {
    public static void main(String[] args) {
        String name = "阳";
        //JDK7的新特性，表达式结果可以是字符串!!!
        //字符的本质还是数字

        //反编译  java---class (字节码文件)---反编译(IDEA)
        switch(name){
            case "阳":
                System.out.println("阳!");
                break;
            case "辰":
                System.out.println("辰!");
                break;
            default:
                System.out.println("不存在!");
        }
    }
}
 
3.6 反编译 
反编译 java—class (字节码文件)—反编译(IDEA) 
先找到编译后的class文件位置
 
 复制编译的class文件 

 放在它的java文件中
  
打开
  
4.循环结构 
4.1 while循环 
 while是最基本的循环，它的结构为:
 while(布尔表达式){
    //循环内容
}
 
 只要布尔表达式为true,循环就会一直执行下去。
 
 我们大多数情况是会让循环停止下来的，我们需要一个让表达式失效的方式来结束循环。
 
 少部分情况需要循环一直执行,比如服务器的请求响应监听等。
 
 循环条件一直为true就会造成无限循环【死循环】,我们正常的业务编程中应该尽量避免死循环。会影响程序性能或者造成程序卡死奔溃!
 
 思考:计算1+2+3+…+100=?
  
输出1~100 
public class WhileDemo01 {
    public static void main(String[] args) {
        //输出1~100
        int i = 0;
        while(i<100){
            i++;
            System.out.println(i);
        }

    }
}
 
思考:计算1+2+3+…+100=? 
public class WhileDemo03 {
    public static void main(String[] args) {
       //思考:计算1+2+3+...+100=?
        //高斯的故事 1＋100＝101，2＋99＝101，3＋98＝101，……，49＋52＝101，50＋51＝101，一共有50对和为 101的数目，所以答案是 50×101＝5050。
        int i=1;
        int sum=0;
        while(i<=100){
             sum=sum+i++;
        }
        System.out.println(sum);
    }
}
 
4.2 do…while循环 
 
public class DoWhileDemo01 {
    public static void main(String[] args) {
        int i = 1;
        int sum = 0;

        do{
            sum=sum+i++;
        }while (i<=100);
        System.out.println(sum);
    }
}
 
do while 总会执行一次 
public class DoWhileDemo02 {
    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);
    }
}
 
4.3 for循环 
public class ForDemo01 {
    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:计算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+"偶数的和:"+evenSum);
 
练习2:用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();
                }
            }
        }
 
练习3:打印九九乘法表 
//1.我们先打印第一列,这个大家应该都会
//2.我们把固定的1再用一个新环包起来
//3.去掉重复项,i<=j
//4.调整样式
public class ForDemo04 {
    public static void main(String[] args) {
        //3.练习3:打印九九乘法表
        for(int i=1; i<10;i++){
            for (int j=1;j<=i;j++){
                System.out.print(j+"*"+i+"="+i*j+"t");
            }
            System.out.println();
        }
    }
}
 
4.4 在Java5中引入了一种主要用于数组的增强型for循环 
 
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);
        }
    }
}
 
5.break&Continue 
 
5.1 break 
//break在任何循环语句的主体部分,均可用break控制循环的流程。 
// break用于强行退出循环,不执行循环中剩余的语句。(break语句也在switch语句中使用) 
public class BreakDemo {
    public static void main(String[] args) {
        int i = 0;
        while (i<100){
            i++;
            System.out.println(i);
            if (i==30){
                break;
            }
        }
        System.out.println("break跳出循环");
    }
}
 
5.2 continue 
//continue 语句用在循环语句体中,用于终止某次循环过程,即跳过循环体中尚未执行的语句,接着进行下一次是否执行循环的判定。 
public class ContinueDemo {
    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);
        }
    }
}
 
5.3 了解就行 
public class LabelDemo {
    public static void main(String[] args) {
        //打印101-150之间所有的质数
        // 质数是指在大于1的自然数中,除了1和它本身以外不再有其他因数的自然数。

        int count = 0;
        outer:for (int i = 101; i <150 ; i++) {
            for (int j = 2; j
                if (i%j ==0){
                    continue outer;
                }
            }
            System.out.print(i+" ");
        }

    }
}
 
6.打印三角形 
public class TestDemo {
    public static void main(String[] args) {
        //打印三角形 5行
        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
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

狂神说笔记-javaSE基础

Java相关栏目本月热门文章