我在乐字节学习的第四天（Java）

今天是我在乐字节学习Java的第四天，这四天学习Java收获了很多，以前不懂的一些问题经过着四天学习下来大概也能理解它的一些意思，下面是我今天学习的内容，大家可以康康哦，如果有不对的地方欢迎指出哦 ，大家互相学习改进。

1**.switch的语句中的控制表达式必须是char，int，short或byte类型的，还有枚举类型（在jdk1.7时，可以为字符串类型），没有double，float类型，与之前说过的，float类型属性具有离散性，接近某个值但不相等，有不确定性。无论哪个版本的JDK，都是不支持 long，float，double，boolean 这个一定要注意！原因是由于char，int，short或byte可以隐式的转换为int类型。
2.在之前说过，string类型参与计算，会输出的结果也为字符串类型，比如在输出时，添加" "字符串，会导致结果也为字符串类型，在这里，当运算有int型和double型一同参与运算时，结果为double。例如：

public class Example1 {
    public static void main(String[] args) {
        int x=5;
        System.out.println("使用比较运算符——→(x>4)?99.99:9得出的结果是："+((x>4)?99.99:9));
    }
}
结果为：
使用比较运算符——→(x>4)?99.99:9得出的结果是：99.99
12345678

3.switch语句中的default的使用（笔试会遇到）：default语句的使用是在，当没有找到匹配的对象时，就会执行default的分支，这个时候，会注意default分支的位置，可以在前，可以在后，但是也会遇到break才会停下，一般情形况下，是在最后面。
4.常用运算符的优先级：
优先级逐渐变低
（）
++，–，！，~（非运算）
*，/，%
+，-
<<,>>(左移右移运算符)
<,>,<=,>=
==, !=
&（位运算）
^（位运算）
|（位运算）
&&,&(逻辑与)
||，|（逻辑或）
？：
=，+= …
5.看一个例题：

public class Example2 {
    public static void main(String[] args) {
        int total=0;
        for (int i=0,j=10;total>30;++i,j--){
            System.out.println("i的值"+i+";"+"j的值"+j);
            total=i+j;
        }
        System.out.println("total:"+total);
    }
}
结果为：
total:0

大家需要去看题，在for循环中，第二个条件语句是满足条件，对于这个例题而言，也就是说，tatal需要<10，这样才会去执行for循环的语句。（哈哈哈哈哈）
1234567891011121314

6.hashCode：暂时可以理解为每一个对象都有一个hashcode，是通过特定的算法生成的，当对象进行比较时，是通过hash值来比较。
7.从键盘输入三个数，按照从小到大的顺序输出。

public class Example3 {
    public static void main(String[] args) {
        //获取三个值，分别赋予x，y，z
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入第一个整数值：");
        int x=scanner.nextInt();
        System.out.println("请输入第二个整数值：");
        int y=scanner.nextInt();
        System.out.println("请输入第三个整数值：");
        int z=scanner.nextInt();
        //提醒，结果是从小到大输出，按照x，y，z输出，也就是说，x，y，z的值被改变
        int temp=0;//在交换数据用到

        //按照x，y，z输出
        //首先第一步，比较x与y的大小，如下情况，此时x大于y，也就意味着需要交换数据，使得x是最小值
        if(x>y){
            temp=x;
            x=y;
            y=temp;
        }
        //注意，此时在x与y之间，x已经是最小的，而y是两者间最大的

        //按照x，y，z输出
        //如果说，x与z比较，x此时比z大，那么意味着需要交换数据，使得x是最小值（按照x，y，z输出）
        if (x>z){
            temp=x;
            x=z;
            z=temp;
        }
        //如果x小于z的值，那么就需要比较y与z的值，毕竟此时，x最小，y最大
        if (y>z){
            temp=y;
            y=z;
            z=temp;
        }
        System.out.println(x+"<"+y+"<"+z);
        scanner.close();
    }
}
结果为：
请输入第一个整数值：
4
请输入第二个整数值：
9
请输入第三个整数值：
3
3<4<9
分析一下：有些语句直接省略，你慢慢想
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748

8.输出九九乘法表

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

        for (int i=1;i<10;i++){
            int sub=0;
            for (int j=1;j<=i;j++){
                sub=i*j;
                System.out.print(j+"*"+i+"="+sub+"\t");
            }
            System.out.println();
        }
    }
}
结果为：
1*1=1	
1*2=2	2*2=4	
1*3=3	2*3=6	3*3=9	
1*4=4	2*4=8	3*4=12	4*4=16	
1*5=5	2*5=10	3*5=15	4*5=20	5*5=25	
1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36	
1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49	
1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64	
1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81	
1234567891011121314151617181920212223

分析一下：

• 第一个循环，1~9，第二个循环是从1到i之间，为了避免重复，如果是第二个按照1到9的话，当i=2时，也需要重复输出21，与12重复。
• 转义字符"\t"，表示的是一个tab之间的距离，如果没有的话，12=2 22=4，之间将会贴在一起，不美观。
• System.out.print(j+"*"+i+"="+sub+"\t");注意，此时的输出语句，是print，不是println。System.out.println();→而且为了到达效果，需要换行。

温馨提示：第一次学习的小伙伴估计是不想看定义，但是我建议先看定义，我会在下面附上代码，以供记忆。
1.类：Java程序是由若干个类组成的，类是Java语言的核心。Java中类的定义分为两部分：类声明和类主体。（以下部分暂时了解）

• 类声明：【修饰符】class <类名> 【extends<父类>】【implements<接口名>】
• 【修饰符】：用来定义类的性质（abstract，final）和访问权限（public，默认）
• 【extends<父类>】：用来在Java中继承用的。最多只能继承一个父类
• 【implements<接口名>】：用来说明该类的实现接口，允许一个类实现多个接口，用逗号隔开
  自己总结一下：如果使用IDEA编写代码，每次都会创建一个类，此时就会发现是public修饰的，注意类的修饰是2种，有些人不分成员变量的修饰符。类主体：就是一些方法，变量的声明，实现。
  2.成员变量：【变量修饰符】<变量类型><变量名>
• 变量类型：可以是Java语言中任意的基本数据类型或引用数据类型（类，数组等），举个例子：int i=0；或者是：private User user；
• 变量名：类中的变量名必须唯一，但是在不同类中的可以出现同名的变量名称（不建议，尤其是到了后边开发项目的时候）
• 变量修饰符：Java语言提供public，protected，private和默认等4种访问权限。其中public修饰的成员变量作用域最广，允许被任何程序包种的类访问；protected修饰的成员变量允许被本类自身，子类及相同包的类访问（包的概念：在以后去写项目的时候大量出现，会将功能相同的一些类放在一个包下面，对于编程软件来说，就是一个文件夹，比如：音乐文件夹→会存放网易云，qq音乐，影视文件夹→会存放爱奇艺，腾讯视频，优酷等。其实，对于我们程序员而言就是包就是分类，比较方便）；private修饰的成员变量只能被本类访问，如果成员变量之前没有显示声明访问权限，则该变量为默认访问权限（也叫做包权限），允许类自身和同一个包内的类访问。（下图，笔试经常遇到）
  
  类成员变量还可以被final，static等关键词修饰，这些修饰符的作用后面了解。

3.成员方法：【方法修饰符】<方法返回值类型><方法名>【<参数列表>】{方法体
}

• 方法修饰符：主要有：public ，private，protected ，final，static ，abstract ，synchronized。其中前三种说明成员方法的访问权限，public，可以被所有类访问；protected允许被相同包的类访问；private只能被本类访问。final用于修饰最终方法，被final修饰的成员方法不允许被子类重载。static用于修饰类方法，与类变量相似，类方法不需要通过创建对象来使用，可以直接通过类访问，类方法也不允许重载。
  可以看到，add（）方法在main方法中直接调用
  abstract用于修饰抽象方法，该方法只有声明式，没有方法体（在接口会使用到，学到了接口再说），synchronized修饰符用于线程同步（在线程会使用到，学到了线程再说）。
• 方法返回值类型：首先返回值的类型可以是Java语言的任何数据类型，包括自定义类（User ，学到项目的时候，会经常返回自定义类，不慌）。如果一个类不需要返回值，则其返回值的类型被说明为void，如果有返回值，那么使用return语句返回，并且return语句中返回值的数据类型必须与成员方法的**<方法返回值类型>**（成员方法的组成的一部分）相同。
• 方法名：建议使用合适的英语单词，但必须符合标识符的构成规则。
• 参数列表：成员方法的参数列表由逗号分隔开，参数组成→类型，参数名，类型可以是Java语言任何数据类型。
• 方法体：定义局部变量，他的作用域仅仅在方法体内。
  4.构造方法：构造方法用于生成一个对象实例，并对对象实例中的成员变量初始化个人的理解，当创建好一个类以后，调用方法，第一步先创建一个对象，（假设有一个Car类 Car car1=new Car（） ），此时，构造方法就会立即执行。【以下重要的点】
• 构造方法的名字必须与类名相同
• 构造方法没有返回值类型，没有void，只有修饰符（只有这三个：public ，private，protected）的任意一个
• 系统默认提供无参构造方法。
• 构造方法不能从父类继承
• 构造方法可以重载，一个类可以有多个构造方法（形参的类型，个数不同），一旦重载了构造方法，系统就不会提供无参构造方法（比如在SSM项目开发中，重载了构造方法，还得提供无参的故暂方法）【关于重载，以后会在记录的】
• 在构造方法中可以调用当前类和其父类的另一个构造方法，但必须是方法体的第一条语句。使用当前类的构造方法用this来引用，是其父类的构造方法用super来引用。

结合上述内容，有如下代码：

//这里就是包名，package开头，是自己创建的，实则就是一个文件夹
package JavaTest2;
//使用IDEA（或Eclipse）会自动创建一个类（public或者是默认的）
public class StudyMethod {
//类的主体，在这里声明一些变量，方法

//首先是声明变量
public int i=0; //允许被任何程序中的类访问
private String userName;//只允许被本类访问
protected String userAge;//只允许被类自身，子类，相同包的类访问

//这里声明方法
/*第一行可以看到，方法返回值类型是int型，所以必须有return，而且return返回的值必须是int型，这里是int c。
 *第一行还可以看到方法名add，参数，包括了类型，int，参数名a，b
 */
public int add(int a,int b){
    int c=a+b;
    System.out.println(c);
    return c;
}

//static修饰方法，无需创建对象，可以直接在使用
public static void outData(){
    System.out.println("static修饰outData()，可以直接在使用");
}


//这里声明构造方法
//只能使用public，private，protected来修饰，方法名必须与类名相同类名也是StudyMethod
public StudyMethod(){
    //这里是一个无参构造方法，系统也会默认，但一般要写一个
    System.out.println("当new一个对象时，就开始调用构造方法了");
    System.out.println("此时创建对象时，参数中没有参数，所以调用该构造函数");
}

//可以有多个构造方法，但需要进行重载,进行重载就是参数类型，以及个数不一样
//关于构造方法的调用，会涉及到创建对象时，比如：本类有两个构造函数，如果在创建对象时，会出现不同的参数，会导致不一样的结果
public StudyMethod(int sum){
    System.out.println("当new一个对象时，就开始调用构造方法了");
    System.out.println("此时创建对象时，参数中含有一个int型参数，所以调用该构造函数");
    System.out.println(sum);
}

public static void main(String[] args) {
    //当我运行该方法时，会先创建两个对象studyMethod1，studyMethod2，此时会调用构造方法
    StudyMethod studyMethod1=new StudyMethod();//注意，此时没有参数，对比输出结果
    StudyMethod studyMethod2=new StudyMethod(1);
    //static修饰的方法
    outData();
    //普通的方法，没有static修饰的方法，需要对象来调用
    studyMethod1.add(2,3);
}

}
结果是：

当new一个对象时，就开始调用构造方法了
此时创建对象时，参数中没有参数，所以调用该构造函数
当new一个对象时，就开始调用构造方法了
此时创建对象时，参数中含有一个int型参数，所以调用该构造函数
1
static修饰outData()，可以直接在使用
5