JAVA 基础知识学习3

目录

JAVA 面向对象 包装类 数字处理类 接口继承多态异常处理类

方法的参数传递

（1）编写ObjectArg类，在该类中定义几个成员变量，这个类的对象将用于演示方法传参。实例代码如下：

public class ObjectArg {
      public String name=""; // 姓名
      public int age=0;  // 年龄
      public String sex="";  // 性别
}

（2）编写ArgDemo类，分别定义测试基本数据类型传参和对象类型传参的方法，并输出它们修改参数的结果。实例代码如下：

public class ArgDemo {
      static int intArg = 10;                                                // int基础类型的测试变量
      static ObjectArg objectArg = new ObjectArg();           // 对象类型的测试变量
      public static void main(String[] args) {
            changeIntArg(intArg);                                  // 测试int基本类型传参
            System.out.println("传递给方法的int类型参数："+intArg);
            System.out.println("intArg=" + intArg);                 // 输出传递给方法的变量值
            objectArg.age = 29;                                     // 初始化对象数据
            objectArg.name = "李经理";
            objectArg.sex = "男";
            changeOjbectArg(objectArg);                              // 测试对象传参
            System.out.println("传递给方法的对象：");
            printObjInfo(objectArg);                              // 输出传递给方法的对象信息
      }
      /**
       * 测试基本数据类型传参的方法
       * @param arg int类型参数
       */
      public static void changeIntArg(int arg) {
            System.out.println("=========实参未改变============= ");
            System.out.println("changeIntArg()方法开始执行");
            System.out.println("int类型参数arg=" + arg);
            System.out.println("将参数值除以2");
            arg = arg / 2;                                              // 改变参数值
            System.out.println("arg=" + arg);
      }
      /**
       * 测试对象类型传参的方法
       * @param arg 对象参数
       */
      public static void changeOjbectArg(ObjectArg arg){
            System.out.println("========实参被改变============== ");
            System.out.println("changeOjbectArg()方法开始执行");
            System.out.println("输出对象参数：");
            printObjInfo(arg);                                        // 输出对象参数信息
            arg.name="王经理";                                    // 修改对象参数信息
            arg.sex="女";
            arg.age=20;
            System.out.println("修改后的对象参数：");
            printObjInfo(arg);                                        // 输出修改后的对象参数信息
      }
      /**
       * 输出对象信息的方法
       * @param arg 对象参数
       */
      private static void printObjInfo(ObjectArg arg) {
            System.out.println("\t名字："+arg.name);
            System.out.println("\t性别："+arg.sex);
            System.out.println("\t年龄："+arg.age);
      }
}

方法重载

方法的重载就是在同一个类里定义了多个名称相同，但是参数类型和数量以及顺序不同的方法。为了更好地理解重载，这里将编写一个方法重载的实例。

实现过程如下：

public class OverLoadTest {
    static int sum = 0; // 成员变量sum 用于累加计数

    /**
     * 把两个int类型整数相加方法
     * 
     * @param numA
     *            第一个int整数
     * @param numB
     *            第二个int整数
     * @return 两数之和,类型为int
     */
    public static int add(int numA, int numB) {
        return numA + numB;
    }

    /**
     * 把两个double 类型实数相加的方法
     * 
     * @param numA
     *            第一个double 实数
     * @param numB
     *            第二个double 实数
     * @return 两数值和,类型为double
     */
    public static double add(double numA, double numB) {
        return numA + numB;
    }

    /**
     * 累加int 类型整数的方法,该方法将参数值累加到sum成员变量
     * 
     * @param numA
     *            int 整形参数
     * @return
     */
    public static int add(int numA) {
        sum += numA;
        return sum;
    }

    /**
     * 把int整数和double类型实数相加的方法
     * 
     * @param numA
     *            int整数
     * @param numB
     *            double实数
     * @return 整数和实数的和，类型为double
     */

    public static double add(int numA, double numB) {

        return numA + numB;

    }

    /**
     * 
     * 把double实数和int类型整数相加的方法
     * 
     * @param numA
     *            double实数
     * 
     * @param numB
     *            int整数
     * 
     * @return 整数和实数的和，类型为double
     * 
     */

    public static double add(double numA, int numB) {

        return numA + numB;

    }

    public static void main(String args[]) {

        System.out.println("调用add(int, int)方法：" + add(1, 2));

        System.out.println("调用add(double, double)方法：" + add(2.1, 3.3));

        System.out.println("调用add(int)方法：" + add(1));

        System.out.println("调用add(int, double)方法：" + add(4, 5.89));

        System.out.println("调用add(double, int)方法：" + add(5.89, 4));

    }

}

integer类进制转换

import java.util.Scanner;

public class RadixConversion {
    private static Scanner scan = new Scanner(System.in);

    public static void main(String[] args) {

        System.out.println("请输入一个十进制数字：");

        int num = scan.nextInt(); // 读取用户输入整数

        String value = Integer.toBinaryString(num); // 把整数转换为二进制格式的字符串

        System.out.println("该数字的二进制格式为：" + value);

        value = Integer.toHexString(num); // 把整数转换为十六进制格式的字符串

        System.out.println("该数字的十六进制格式为：" + value);

        value = Integer.toOctalString(num); // 把整数转换为八进制格式的字符串

        System.out.println("该数字的八进制格式为：" + value);

    }

}

实现星座查询类

public class QueryConstellation {
    /**
     * 功能：根据生日查询星座
     * 
     * @param month
     * @param day
     * @return
     */
    public String query(int month, int day) {
        String name = "";   //提示信息
        if (month > 0 && month < 13 && day > 0 && day < 32) { // 判断输入的月和日是否有效
            if ((month == 3 && day > 20) || (month == 4 && day < 21)) { // 3月21~4月20
                name = "您是白羊座！";
            } else if ((month == 4 && day > 20) || (month == 5 && day < 21)) { // 4月21~5月20
                name = "您是金牛座！";
            } else if ((month == 5 && day > 20) || (month == 6 && day < 22)) { // 5月21~6月21
                name = "您是双子座！";
            } else if ((month == 6 && day > 21) || (month == 7 && day < 23)) { // 6月22~7月22
                name = "您是巨蟹座！";
            } else if ((month == 7 && day > 22) || (month == 8 && day < 23)) { // 7月23~8月22
                name = "您是狮子座！";
            } else if ((month == 8 && day > 22) || (month == 9 && day < 23)) { // 8月23~9月22
                name = "您是处女座！";
            } else if ((month == 9 && day > 22) || (month == 10 && day < 23)) { // 9月23~10月22
                name = "您是天平座！";
            } else if ((month == 10 && day > 22) || (month == 11 && day < 22)) { // 10月23~11月21
                name = "您是天蝎座！";
            } else if ((month == 11 && day > 21) || (month == 12 && day < 22)) { // 11月22~12月21
                name = "您是射手座！";
            } else if ((month == 12 && day > 21) || (month == 1 && day < 20)) { // 12月22~1月19
                name = "您是摩羯座！";
            } else if ((month == 1 && day > 19) || (month == 2 && day < 19)) { // 1月20~2月18
                name = "您是水牛座！";
            } else if ((month == 2 && day > 18) || (month == 3 && day < 21)) { // 2月19~3月20
                name = "您是双鱼座！";
            }
            name = month + "月" + day + "日  " + name; // 组合提示信息
        } else {
            name = "请输入您的真实的生日！"; // 设置错误提示信息
        }
        return name;
    }
}

通过类的实例访问成员变量和方法

public class Circ {
final float PI = 3.14159f; // 定义一个用于表示圆周率的常量PI
public float r = 0.0f;

// 定义计算圆面积的方法
public float getArea() {
float area = PI * r * r; // 计算圆面积并赋值给变量area
return area; // 返回计算后的圆面积
}

// 定义计算圆周长的方法
public float getCircumference(float r) {
float circumference = 2 * PI * r; // 计算圆周长并赋值给变量circumference
return circumference; // 返回计算后的圆周长
}

// 定义主方法测试程序
public static void main(String[] args) {
Circ circ = new Circ();
circ.r = 20; // 改变成员变量的值
float r = 20;
float area = circ.getArea(); // 调用成员方法
System.out.println("圆的面积为：" + area);// 输出面的面积
float circumference = circ.getCircumference(r); // 调用带参数的成员方法
System.out.println("圆的周长为：" + circumference); // 输出圆的周长
}
}

统计字符串的实际长度的类

public class TotalWordcount {
    /**
     * 功能：统计字符串的实际长度
     * @param str
     * @return
     */
    public int total(String str) {
        byte temp[];    //临时的字节数组
        int strlength=0;    //字符串的实际长度
        for(int i=0;i<str.length();i++){    //循环语句
            temp=(str.substring(i,i+1)).getBytes(); //获取一个字符并存储到字节数组中
            strlength+=temp.length; //累加字符串的长度
        }
        return strlength;   //返回字符串的实际长度
    }
}

获取汉字拼音简码的类

public class GetCharSpell {

    public String getCharSpell(String character){
        String spell="";    //汉字拼音简码
        String str[]=character.split("");   //将汉字分隔为数组
        int length=str.length;//获取汉字的个数
        byte[] a=null;  //空的字节数组
        String getchar="";  //单个汉字的拼音简码
        for(int i=1;i<length;i++){
            a=str[i].getBytes();
            if(a.length>1){
                int asc=256*(a[0]+256)+(a[1]+256);
                if(asc>=45217 && asc<=45252){
                    getchar= "A";
                }else if(asc>=45253 && asc<=45760){
                    getchar= "B";
                }else if(asc>=45761 && asc<=46317){
                    getchar= "C";
                }else if(asc>=46318 && asc<=46825){
                    getchar= "D";
                }else if(asc>=46826 && asc<=47009){ 
                    getchar= "E";
                }else if(asc>=47010 && asc<=47296){ 
                    getchar= "F";
                }else if(asc>=47297 && asc<=47613) { 
                    getchar= "G";
                }else if(asc>=47614 && asc<=48118) {
                    getchar= "H";
                }else if(asc>=48119 && asc<=49061) {
                    getchar= "J";
                }else if(asc>=49062 && asc<=49323) { 
                    getchar= "K";
                }else if(asc>=49324 && asc<=49895) { 
                    getchar= "L";
                }else if(asc>=49896 && asc<=50370) { 
                    getchar= "M";
                }else if(asc>=50371 && asc<=50613) { 
                    getchar= "N";
                }else if(asc>=50614 && asc<=50621) { 
                    getchar= "O";
                }else if(asc>=50622 && asc<=50905) {
                    getchar= "P";
                }else if(asc>=50906 && asc<=51386) { 
                    getchar= "Q";
                }else if(asc>=51387 && asc<=51445) { 
                    getchar= "R";
                }else if(asc>=51446 && asc<=52217) { 
                    getchar= "S";
                }else if(asc>=52218 && asc<=52697) { 
                    getchar= "T";
                }else if(asc>=52698 && asc<=52979) { 
                    getchar= "W";
                }else if(asc>=52980 && asc<=53640) { 
                    getchar= "X";
                }else if(asc>=53689 && asc<=54480) { 
                    getchar= "Y";
                }else if(asc>=54481 && asc<=62289) {
                    getchar= "Z";
                }
            }
            else{   //不是汉字时
                getchar=str[i]; //简码等于本身
            }
            spell+=getchar; //连接生成的拼音简码
        }       
        return spell;
    }
}

编写验证E-mail地址的类

public class CheckEmail {
public boolean checkEmail(String email){
    boolean result=false;
     String regex = "\\w+([-+.']\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*"; //正则表达式，定义邮箱格式
     if(email.matches(regex)){                            //matches()方法可判断字符串是否与正则表达式匹配
         result=true;
     }
    return result;
}
}

编写用选择法对数组排序的类

public class ArraySort {
    /**
     * 升序排列
     * @param arr
     * @return
     */
    public int[] ascSort(int[] arr){
        int min=0;  //当前比较的两个数组元素中小的下标
        for(int i=0;i<arr.length;i++){
            min=i;
            for(int j=i+1;j<arr.length;j++){
                if(arr[j]<arr[min]){
                    min=j;  //将max设置为两个数中较小的一个的下标
                }
            }
            //将arr[min]与arr[i]中的值互换
            int t=arr[min]; 
            arr[min]=arr[i];
            arr[i]=t;   
        }
        return arr;
    }
    /**
     * 降序排列
     * @param arr
     * @return
     */
    public int[] descSort(int[] arr){
        int max=0;  //当前比较的两个数组元素中小的下标
        for(int i=0;i<arr.length;i++){
            max=i;
            for(int j=i+1;j<arr.length;j++){
                if(arr[j]>arr[max]){
                    max=j;  //将max设置为两个数中较大的一个的下标
                }
            }
            //将arr[max]与arr[i]中的值互换
            int t=arr[max];
            arr[max]=arr[i];
            arr[i]=t;
        }
        return arr;
    }   
}

计算某年某月的天数

/**
 * 字符串工具类
 * @author WuYang
 *
 */
public class StringUtil {
    /**
     * 判断一个字符串是否为数字
     * @param strNum
     * @return 为数字时返回true
     */
    public static boolean isNumber(String strNum){
        // 判断字符串是否有效
        if(strNum == null || strNum.isEmpty()){
            return false;
        }
        // 将字符串转换为char型数组
        char[] arr = strNum.toCharArray();
        // 遍历字符数组
        for (char c : arr) {
            // 判断字符数组中的每一个数是否为数字
            if(!Character.isDigit(c)){
                return false;
            }
        }
        // 字符串为数字返回true
        return true;
    }
    /**
     * 计算某年某月的天数
     * @param year 年份
     * @param month 月份
     * @return 天数
     */
    public static int account(int year, int month){
        // 定义天数
        int day = 0;
        // 判断月份为几月
        switch (month) {
            // 如果月份为1、3、5、7、8、10、12天数为31天
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
                day = 31;
                break;
            // 如果月份为4、6、9、11天数为30
            case 4:
            case 6:
            case 9:
            case 11:
                day = 30;
                break;
        }
        // 判断是否为2月
        if(month == 2){
            // 判断年份是否闰年
            if((year % 4 == 0 && year % 100 != 0) ||  (year % 4 == 0 && year % 400 == 0)){
                // 闰年为29天
                day = 29;
            }else{
                // 不是闰年为28天
                day = 28;
            }
        }
        // 返回天数
        return day;
    }
}

包装类 Integer Long Short Boolean Byte Chaeacter Double Float Number

/**
 * @author wuyang 包装类 integer 类型
 */
public class Getint {
    public static void main(String args[]) {
           String str = Integer.toString(456);                // 获取数字的十进制表示
           String str2 = Integer.toBinaryString(456);     // 获取数字二进制表示
           String str3 = Integer.toHexString(456);        // 获取数字的十六进制表示
           String str4 = Integer.toOctalString(456);       // 获取数字的八进制表示
           System.out.println("'456'的十进制表示为：" + str);
           System.out.println("'456'的二进制表示为：" + str2);
           System.out.println("'456'的十六进制表示为：" + str3);
           System.out.println("'456'的八进制表示为：" + str4);
           int maxint = Integer.MAX_VALUE;         // 获取Integer类的常量值

           int minint = Integer.MIN_VALUE;

           int intsize = Integer.SIZE;

           System.out.println("int类型可取的最大值是：" + maxint); // 将常量值输出

           System.out.println("int类型可取的最小值是：" + minint);

           System.out.println("int类型的二进制位数是：" + intsize);


    }

}

十进制 二进制 十六进制互相转换

import java.awt.BorderLayout;
import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;

import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JTextField;
import com.lyq.RadioPanel;
import com.lzw.BackgroundPanel;
import com.swtdesigner.SwingResourceManager;

public class MainFrame extends JFrame {
    private static final long serialVersionUID = 1074908476800267585L;
    private JTextField textField_2;
    private JTextField textField;
    /**
     * Launch the application
     * @param args
     */
    public static void main(String args[]) {
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                try {
                    MainFrame frame = new MainFrame();
                    frame.setVisible(true);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

    /**
     * Create the frame
     */
    public MainFrame() {
        super();
        setResizable(false);
        setTitle("进制转换");
        setBounds(100, 100, 490, 209);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        final BackgroundPanel backgroundPanel = new BackgroundPanel();
        backgroundPanel.setImage(SwingResourceManager.getImage(MainFrame.class, "/res/bg.jpg"));
        getContentPane().add(backgroundPanel, BorderLayout.CENTER);

        textField = new JTextField();
        textField.setBounds(120, 25, 297, 22);
        backgroundPanel.add(textField);

        final RadioPanel radioPanel = new RadioPanel();
        radioPanel.setBounds(67, 53, 350, 43);
        backgroundPanel.add(radioPanel);

        final JLabel label = new JLabel();
        label.setText("转换前：");
        label.setBounds(67, 27, 52, 18);
        backgroundPanel.add(label);

        final JLabel label_1 = new JLabel();
        label_1.setText("转换后：");
        label_1.setBounds(67, 104, 52, 18);
        backgroundPanel.add(label_1);

        textField_2 = new JTextField();
        textField_2.setBounds(120, 102, 297, 22);
        backgroundPanel.add(textField_2);

        final JButton button = new JButton();
        button.addActionListener(new ActionListener() {
            public void actionPerformed(final ActionEvent e) {
                // 获取文本框中的字符串
                String strNum = textField.getText();
                // 如果文本框中的字符串不是一个数
                if(!StringUtil.isNumber(strNum)){
                    // 错误提示
                    JOptionPane.showMessageDialog(null, "请输入正确的数据！");
                    return;
                }
                // 返回字符数组
                char[] arr = strNum.toCharArray();
                // 遍历字符数组
                for (char c : arr) {
                    // 如果字符为"abcdef"
                    if("abcdef".indexOf(c) != -1){
                        // 转换为16进制
                        strNum = Long.parseLong(strNum, 16) + "";
                        break;
                    }
                }
                // 获取所选择的进制
                int select = radioPanel.getSelect();
                // 提示信息
                String value = "错误！";
                // 判断所选择的进制
                switch (select) {
                    case 16:
                        // 转换为16进制
                        value = Long.toHexString(Long.valueOf(strNum));
                        break;
                    case 10:
                        // 转换为10进制
                        value = Long.toString(Long.valueOf(strNum), 10);
                        break;
                    case 8:
                        // 转换为8进制
                        value = Long.toOctalString(Long.valueOf(strNum));
                        break;
                    case 2:
                        // 转换为2进制
                        value = Long.toBinaryString(Long.valueOf(strNum));
                        break;
                }
                textField_2.setText(value);
            }
        });
        button.setText("转换");
        button.setBounds(330, 136, 88, 28);
        backgroundPanel.add(button);
        //
    }

}

---

/**
 * 字符串工具类
 * @author YongQiang Lee
 *
 */
public class StringUtil {
    /**
     * 判断一个字符串是否为数字
     * @param strNum
     * @return 为数字时返回true
     */
    public static boolean isNumber(String strNum){
        // 判断字符串是否有效
        if(strNum == null || strNum.isEmpty()){
            // 返回false
            return false;
        }
        // 将字符串转换为字符数组
        char[] arr = strNum.toCharArray();
        // 遍历数组
        for (char c : arr) {
            // 如字符不是一个数字
            if(!Character.isDigit(c)){
                // 判断字符是否为"abcdef"中的字符
                if("abcdef".indexOf(c) == -1){
                    // 返回false
                    return false;
                }
            }
        }
        // 返回true
        return true;
    }
}

---

public class Example {
    public static void main(String[] args) {
        // 创建int型变量a
        int a = 128;
        // 将a转换为二进制
        String str1 = Integer.toBinaryString(a);
        // 将a转换为八进制
        String str2 = Integer.toOctalString(a);
        // 将a转换为十六进制
        String str3 = Integer.toHexString(a);
        // 输出转换结果
        System.out.println("十进制128的二进制表示是：" + str1);
        System.out.println("十进制128的八进制表示是：" + str2);
        System.out.println("十进制128的十六进制表示是：" + str3);
    }
}

使用character 把String 转换为大写

public class Example {
    public static void main(String[] args) {
        // 实例化一个字符串
        String oldStr = "I Love ShangHai";
        // 将字符串转换为字符数组
        char[] arr = oldStr.toCharArray();
        // 遍历数组中的元素
        for (int i = 0; i < arr.length; i++) {
            // 如字符为小写将其转换为大写
            if (Character.isLowerCase(arr[i])) {
                arr[i] = Character.toUpperCase(arr[i]);
            }
        }
        // 转换后的字符串
        String newStr = new String(arr);
        // 输出信息
        System.out.println("转换前字符串的内容是：" + oldStr);
        System.out.print("转换后字符串的内容是：" + newStr);
    }
}

使用character 把String 转换为小写

public class Example {
    public static void main(String[] args) {
        // 实例化一个字符串
        String oldStr = "I Love Beijing";
        // 将字符串转换为字符数组
        char[] arr = oldStr.toCharArray();
        // 遍历数组中的元素
        for (int i = 0; i < arr.length; i++) {
            // 如字符为大写将其转换为小写
            if (Character.isUpperCase(arr[i])) {
                arr[i] = Character.toLowerCase(arr[i]);
            }
        }
        // 转换后的字符串
        String newStr = new String(arr);
        // 输出信息
        System.out.println("转换前字符串的内容是：" + oldStr);
        System.out.print("转换后字符串的内容是：" + newStr);
    }
}

使用compareTo 方法比较int型数的大小

public class Example {
    public static void main(String[] args) {
        // int型变量a
        int a = 100;
        // int型变量a
        int b = 1000;
        // Integer对象num1
        Integer num1 = new Integer(a);
        // Integer对象num2
        Integer num2 = new Integer(b);
        // 比较num1与num2的大小
        int flag = num1.compareTo(num2);
        if (flag < 0) {
            System.out.println(a + "小于" + b);
        } else if (flag == 0) {
            System.out.println(a + "等于" + b);
        } else {
            System.out.println(a + "大于" + b);
        }
    }
}