Java基础知识点整理（二）

数组求和

案例代码

package day04;

public class ArrayTest {
    
    /**
     * 对整数数组进行求和
     * @param x 表示整数数组
     * @return
     */
    static int sum(int[] x) {
        int z=0;
        for(int e:x) {
            z+=e;
        }
        return z;
    }

    public static void main(String[] args) {
        //System.out.println(args);
        int[] arr = {1,2,3};
        //System.out.println(arr);
        System.out.println(sum(arr));
    }

}

分析
调用sum函数的时候，发生参数的传递，数列（也称数组对象）在堆里面的内存地址0x6d06d69c传递给了x, 这样的话，x也指向了该数列，变量名x可以理解为arr数组的别名。

image.png

常量

常量是特殊的变量，常量里面保存的内容不能被改变。

package day03;

public class FinalTest {
    static final byte HOURS_OF_DAY=24;//1天有24个小时
    static final short MONTHS_OF_YEAR=12;//1年有12个月
    static final int PLAYERS_OF_FOOTBALLTEAM=11;//1支足球队上场比赛的人数
    static final long SPEED_OF_LIGHT=300000;//光速30w公里每秒
    static final boolean TAIWAN_BELONG_TO_CHINA=true;//台湾属于中国
    static final char FLAG_OF_RMB='￥';//人民币符号
    static final double TAX_THRESHHOLD=5000.0;//个税起征点
    
    public static void main(String[] args) {
        System.out.println("光速为每秒钟："+SPEED_OF_LIGHT/10000+"万公里");
    }
}

new关键字

new是新建的意思，new操作会在堆里面开辟空间。

案例代码

package day06;

class StudentTest {

    public static void main(String[] args) {
//      int x = 1;
        Student[] students = new Student[30];//开辟30个Student类型的空间
        students[0] = new Student();//实例化
        students[0].sno = 1001;
        students[0].sname = "张三";
        students[0].isMale = true;
        students[1] = new Student();
        students[1].sno = 1002;
        students[1].sname = "李四";
        students[1].isMale = true;      
        System.out.println(students[0]);
        System.out.println(students[1]);
        System.out.println(students[2]);//null
        System.out.println(students);
//      Student scx = new Student();//scx表示一个学生对象
//      System.out.println(scx);
//      System.out.println(scx.sno+","+scx.sname+","+scx.isMale);
//      scx.sno = 1001;
//      scx.sname = "宋超鑫";
//      scx.isMale = true;
//      System.out.println(scx.sno+","+scx.sname+","+scx.isMale);       
//      System.out.println(scx);
    }
}

image.png

this关键字

this变量引用当前对象，比如：this.age就表示当前对象的年龄
1）this可以调用属性（成员变量）
2）this可以调用功能（成员方法）

篮球运动员类Player

package day07;

public class Player {
    private String name;
    private int age;//成员变量
    private boolean isMale;//成员变量
    private String position;
    private int score;
    private int no=10;          //球衣号码，默认10
    private int rate;           //1~100之间
    
    
    /**
     * 
     * @param name  接收姓名
     * @param age       接收年龄
     * @param isMale    接收性别
     * @param position  接收场上位置
     * @param score 接收场上得分
     * @param no        接收球衣号码
     * @param rate      接收命中率
     */
    public Player(String name, int age, boolean isMale, String position, int score, int no, int rate) {
        super();
        this.name = name;
        this.age = age;
        this.isMale = isMale;
        this.position = position;
        this.score = score;
        this.no = no;
        this.rate = rate;
    }
    

    public Player() {
        super();
    }


    /**
     * 获取年龄的接口
     * @return
     */
    public int getAge() {
        return age;
    }

    /**
     * 修改年龄的接口
     * @param age   接收输入的年龄
     */
    public void setAge(int age) {
        if(age>=0) {
            this.age = age;
        }
    }

    /**
     * 获取命中率
     * @return
     */
    public int getRate() {
        return rate;
    }

    /**
     * 修改命中率
     * @param rate
     */
    public void setRate(int rate) {
        if(rate>=0&&rate<=100) {
            this.rate = rate;
        }   
    }

    @Override
    public String toString() {
        return "Player [name=" + name + ", age=" + age + ", position=" + position + "]";
    }
    
    /**
     * 投篮的方法
     * @return      true表示投进，false表示没投进
     */
    public boolean shoot() {
        int x = (int)(1+Math.random()*100);//x表示一个1~100之间的随机整数
        //假设rate是90，那么x<=90的概率是rate%
        if(x<=rate) {//如果x小于等于rate，则投篮投进（得2分）
            score+=2;
            return true;
        }
        return false;
    }
    
}

测试类

package day07;

public class PlayerTest2 {

    public static void main(String[] args) {
        Player zs = new Player();
        Player ls = new Player();
        System.out.println(zs);
        System.out.println(ls);
        zs.setAge(23);//修改的是张三的年龄
        //ls.setAge(27);//修改的是李四的年龄
        System.out.println(zs.getAge());//查询
    }

}

image.png

static关键字

1）静态成员变量位于方法区，对应的空间个数只有1个
2）非静态成员变量位于堆内存，对应的空间个数取决于有多少个该类型的对象
3）静态的成员方法里面不能直接调用非静态的成员变量
4）静态的成员方法里面不能直接调用非静态的成员方法
5）静态的成员方法里面可以通过对象名调用非静态的方法，比如：

    public static void main(String[] args){
        Player linshuhao = new Player();
        linshuhao.shoot();//投篮
    }

6）静态的成员方法里面不能直接调用非静态的成员
7）非静态的成员方法里面可以直接调用静态的成员变量
8）非静态的成员方法里面可以直接调用静态的成员方法
9）静态成员可以通过类名调用，也可以通过对象名调用。比如：把成员方法设置成静态的，我们就可以通过类名去调用，否则的话，需要先实例化，然后通过对象名去调用
10）静态成员方法里面不能使用this变量
11）静态代码块的语法格式（了解）

static{//JVM在加载类的时候，会执行该类里面的静态代码块，并且该静态代码块只会被执行一次
    ...
}

学生类

package day06;

/**
 * 学生类
 * @author yangzc
 *
 */
public class Student {
    public int sno;//学号
    public String sname;//姓名
    public boolean isMale;//性别
    public int age;//年龄
    public static int count=0;//学生的数量
    
    public Student() {
        count++;
    }


    /**
     * 自我介绍的方法
     */
    public void info() {
        System.out.println("大家好！我叫"+sname+"，今年"+age+"岁");
        //System.out.println(count);
    }
}

测试类

package day07;

import day06.Student;

public class StudentTest4 {

    public static void main(String[] args) {
        //Student.count=30;
        Student zs = new Student();
        zs.sname="张三";
        zs.sno=1001;
        Student ls = new Student();
        ls.sname="李四";
        ls.sno=1002;
        System.out.println(zs);
        System.out.println(ls);
        //System.out.println(zs.sname);//
        //System.out.println(zs.sno);//1001
        //System.out.println(ls.sname);//
        System.out.println(Student.count);
    }

}

image.png

多态的特点

1）父类的变量可以接收子类对象，比如：

public double pay(Emp obj) {//父类变量obj可以接收子类对象
    //obj表面上是员工
    if(obj instanceof PM) {//如果obj实际上是项目经理的话
        //向下造型（把Emp类型强转成PM类型）
        PM manager = (PM)obj;
        return obj.getSalary()+manager.getBonus();
    }
    return obj.getSalary();
}

2）通过一个指向子类对象的父类引用调用父类的方法，并且子类里面对该方法进行了重写，那么，执行的时候实际调用的是子类的方法，比如：

Emp e = new SE();//程序员的工资默认是5000.0
e.setSalary(-1000.0);//实际调用的是子类的setSalary接口
System.out.println(e.getSalary());//实际调用的是父类的getSalary接口

说明：
使用多态的话，代码维护起来比较方便

向上造型（子类可以自动转换成父类）

Cat类型可以自动转成Animal类型

//父类变量可以接收子类对象
//Cat是Animal的子类，可以自动转成Animal
Animal obj = new Cat();//猫是动物，正确
//子类变量不能接收父类对象
Cat cat = new Animal();//动物是猫，错误

向下造型（通过强制转换可以将父类转换成子类）

把Animal类型强转成Cat类型

Animal obj = new Cat();
if(obj instanceof Dog){//如果animal所指向的对象是狗的话
    //把Animal（父类）强制转换成Dog（子类）
    Dog wangcai = (Dog)obj;
}
if(obj instanceof Cat){//如果animal所指向的对象是猫的话
    //把Animal（父类）强制转换成Cat（子类）
    Cat hellokitty = (Cat)obj;
}

Cat类和Dog类之间没有继承关系，把Cat类强转成Dog类会发生编译错误

Cat cat = new Cat();
Dog dog = (Dog)cat;//编译出错（不能把Cat强转成Dog）

把Animal类强转成Dog类会发生运行异常，因为obj实际上是猫

Animal obj = new Cat();
Dog dog = (Dog)obj;//运行出错

字符串比较

//判断两个字符串对象的内容是否相等
System.out.println(str.equals(str1));

//比较的是对象的内存地址
System.out.println(对象名==对象名);

案例代码

public static void main(String[] args) {
    String str = "123";
    String str1 = new String("123");
    String str2 = "123";
    System.out.println(str == str1);
    System.out.println(str == str2);
}

image.png

字符串替换

public String replace(char oldChar,char newChar){
  ...
}

参数：
oldChar - 原字符。
newChar - 新字符。
返回：
一个从此字符串派生的字符串，它将此字符串中的所有 oldChar 替代为 newChar。
说明：
返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
如果 oldChar 在此 String 对象表示的字符序列中没有出现，则返回对此 String 对象的引用。否则，创建一个新的 String 对象，它所表示的字符序列除了所有的 oldChar 都被替换为 newChar 之外，与此 String 对象表示的字符序列相同。

案例代码

public static void main(String[] args) {
    System.out.println("String".replace('g', 'G') == "String".replace('g','G'));
    System.out.println("String".replace('t', 't') == "String".replace('t','t'));
}

image.png

UTF-8编码和Unicode编码

汉字字符集查询：
https://www.qqxiuzi.cn/bianma/zifuji.php

中文字符	UTF-8编码（16进制）	Unicode编码（16进制）	GBK编码（16进制）
小	E5B08F	5C0F	D0A1
米	E7B1B3	7C73	C3D7

package examples;

import java.util.ArrayList;
import java.util.List;

public class UTF8Test {

    public static void main(String[] args) throws Exception {
        String str = "小米";
        byte[] arr = str.getBytes("utf-8");
        char[] arr2 = str.toCharArray();
        byte[] arr3 = str.getBytes("GBK");
        List<String> list = new ArrayList<String>();
        List<String> list2 = new ArrayList<String>();
        List<String> list3 = new ArrayList<String>();

        for(byte e:arr) {
            list.add(String.format("%x", e));
        }
        //输出中文字符串的UTF-8编码
        System.out.println(list);//[e5, b0, 8f, e7, b1, b3]
        
        for(char e:arr2) {
            list2.add(Integer.toHexString(e));
        }
        //输出中文字符串的Unicode编码
        System.out.println(list2);//[5c0f, 7c73]
        
        for(byte e:arr3) {
            list3.add(String.format("%x", e));
        }
        //输出中文字符串的GBK编码
        System.out.println(list3);//[d0, a1, c3, d7]
    }

}

---

参考资料

[01] 运算符的结合性
https://www.cnblogs.com/softwaretesting/archive/2011/08/16/2139068.html
[02] Java运算符优先级
https://www.cnblogs.com/zjfjava/p/5996666.html
[03] 在JAVA命令行中输入参数，星号是如何处理的？
https://zhidao.baidu.com/question/56783574.html
[04] JVM内存初学 堆、栈、方法区
https://www.cnblogs.com/dingyingsi/p/3760730.html
[05] Java中的堆内存、栈内存和方法区总结
https://orochimaru-sama.iteye.com/blog/2372341
[06] 你所不知道的Java之char默认值
https://www.jianshu.com/p/d20d5f8bb878
[07] JAVA经典算法40题
https://www.cnblogs.com/jianmang/articles/4878924.html
[08] java中this关键字的作用
https://www.cnblogs.com/lzq198754/p/5767024.html
[09] java里的静态成员变量是放在了堆内存还是栈内存
https://zhidao.baidu.com/question/1643722234531216060.html
[10] Java基础-方法区以及static的内存分配图
https://blog.csdn.net/wang_1997/article/details/52267688

微信扫一扫关注该公众号【测试开发者部落】

image.png
点击链接加入群聊【软件测试学习交流群】
https://jq.qq.com/?_wv=1027&k=5eVEhfN
软件测试学习交流QQ群号：511619105