Java基础(2)-运算符、流程控制、数组、类基本操作

写于2019.5.10

参考：www.java1234.com

运算符

(1) 算术运算(*,/,%,+,-)

(2) 逻辑运算符(!,&&,||)

(3) 自增运算符(++,--)

(4) 三目运算符( : ? )

public class JavaBase {
    public  static void main(String[] args)
    {
        // 自动类型转换
        short s = 1;
        int i = s;
        System.out.println("i="+i);

        // 强制类型转换
        double d = 1.0;
        float f = (float)d;
        System.out.println("f="+f);

        // +运算符
        int a = 10;
        int b = 3;
        System.out.println(a+"+"+b+"="+a+b); // 字符串连接 优先级高于 +
        System.out.println(a+"+"+b+"="+(a+b));

        // -运算符
        System.out.println(a+"-"+b+"="+(a-b));

        // *运算符
        System.out.println(a+"*"+b+"="+(a*b));

        // /运算符
        System.out.println(a+"/"+b+"="+(a/b));

        // /运算符
        System.out.println(a+"%"+b+"="+(a%b));

        // ++运算符
        int a1 = 1;
        System.out.println("a1++ = "+(a1++)+","+(a1++));
        System.out.println("a1="+a1);

        int b1 = 1;
        System.out.println("++b1 = "+(++b1)+","+(b1++));
        System.out.println("b1="+b1);

        int c1 = 1;
        c1 = (c1++)+(++c1);
        System.out.println("c1="+c1);

        // 逻辑运算符 && || !
        int aa1 = 1;
        boolean bb1 = (aa1++ ==1) && (aa1==2); // 本(aa1++)用aa1原值1替代，下一个(aa1++)中aa1为2
        System.out.println("bb1="+bb1);

        // 三目运算符
        int x = 2;
        int y = 3;
        int z = 4;
        int m = 0;
        int minInThree = x<m?x:(m=y<z?y:z);
        System.out.println("min in three is "+minInThree);
    }

流程控制

(1) switch case

import java.util.Scanner;

public class Demo14 {
    public static void main(String[] args)
    {
        System.out.println("请输入一个人名：");
        Scanner scanner = new Scanner(System.in);
        String str = scanner.next();
        scanner.close();

        switch (str) {
            case "张三":{
                System.out.println("输入的是张三");
                break;
            }
            case "李四":{
                System.out.println("输入的是李四");
                break;
            }
            default:{
                System.out.println("输入的是其它");
            }
        }
    }
}

(2) while, do while, for

public class Demo15 {
    /**
     * 在控制台输出1到10
     * @param args
     */
    public static void main(String[] args)
    {
        // while循环
        System.out.println("====================");
        int i=1;
        while(i<=10)
        {
            System.out.println("i="+i);
            i++;
        }

        // do while循环
        System.out.println("====================");
        int j=1;
        do{
            System.out.println("j="+j);
            j++;
        }while(j<=10);

        // for循环
        System.out.println("====================");
        for(int k=1; k<=10; k++)
        {
            System.out.println("k="+k);
        }

        // 水仙花数
        System.out.println("====================");
        for(int x=100; x<=999; x++)
        {
            int a = x/100;
            int b = x/10%10;
            int c = x%10;
            if(a*a*a+b*b*b+c*c*c==x)
                System.out.println("x="+x);
        }

        // 打印九九乘法表
        System.out.println("====================");
        for(int a=1; a<=9; a++)
        {
            for(int b=1; b<=a; b++) {
                System.out.print(b+"*"+a+"="+a*b+"\t");
            }
            System.out.println();
        }

        // 1!+2!+...+10!
        System.out.println("====================");
        int sum = 0;
        int factor = 1;
        for(int ii=1; ii<=10; ii++)
        {
            factor *= ii;
            sum += factor;
        }
        System.out.println("sum="+sum);
    }
}

(3) break, continue, return

数组

(1) 定义数组

• int[] arr (推荐)
• int arr[]

(2) 初始化数组

• 静态初始化

int arr[] = new int[]{1,2,3};

• 动态初始化

arr3[0] = 1;
arr3[2] = 6;

/* 数组操作 */
public class Demo18 {
    public static void main(String[] args) {
        /*// 定义int类型数组
        int[] arr;

        // 另外一种方式
        int arr2[];

        // 静态初始化*/

        // 定义一个数组，并且静态初始化
        int arr[] = new int[]{1,2,3};

        // 普通的遍历方式
        System.out.println("===============");
        for(int i=0; i<arr.length; i++){
            System.out.println(arr[i]);
        }

        // foreach方式
        System.out.println("===============");
        for(int j: arr) {
            System.out.println(j);
        }

        // 动态初始化
        int[] arr3 = new int[3];
        System.out.println("===============");
        for(int k: arr3) {
            System.out.println(k);
        }
        // 给数组元素赋值
        arr3[0] = 1;
        arr3[2] = 6;
        System.out.println("===============");
        for(int k: arr3) {
            System.out.println(k);
        }
    }
}

(3) 二维数组

/* 二维数组操作 */
public class Demo19 {
    public static void main(String[] args) {

        // 静态初始化
        /*int[][] arr = new int[][]{{1,2,3},{4,5,6},{7,8,9,10}};

        for(int i=0; i<arr.length; i++) {
            for(int j=0; j<arr[i].length; j++) {
                System.out.print(arr[i][j]+" ");
            }
            System.out.println();
        }*/

        // 动态初始化
        /*int[][] arr = new int[3][3];
        arr[1][2] = 1;
        for(int i=0; i<arr.length; i++) {
            for(int j=0; j<arr[i].length; j++) {
                System.out.print(arr[i][j]+" ");
            }
            System.out.println();
        }*/

        // 冒泡排序

        int[] arr = {4,21,0,-12,-3};
        for(int i=0; i<arr.length-1; i++) {
            for(int j=0; j<arr.length-1-i; j++) {
                if(arr[j]>arr[j+1]) {
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }

        for(int x: arr) {
            System.out.println(x);
        }

    }
}

类的基本操作

(1) 面向对象：基于对象的思维去分析和解决问题

• 三大特性：封装、继承、多态

(2) 定义类

• 类的内存分析

  • 栈区：存放指向person对象内容的地址，类似如遥控器
  • 堆区：类属性的内容，类似如电视机实体

/**
 * Person类 文件名和类名必须一致
 *
 */
public class Person {
    String name; // 在类中，定义一个名字属性
    int age;

    /**
     * 定义一个方法
     */
    public void speak(){
        System.out.println("我叫"+name+"，我今年"+age+"岁了");
    }

    /**
     * main入口
     * @param args
     */
    public static void main(String[] args) {
        // 定义一个Person类的对象
        Person person;

        // 实例化对象
        person = new Person();
        person.name = "张三";
        person.age = 1;
        person.speak();
    }
}

(3) 方法

• 不固定参数： String... hobbies
• 值传递：形参为基本数据类型
• 引用传递：形参为对象

class Sanwei{
    int b;
    int h;
    int w;
}
public class Person {
    /**
     *
     * @param name
     * @param age
     * @param hobbies
     * @return 返回爱好的个数
     */
    /*public int speak(String name,int age, String ...hobbies){
        System.out.println("我是"+name+"，我今年"+age);
        for(String hobby: hobbies){
            System.out.println(hobby+" ");
        }
        int totalHobbies = hobbies.length;
        return totalHobbies;
    }*/

    public void speak(int age, Sanwei sanWei){
        System.out.println("我今年"+age+"岁");
        age = 24;
        System.out.println("方法里age="+age);
        sanWei.w = 80;
        System.out.println("方法里胸围"+sanWei.w);
    }
    public static void main(String[] args) {
        Person zhangsan = new Person();
        int age = 23;
        Sanwei sanWei = new Sanwei();
        sanWei.w = 90;
        zhangsan.speak(age,sanWei);
        System.out.println(age);
        System.out.println("调用函数中胸围"+sanWei.w);
    }
}

(4) 方法重载

• 可以重载：具有不同参数的同名方法
• 不能重载：参数完全一致，返回值不同的同名方法，会编译出错

public class Demo01 {
    int add(int a, int b){
        System.out.println("方法1");
        return a+b;
    }

    int add(int a, int b, int c){
        System.out.println("方法2");
        return a+b+c;
    }

    int add(int a, String b){
        System.out.println("方法3");
        return a+Integer.parseInt(b);
    }

    // 参数类型
    /*long add(int a, int b){
        System.out.println("方法1");
        return a+b;
    }*/

    public static void main(String[] args) {
        Demo01 demo01 = new Demo01();
        System.out.println(demo01.add(1,2));
        System.out.println(demo01.add(1,2,3));
        System.out.println(demo01.add(1,"3"));
    }
}

(5) 静态方法 vs 普通方法

• static 修饰的方法为静态方法

public class Demo02 {
    void fun1(){
        System.out.println("这是一个普通方法");
    }

    static void fun2(){
        System.out.println("这是一个静态方法");
    }

    public static void main(String[] args) {
        Demo02 demo02 = new Demo02();

        // 调用普通方法
        demo02.fun1();

        // 调用静态方法
        Demo02.fun2();
        demo02.fun2();
    }
}

(5) 递归：方法调用自身

/**
 * 计算阶乘
 */
public class Demo03 {
    /**
     * 循环实现
     * @param n
     * @return
     */
    static long factor01(int n){
        long result = 1;
        for(int i=1;i<=n;i++){
            result *= i;
        }
        return result;
    }

    /**
     * 递归实现
     * @param n
     * @return
     */
    static long factor02(int n){
        if(n==1)
            return 1;
        else
            return n*factor02(n-1);
    }

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

**
 * 斐波那契数列
 */
public class Fabonacci {
    /**
     * 循环实现
     * @param n
     * @return
     */
    static long fabonacci01(int n){
        long prev = 0;
        long cur = 1;
        for(int i=1; i<n; i++){
            long temp = prev;
            prev = cur;
            cur += temp;
        }
        return  cur;
    }

    static long fabonacci02(int n){
        if(n==1 || n==2)
            return 1;
        else
            return fabonacci02(n-1)+fabonacci02(n-2);
    }

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

(6) 构造方法和this

• 构造方法
  • 执行对象实例化的初始化操作
  • 一种特殊的方法：没有返回值；方法名和类名相同
    
  • 无构造方法时，系统自动生成默认的无参数构造方法
  • 有构造方法时，系统不会自动生成构造方法
• this
  • 访问本类中的属性：this.name
  • 调用本类的构造方法：this()

  public class Person {
    private String name; // 实例化对象时，默认值是null
    private int age;    // 实例化对象时，默认值是0
  
    Person(){
        System.out.println("默认构造方法");
    }
  
    Person(String name, int age){
        this(); // 调用无参数的构造方法
        System.out.println("调用的是有参数构造方法");
        name = name; // name指的是形参name，没有操作同名的对象属性name
        this.age = age;
    }
  
    Person(String name, int age, String haha){
        this(name, age); // 调用无参数的构造方法
        System.out.println("调用的是有参数构造方法"+haha);
    }
  
    public void say(){
        System.out.println("我叫"+name+"，我今年"+age+"岁了");
    }
    public static void main(String[] args) {
  //        Person zhangsan = new Person();
        Person zhangsan = new Person("张三",20, "haha");
        zhangsan.say();
    }
  }

Java基础(2)-运算符、流程控制、数组、类基本操作

原文：https://www.cnblogs.com/vincent-zhu/p/10847436.html