java3月train笔记

已于 2023-02-22 16:31:54 修改
阅读量469 收藏 1
点赞数
分类专栏： IDEA 文章标签： java
于 2023-02-20 10:01:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ydyrx808/article/details/129119070
版权

java笔记

会议号：417 523 3263

day01

一、jdk和idea下载及安装（一般不建议装C盘）：

jdk：java开发环境
idea：开发工具（软件），用来编写代码的

苍老师文档服务器：doc.canglaoshi.org
jdk下载：https://repo.huaweicloud.com/java/jdk/

打开cmd窗口（win+r，输入cmd）
依次输入
java
javac
java -version进行测试

配置环境变量（win+s搜索环境变量，点击编辑系统的环境变量）
在这里插入图片描述
在这里插入图片描述
再次测试javac命令（一定要打开一个新的cmd窗口）

二、基本语法

1、数据类型

（1）基本数据类型：八种
整型：
①byte，取值范围：-128~127
②short，取值范围：-32768~32767
③int（默认），取值范围：-2147483648~2147483647
④long，数字后面需要加后缀L（l）

浮点型：
⑤float，需要加后缀F（f）
⑥double（默认），不需要加后缀

布尔型：
⑦boolean，值：true或者false

字符型：
⑧char，只能存放一个中文汉字或者一个英文字母、整数
当存放的是一个数字时，输出出来的值，是经过底层ascii码表会进行相应的转化，转化成对应的字符

package cn.td.jsd2303;

/**
 * 八大基本数据类型
 */

public class Test2 {
    public static void main(String[] args) {
        //定义变量
        //语法格式：定义的类型 变量名 = 值;

        //修改变量的值
        //语法格式：变量名 = 值;

        //整型
        byte b1 = 127;//(-128~127)
        System.out.println(b1);
        b1 = -127;
        short s1 = 30000;//(-32768~32767)
        int i1 = 210;//(-2147483648~2147483647)
        long l1 = 21432934535432L;
        System.out.println(b1);
        System.out.println(s1);
        System.out.println(i1);
        System.out.println(l1);

        //浮点型
        float f1 = 8.9F;
        double d1 = 15.6;
        System.out.println(f1);
        System.out.println(d1);

        //布尔型
        boolean bl1 = true;
        boolean bl2 = false;
        System.out.println(bl1);
        System.out.println(bl2);

        //字符型
        char c1 = '北';
        char c2 = 'W';
        char c3 = 98;
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
    }
}

（2）基本数据类型的转换：
类型从小到大排序：byte < short < int < long < float/double
char比short和byte大

小转大：自动转换
大转小：强制转换，格式：小类型 = (小类型/或者比他还小的类型)大类型;

package cn.td.jsd2303;

/**
 * 基本数据类型转换
 * byte < short < int < long < float < double
 * char比short和byte要大，和其他的相等
 */
public class Test13 {
    public static void main(String[] args) {
        byte a1 = 28;
        short s1 = 19;
        int i1 = -55;
        long l1 = 101;
        float f1 = 3.0f;
        double d1= 4.0;
        char c1 = 'A';

        //报错的原因是把大类型给到小类型了（需要的是一个byte类型，但是提供了一个short），需要强制转换
        //小类型 = 大类型;
        //a1 = s1;

        //强制转换
        //格式：小类型 = (小类型/或者比他还小的类型)大类型;
        a1 = (byte)s1;//大转小
        System.out.println(a1);

        //short = int;
        s1 = (byte)i1;

        l1 = (long)d1;
//        l1 = (char)d1;
//        l1 = (int)d1;
//        l1 = (short)d1;
//        l1 = (byte)d1;

        //小转大，直接转换，不需要强制转换
        //float = int;
        f1 = i1;
    }
}
2、运算符

（1）赋值：= += -= /= *= %=

package cn.td.jsd2303;

/**
 * 赋值运算符：= += -= *= /= %=
 */
public class Test8 {
    public static void main(String[] args) {
        //定义变量格式：变量的类型 变量名 = 变量的值;
        int i1 = 23;
        //+=：a+=b <=> a = a + b
        int i2 = 15;
//        i1 = i1 + i2;
        i1+=i2;
        System.out.println(i1);

        int b1 = 20;
        int b2 = 8;
        // ctrl + /     注释单行
//        b2 = b2 - b1;
        b2-=b1;
        System.out.println(b2);

        double d1 = 2.0;
        double d2 = 5.0;
//        d1 = d1*d2;
        d1*=d2;
        System.out.println(d1);

        int i3 = 100;
        int i4 = 5;
//        i3 = i3/i4;
        i3/=i4;
        System.out.println(i3);

        int i5 = -13;
//        i5 = i5 % i3;
        i5%=i3;
        System.out.println(i5);
    }
}

（2）逻辑：> < >= <= == !=

package cn.td.jsd2303;

/**
 * 逻辑：> < >=	<=  ==  !=
 */
public class Test9 {
    public static void main(String[] args) {
        //定义（声明）多个变量
        //语法格式：变量的类型 变量1,变量2,......;
        int i1,i2,i3,i4,i5,i6;
        boolean b1;
        i1 = 15;
        i2 = 28;
        i3 = -15;
        i4 = 19;
        i5 = 28;
        b1 = i1 > i2;
        System.out.println(b1);//false
        b1 = i2 < i3;
        System.out.println(b1);//false
        b1 = i1 >= i4;
        System.out.println(b1);//false
        b1 = i3 <= i1;
        System.out.println(b1);//true
        b1 = (i2==i5);
        System.out.println(b1);//true
        b1 = (i1!=i3);
        System.out.println(b1);//true
    }
}



package cn.td.jsd2303;

/**
 * 超市打折案例：如果购物金额达到200，打九折，达到500，打8折，达到800，打6折
 *
 * 逻辑运算符 + 分支结构
 */
public class Test10 {
    public static void main(String[] args) {
        double shopMoney = 850.0;
        if(shopMoney >= 800) {
            shopMoney = shopMoney * 0.6;
            System.out.println("您本次一共消费了：" + shopMoney + "元");
        } else if(shopMoney >= 500) {
            shopMoney = shopMoney * 0.8;
            System.out.println("您本次一共消费了：" + shopMoney + "元");
        } else {
            shopMoney = shopMoney * 0.9;
            System.out.println("您本次一共消费了：" + shopMoney + "元");
        }
    }
}

（3）&&（与）、||（或） !（非）

package cn.td.jsd2303;

/**
 * &&   A&&B，A、B都为true，结果才为true，有一个是false，结果就是false
 * ||   A||B，有一个为true，即为true，如果都为false，才是false
 * !    !A，如果A为true，结果则为false，如果A为false，结果则为true
 */
public class Test11 {
    public static void main(String[] args) {
        int i1,i2,i3,i4;
        boolean b1;
        i1 = 10;
        i2 = -13;
        i3 = 28;
        i4= 33;

        b1 = (i1 > i3) && (i4 > i3);
        System.out.println(b1);//false
        if(b1) {
            System.out.println("result1 is true");
        } else if((i1 > i4) || (i2 < i3)) {//true
            System.out.println("result2 is true");
        }

        if(!b1) {
            System.out.println("result3 is " + b1);
        }
    }
}

（4）++ –

package cn.td.jsd2303;

/**
 *  ++ --
 *  前++、后++、前--、后--
 */
public class Test7 {
    public static void main(String[] args) {
        int i1 = 10;
        //++i1;//等价于 i1=i1 + 1
        System.out.println(++i1);//11
        System.out.println(i1);//11

        int i2 = 20;
        //i2++;//等价于 i2=i2 + 1
        System.out.println(i2++);//20
        System.out.println(i2);//21

        int i3 = 51;
        int i4 = 28;
        int i5 = 0;
        i5 = i3+++--i4;
        System.out.println(i5);//78
    }
}

（5）算术：+ - * / %（取模）

package cn.td.jsd2303;

/**
 * 算术：+ - * /   %（取模）
 */
public class Test6 {
    public static void main(String[] args) {
        int i1 = 10;
        System.out.println(i1);
        i1 = i1 + 100;
        System.out.println(i1);

        int i2 = 5;
        int i3 = 8;
        int i4 = 0;
        i4 = i3 - i2 ;
        System.out.println(i4);

        //基本数据类型运算，可能会出现运算结果不精确问题，如下
        double d1 = 10;
        double d2 = 9.8;
        System.out.println(d1-d2);//0.199999......

        //% 取模（求余数）
        //大取小，得到就是余数；小取大，得到就是小的值
        int i5 = 5;
        int i6 = 3;
        int i7 = 0;
        i7 = i5%i6;
        System.out.println(i7);

        //小取大，得到那个小的值
        i5 = -1;
        i6 = 10;
        i7 = i5 % i6;
        System.out.println(i7);
    }
}

（6）三目或者三元

package cn.td.jsd2303;

/**
 * 三目或者三元
 * 格式：a>b?c:d
 *
 * 例子：找出三个数中的最大值
 */
public class Test12 {
    public static void main(String[] args) {
        int i1,i2,i3,i4;
        i1 = 10;
        i2 = 50;
        i3 = -100;
        if(i1 > i2) {//i1比i2大，拿i1和i3比
            if(i1 > i3) {
                System.out.println("max value is " + i1);
            } else {
                System.out.println("max value is " + i3);
            }
        } else {//i1比i2小，拿i2和i3比
            if(i2 > i3) {
                System.out.println("max value is " + i2);
            } else {
                System.out.println("max value is " + i3);
            }
        }

        //上面的方法虽然可行，但麻烦，推荐用三木或者三元运算符
        i4 = i1>i2? (i1>i3?i1:i3) : (i2>i3?i2:i3);
        System.out.println("max value is " + i4);
    }
}

3、流程控制
（1）分支结构
①if()…else

package cn.td.jsd2303;

/**
 * if else结构
 */
public class Test3 {
    public static void main(String[] args) {
        boolean b1 = false;
        if(b1) {
            System.out.println("this true");
        } else {
            System.out.println("this false");
        }
    }
}

②if()…else if()…else

package cn.td.jsd2303;

/**
 * if...else if...else
 */
public class Test4 {
    public static void main(String[] args) {
        boolean b1 = false;
        boolean b2 = false;
        if(b1) {
            System.out.println("this b1 is true");
        } else if(b2) {
            System.out.println("this b2 is true");
        } else {
            System.out.println("b1 and b2 is false");
        }
    }
}

③switch case

package cn.td.jsd2303;

/**
 * switch(args) {
 *     case
 * }
 *
 * args类型只能是byte、int、short、char、String、Enum六种类型
 */
public class Test5 {
    public static void main(String[] args) {
        int i1 = 10;
        switch(i1) {
            case 1:
                System.out.println("output 1");
                break;//中断、中止
            case 2:
                System.out.println("output 2");
            case 10:
                System.out.println("output 10");
            case -1:
                System.out.println("output -1");
            default:
                System.out.println("output default");
        }
    }
}

package cn.td.jsd2303;

import java.util.Scanner;

/**
 * 练习：从控制台去接收值
 */
public class Test14 {
    public static void main(String[] args) {
        //接收一个int整数
        System.out.println("请输入一个整数：");
        Scanner scanner = new Scanner(System.in);
        int i1 = scanner.nextInt();//去接收int类型的值
        System.out.println(i1);

        //接收一个double类型的小数
        System.out.println("请输入一个小数：");
        Scanner scanner1 = new Scanner(System.in);
        double d1 = scanner1.nextDouble();//接收double类型的值
        System.out.println(d1);
    }
}

（2）循环
①for循环

package cn.td.jsd2303;

/**
 * for循环
 * 语法格式：
 * for(①; ②; ③){
 *
 * }
 * ①：变量的初始化
 * ②：条件判断表达式，是一个boolean值
 * ③：变量或者其他运算
 *
 * for(变量的初始化; 条件判断表达式; 变量或者其他运算) {
 *      //程序的执行代码
 *      System.out.println();
 * }
 */
public class Test15 {
    public static void main(String[] args) {
        for(int i = 1;i < 101;i++) {
            System.out.println(i);
        }
    }
}

②while循环

package cn.td.jsd2303;

/**
 * while循环
 * 语法格式：
 * while(boolean的值) {
 *     //需要执行的代码
 * }
 */
public class Test16 {
    public static void main(String[] args) {
        int i = 1;
        while(i < 101) {
            System.out.println(i);
            i++;
        }
    }
}

③do while循环

package cn.td.jsd2303;

/**
 * do while循环
 * 语法格式：
 * do {
 *     //需要执行的代码
 * } while(boolean的值);
 */
public class Test17 {
    public static void main(String[] args) {
        int i1 = 1;
        do {
            System.out.println(i1);//1
            i1++;//i1 = i1 + 1;
        } while(i1 < 101);
    }
}

for循环和while循环其实本质差不多，唯一的区别就在于变量定义位置等
dowhile相对特殊，至少会执行一次

使用场景：具体情况，具体分析

package cn.td.jsd2303;

/**
 * 例子1：
 * 找出1-100里面所有的奇数和偶数，并分别输出
 */
public class Test18 {
    public static void main(String[] args) {
        //1、循环：1-100
        //2、判断，如果是奇数，输出“奇数：” + 值，如果是偶数，输出“偶数” + 值
        //问题：如何判断是奇数，还是偶数？

        for(int i = 1;i < 101;i++) {
            if(i%2==0) {//能被2整除就是偶数
                System.out.println("偶数：" + i);
            } else { //不能被2整除就是奇数
                System.out.println("奇数：" + i);
            }
        }

        //第二种方式：do while
        int i = 1;
        do {
            if(i%2==0) {
                System.out.println("偶数：" + i);
            } else {
                System.out.println("奇数：" + i);
            }
            i++;
        } while(i < 101);
    }
}


package cn.td.jsd2303;

import java.util.Scanner;

/**
 * 例子：
 * 判断是闰年还是平年
 * 闰年：能被4整除，但是不能被100整除 或者 可以被400整除
 */
public class Test19 {
    public static void main(String[] args) {
        //从控制台接收一个年份
        Scanner scanner = new Scanner(System.in);
        int year = scanner.nextInt();
        if((year%4==0 && year%100!=0) || (year%400==0)) {
            System.out.println(year + "是闰年！");
        } else {
            System.out.println(year + "是平年！");
        }
    }
}


package cn.td.jsd2303;

/**
 * 打印九九乘法口诀表
 */
public class Test20 {
    public static void main(String[] args) {
        //使用for循环
        for(int i = 1;i < 10;i++) {//控制好行数
            for(int j = 1;j <= i;j++) {//控制每一行里面的个数
                System.out.print(j + "x" + i + "=" + (i*j) + " ");
                //print，不换行
                //println，换行
            }
            //换行
            System.out.println();
        }

        //使用do while循环
        int i = 1;
        do{//控制行数
            int j = 1;
            do{//控制每一行里的个数
                System.out.print(j+"x"+i+"="+(i*j) + " ");
                j++;
            }while(j <= i);
            System.out.println();//换行
            i++;
        } while(i < 10);
    }
}

4、数组
用于存放一堆数

（1）创建（声明）
①静态
②动态

package cn.td.jsd2303;

/**
 * 数组的创建
 */
public class Test21 {
    public static void main(String[] args) {
        //1、静态
        //语法格式：
        //数组的类型[] 数组的名字 = {值1,值2,值3,......};
        //或者 数组的类型[] 数组的名字 = new 数组的类型[]{值1,值2,值3,......};

        int[] intArray1 = {1,3,5,7,9};
        int[] intArray2 = new int[]{1,3,5,7,9};

        int x = 0;
        while(x < intArray1.length) {
            System.out.println("intArray["+x+"] = " + intArray1[x]);
            x++;
        }

        //2、动态
        //语法格式：
        //数组的类型[] 数组的名字 = new 数组的类型[值];
        byte[] byteArray1 = new byte[10];//值代表数组的元素个数（数组的长度），也代表能存放多少个值
        //赋值，因为数组有下标，一般是根据下标进行赋值，取值范围：0~数组的长度(数组名.length)-1
        System.out.println("赋值前：" + byteArray1[0]);
        byteArray1[0] = 1;
        System.out.println("赋值后：" + byteArray1[0]);

        //一次性赋值，利用循环
        for(int i = 0;i <= byteArray1.length-1;i++) {
            byteArray1[i] = (byte)(i+1);
        }
        //取出每个元素的值，根据下标，遍历数组
        for(int i = 0;i <= byteArray1.length-1;i++) {
            System.out.println("byteArray["+ i +"] =" + byteArray1[i]);
        }
    }
}


package cn.td.jsd2303;

/**
 * 找出数组里面的奇数和偶数，分别输出
 */
public class Test22 {
    public static void main(String[] args) {
        short[] shortArray1 = new short[20];

        //遍历数组
        int i = 0;
        do{
            System.out.println("shortArray["+i+"] = " + shortArray1[i]);
            i++;
        } while(i < shortArray1.length);

        System.out.println("赋值后：");

        i = 0;//重置i的值

        do{
            shortArray1[i] = (short)(i+1);
            i++;
        } while(i < shortArray1.length);

        i = 0;
        do{
            if(shortArray1[i]%2==0) {
                System.out.println("shortArray1["+i+"]" + "是偶数,value is" + shortArray1[i]);
            } else {
                System.out.println("shortArray1["+i+"]" + "是奇数,value is" + shortArray1[i]);
            }
            i++;
        } while(i < shortArray1.length);
    }
}


package cn.td.jsd2303;

import java.util.Arrays;
import java.util.Random;

/**
 * 数组的遍历-新
 */
public class Test23 {
    public static void main(String[] args) {
//        long[] longArray1 = new long[]{2,4,6,8,10};
        long[] longArray1 = {2,4,6,8,10};
        System.out.println(Arrays.toString(longArray1));

        //例子：随机往数组赋值，值是随机的
        int[] intArray1 = new int[6];
        int i1 = new Random().nextInt();
        System.out.println(i1);
        //往数组里赋随机值
        Random random = new Random();
        for(int i = 0;i < intArray1.length;i++) {
            intArray1[i] = random.nextInt();
        }
        System.out.println("赋值后的结果：");
        int j = 0;
        while(j < intArray1.length) {//用while循环遍历
            System.out.println("intArray1["+ j +"] = " + intArray1[j]);
            j++;
        }
    }
}

5、公共类和方法的使用

方法的定义

//模仿main方法去写的
public：修饰词，必须要有
static：静态
void：不能有返回值，必须要有
main1 方法的名字，必须要有
public static void main1() {
	
}

package cn.td.jsd2303;

import java.util.Random;

/**
 * 公共类和方法的使用
 * 关键字
 * （1）public    公共
 * （2）class     类
 * （3）static
 * （4）void
 *
 * .java
 * ---类
 * ------方法（方法1、方法2、方法3......）
 * ---------具体的代码（变量的定义、普通代码、方法的调用......）
 */
public class Test25 {
    //程序执行的唯一的入口
    public static void main(String[] args) {
        //方法的调用：方法名();         在方法里面才能调用定义过的方法
        main1();
    }

    //在main方法外，在类中定义一个新的方法，main1
    public static void main1() {
        double[] dArray1 = {3.0,2.0,1.5,4.0,4.2,4.4};

        //遍历
        for(int i = 0;i < dArray1.length;i++) {
            System.out.println("dArray1["+ i +"] = " + dArray1[i]);
        }

        //修改：赋一些随机值进去
        int j = 0;
        do{
            Random random = new Random();
            double dValue1 = random.nextDouble();//0.0~1.0
            dArray1[j] = dValue1;
            j++;
        } while(j < dArray1.length);

        System.out.println("修改赋值后的再次遍历：");
        //再次遍历
        j = 0;
        while(j < dArray1.length) {
            System.out.println("dArray1["+j+"] = " + dArray1[j]);
            j++;
        }
    }
}


package cn.td.jsd2303;

import java.util.Random;
import java.util.Scanner;

/**
 * 方法修饰词
 * public       公共                  整个项目或者模块都可以用
 * protected    受保护的                本包的类及它的子类可访问
 * default      默认的,缺省的           本包里的类可访问
 * private      私有的                 只能在本类中使用
 *
 * 从大到小排序：public > protected > default > private
 */
public class Test26 {
    public static void main(String[] args) {
//        Scanner scanner = new Scanner(System.in);
//        scanner.nextInt();//从控制台去接收数        public

//        Random random = new Random();
//        random.nextDouble();//生成一个随机小数      public
    }

    private void main100() {
//        Test26 test26 = new Test26();
//        test26.main1();

        main1();
    }

    //如果是private，那main1只能在Test26类里面访问，其他的类不允许访问
    protected void main1() {
        System.out.println("Test26-main1");
    }
}

``

```java
package cn.td.jsd2303;

import cn.td.jsd2303.Test26;

public class Test27 {
    public static void main(String[] args) {
        Test26 test26  = new Test26();
        test26.main1();
    }
}


package cn.td.jsd2303;

/**
 * void     不能有返回值
 *
 * 有返回值的方法的调用以及如何得到返回值
 */
public class Test28 {

    public static void main(String[] args) {
        //调用main1方法
        main1();

        //调用main2方法，得到返回值，格式：返回值的类型本身/比他大的类型 变量名 = 方法名();
        int returnValue = main2();
        System.out.println("returnValue: " + returnValue);
    }

    //定义main1方法
    public static void main1() {
        System.out.println("Test28-main1");
    }

    //定义方法main2
    public static int main2(){
        System.out.println("Test28-main2");
        //计算5+10，并将结果返回
        int a = 5;
        int b = 10;
        int c = 0;

        c = a + b;

        //返回值：return 值;     return也是一个关键字
        return c;
    }
}

package cn.td.jsd2303;

import java.util.Arrays;

/**
 * 方法的参数：形参（形式参数）和实参（实际参数）
 *
 * (String[] args)
 * args，形式参数
 *
 */
public class Test29 {
    public static void main(String[] args) {
        int[] iArr1 = {1,3,5,7,9};//iArr1就是一个实际参数
        main2(iArr1);
    }

    public static void main1() {
        String[] args = {};//数组
        int[] iArr1 = {};//数组
    }

    public static void main2(int[] intArr1) { //intArr1就是一个形式参数
        //利用新的数组遍历方式，打印输出数组
        System.out.println(Arrays.toString(intArr1));
    }
}


package cn.td.jsd2303;

import java.util.Arrays;

/**
 * 方法的参数
 * 形式参数和实际参数可以有多个，形参和实参名字可以不一样，但类型必须要对应
 */
public class Test30 {
    public static void main(String[] args){
        byte x = 5;
        double y = 20.0;
        //调用main1
        int d = main1(x,y);
        System.out.println(d);

        //调用main2
        int[] intArr1 = {1,3,5,7,9};
        int[] i2 = main2(intArr1);
        System.out.println(Arrays.toString(i2));
    }

    public static int main1(byte a,double b) {
        //将传过来的形式参数，进行加法运算，并返回，输出
        int c = 0;
        c = (int)(a + b);
        return c;
    }

    public static int[] main2(int[] i1) {
        i1[0] = 2;
        i1[1] = 4;
        i1[2] = 6;
        i1[3] = 8;
        i1[4] = 10;
        return i1;
    }
}


package cn.td.jsd2303;

/**
 *  static 静态
 *  静态的东西（方法）里面只能调用静态的东西，不能调用非静态的东西
 *  非静态的东西（方法）可以调用静态的东西，也可以调用非静态的东西
 */
public class Test31 {
    //程序执行的入口
   public static void main(String[] args) {

   }

   public void main2() {//非静态
       String[] m1 = {"1","2","3"};
        main(m1);//静态

        main1();//非静态
   }

   public void main1() {
       System.out.println("Test31 - main1");
   }
}


package cn.td.jsd2303;

/**
 * static
 */
public class Test32 {

    //类变量（全局变量）：在类中，在方法外，全局（本类中）都可访问
    static int i1 = 10;//属于类变量
    int i2 = 20;//属于类变量

    public static void main(String[] args) {
        //方法变量（局部变量）：在方法里，方法内都可访问，方法外不能访问
        int i3 = 50;

        System.out.println(i1);
//        System.out.println(i2);//编译报错，原因：静态里面不能调用非静态的东西
        System.out.println(i3);
//        System.out.println(i4);//编译报错，原因：i4是属于main2方法的变量，只能在main2方法内访问
    }

    public void main2() {
        int i4 = 100;

        System.out.println(i1);
        System.out.println(i2);
//        System.out.println(i3);//编译报错，原因：i3属于main方法的变量，只能在main方法内访问
        System.out.println(i4);
    }
}


package cn.td.jsd2303;

/**
 * 类中东西执行加载顺序
 * 类
 * ---变量（类变量和方法变量）、方法
 *
 * 代码块
 * （1）非静态
 *  {
 *      //代码
 *  }
 * （2）静态
 *  static {
 *      //代码
 *  }
 *
 *  代码块相对于方法而言，是优先执行的
 *  执行（加载）顺序：静态类变量  > 静态代码块  > 静态方法
 *  静态的东西总是优先执行的
 */
public class Test33 {
    //静态
    static {
        short age = 28;
        int kg = 75;
        System.out.println("static：" + age + ":" + kg);
    }

    static short age1 = 0;
    static short kg1 = 0;

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


package cn.td.jsd2303;

/**
 * 面向对象：是一种思想
 */
public class Student1 { //学生类
    //人的特征：姓名，年龄，性别，身高，体重.....
    char name = 'a';
    int age = 28;
    char gender = '男';
    int height = 170;
    int kg = 75;

    public static void main(String[] args) {
        //创建a的学生对象
        //语法格式：对象的类型 对象的名字 = new 对象的类型();
        Student1 a = new Student1();

        //打印a对象
        //引用类型：除了八大基本数据类型以外，都称之为引用类型
        System.out.println(a);//cn.td.jsd2303.Student1@1b6d3586 因为a对象属于引用类型，所以打印出来的a对象是一个地址值
        //地址值：包名+类名@16进制数
        System.out.println(a.toString());
    }

    //alt + insert
    @Override
    public String toString() {
        return "Student1{" +
                "name=" + name +
                ", age=" + age +
                ", gender=" + gender +
                ", height=" + height +
                ", kg=" + kg +
                '}';
    }
}


package cn.td.jsd2303;

/**
 * 面向对象
 * 三大特征
 * （1）封装    关键字：private 私有的
 *  封装：一般封装的是属性（特征）或者是方法
 *  好处：提高程序的安全性
 *
 * （2）继承    关键字：extends 继承
 *  好处：子类不需要再定义的重复的东西，可以直接从父类去继承过来，无需定义
 *  但是继承的东西必须是非private
 *
 * （3）多态
 */
public class Student2 extends Student2Father {//Student2是Student2Father的一个子类
    //类变量
    static char name = 'w';//姓名
    static int age = 28;//年龄

    public static void main(String[] args) {
        System.out.println("name: " + name);
        System.out.println("age: " + age);

        System.out.println("money: " + money);
        System.out.println("like: " + like);
    }
}


package cn.td.jsd2303;

/**
 * Student2的父类
 */
public class Student2Father {
    private static char name = 'y';//姓名
    private static int age = 55;//年龄
    static char like = 'p';//爱好
    static double money = 200000000.0;//存款
}

练习：

从控制台接收成绩(score)，判断
如果score>=90，输出优秀
如果score>=80 <90， 输出良
如果score>=70 <80，输出一般
如果score<70，输出差
热爱111
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java通过Comparator比较器对集合进行多属性连续分组内升降排序，以及null空值排最前或最后
hkl_Forever的博客
04-26 153
一、排序数据准备，分别对 one、two、three 三个属性进行连续分组内排序。连续排序，并且把被排序属性值为null的排在最后。连续排序，并且把被排序属性值为null的排在最后。
深入理解Java虚拟机（读书笔记）
汪子涵的博客
06-06 928
JRE是支持Java程序运行的标准环境，包括：Java类库API中的Java SE API子集和Java虚拟机。JDK是支持Java程序开发的最小环境，包括：Java程序设计语言、Java虚拟机、Java类库。Java程序设计语言、Java虚拟机、Class文件格式、Java类库API、Java三方框架。动态语言支持：Java是静态语言，为其他运行在Java虚拟机上的动态语言提供支持。Lambda项目：支持Lambda表达式，支持函数式编程。Garbage-First收集器。
尚学堂JAVA基础学习笔记_1/2
李英俊小朋友
11-29 1718
尚学堂JAVA基础学习笔记_1/2 文章目录尚学堂JAVA基础学习笔记_1/2写在前面第1章 JAVA入门第2章 数据类型和运算符第3章 控制语句第4章 Java面向对象基础1. 面向对象基础2. 面向对象的内存分析3. 构造方法4. 垃圾回收机制(Garbage Collection)5. this关键字6. static 关键字7. 静态初始化块8. 参数传值机制9. 包第5章 Java面向对...
Java基础+进阶
vincewm的博客
04-14 7691
本文适合Java入门和复习回顾。内容覆盖JDK下载和hello world、IDEA下载安装配置、类、基本数据类型、方法、修饰符、关键字、面向对象、继承、多态、接口、异常、集合、i/o流、多线程、网络编程、Lambda表达式、接口组成更新、方法引用、函数式接口、 Stream流、 反射、模块化、XML
Java词汇
weixin_43366437的博客
04-22 458
1、JDK abbr. Java 开发工具包（Java Development Kit） 2、JRE abbr. Java 运行环境（Java Runtime Environment） 3、JVM abbr. Java 虚拟机（Java Virtual Machine） 4、System n. 制度，系统； 5、out adj. 外面的；出去 6、println n. 换行打印 7、main，n. 主方法 8、download， vt. [计] 下载 9、path， n. 道路；小路；轨道；路径 10、J
flink-train-java
03-06
mvn原型：generate -B -DarchetypeGroupId = org.apache.flink -DarchetypeArtifactId = flink-quickstart-java -DarchetypeVersion = 1.10.2 -DgroupId = com.dinglicom -DartifactId = flink-train- java -...
java_type_train.rar_java 多线程_java 打字 程序_train_线程
09-23
java的打字程序，包含了多线程编写的练习和Applet的编程练习。
JavaChat:Java Trainin'程序
05-26
JavaChat 时间：2019-04-07标签：trainindfsdfjavatrainin
Com_Java_train_5_days.rar_QG8kaifaban.r_train
09-24
某公司Java培训5天讲义,在网上找的,在这也和大家分离一下
train_python_train_
09-30
github上ExtermNet的train.py文件
mybatisPlus使用MetaObjectHandler对字段进行更新
m0_56356631的博客
04-23 335
都是符合我们的预期的。
string模拟实现
m0_73969414的博客
04-23 1441
c++中string的模拟实现，面试必会知识点
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 603
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
javaweb-SpringBoot基础
kussm_的博客
04-20 1340
Spring的官网(Spring的简介：Spring makes Java simple。Spring Boot 可以帮助我们非常快速的构建应用程序、简化开发、提高效率。创建一个子包controller。
第5 章 Consul服务注册与发现
a13763926743的博客
04-22 758
consul官网地址。
迭代器模式
LuckFairyLuckBaby的博客
04-23 520
迭代器模式(Iterator),提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。
Java | 冒泡排序算法实现
yingzix688的博客
04-24 718
题目描述 编写一个Java程序，实现冒泡排序算法。程序需要能够接收一个整型数组作为输入，并输出排序后的数组。 冒泡排序是一种简单的排序算法，它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
@Value
最新发布
思索的涟漪，突破自我
04-26 185
Value注解是 Spring 框架中的一个注解，用于从属性文件、环境变量、Java 系统属性等地方读取值，并将这些值注入到 Spring 管理的 Bean 中。
split train
09-08
train_test_split方法是机器学习中常用的一个方法，用于将原始数据按照比例划分为训练集和测试集。...<span class="em">1</span><span class="em">2</span><span class="em">3</span><span class="em">4</span>

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值