Java ——基础语法

package myhello; // 本类所在的包的路径

import af.util.AfMath; // 导入对应的类

import java.util.Random; // 导入随机数的类

public class HelloWorld
{

    public static void main(String[] args)
    {
        int a = 8;
        int i;
        int total = 0;
        int score = 80;
        System.out.println(a > 8);
        // 空语句 只有一个 ;
        ;
        // 复合语句 {} 包含的
        {
            ;
        }
        // if 语句
        if (score > 60)
            System.out.println("及格");
        else
            System.out.println("不及格");

        for (i = 1; i <= 100; i++)
        {
            total += i * i;
        }
        System.out.println(total);

        // break 为跳出单层循环

        // 创建数据对象
        int[] b = new int[30];
        // 等号右侧：创建了一个数组对象
        // 等号左侧：变量 b 称为该对应的引用
        // 称作 变量 b 指向了一个对象
        // 有时也简称为： b 是一个对象，或 b 是对象的名字

        b[1] = 1;
        b[2] = 2;
        b[3] = 3;

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

        System.out.println(arr.length);

        // arr[4] = 128; 数组越界

        // 对应与引用
        int[] c = { 11, 11, 11, 11 };
        int[] d = c;
        // c 指向了一个对象
        // c 和 d 指向相同的对象
        // c 和 d 都是该对象的引用
        d[3] = 30;
        for (int k = 0; k < 4; k++)
        {
            System.out.print(c[k] + "   ");
        }

        // 空对象
        // null 表示一个引用不指向任何对象
        int[] e = { 1, 2, 3, 4 };
        int[] f = e;
        e = null;

        // 空指针错误
        /*
         * for (int t = 0; t < 4; t++) { System.out.print(e[t]+"  "); }
         */
        for (i = 0; i < 4; i++)
        {
            System.out.print(f[i] + "  ");
        }

        // 类 class
        // 类：类型，描述某一类事物的共性
        // 对象：一个具体实例
        // 用来描述一种数据类型
        // 一个class可以若干基本类型的组合
        Student s1 = new Student();
        s1.id = "20181109";
        s1.name = "Jenrry";
        s1.sex = true;
        s1.cellphone = "555";
        // Student 是一个类型
        // 所有的 Student 都有 id,name,sex,cellphone这几个属性
        // s1是一个Student 类型的对象
        // 数组
        Student[] s2 = new Student[5];

        // 类的嵌套
        s1.cards.bankCardNumber = "123";
        s1.cards.schoolCardNumber = "456";

        // java 会有默认值

        // 类的方法
        // 类.属性：描述 类有什么
        // 类.方法：描述 类能做什么
        // 属性命名一般使用名词性短语 方法一般是动词性短语
        Student s3 = new Student();
        s3.show();
        s3.show2(15);

        // 获取最大指
        int[] a1 = { 1, 2, 3 };
        int[] aa1 = { 123, 546, 145, 789 };
        int result = 0;
        for (i = 0; i < a1.length; i++)
        {
            if (a1[i] > result)
            {
                result = a1[i];
            }
        }
        System.out.print("
");
        System.out.print("最大值：" + result);
        MyMath a2 = new MyMath();
        System.out.print("
");
        a2.getMax(aa1);
        int result2 = a2.getMax2(aa1);
        System.out.print("
");
        System.out.print("最大值：" + result2);

        // return语句执行后，函数不再往下执行，直接退出方法
        MyMath n = new MyMath();
        boolean res = n.check2(aa1);
        System.out.print("结果为：" + res);

        // 给定一个int值，结果打印一个三角形
        MyMath n2 = new MyMath();
        System.out.print("
");
        n2.print(10);
        n2.print(-1);
        // 数组里能被8整除
        int[] arr2 = { 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 };
        MyMath n3 = new MyMath();
        int[] result3 = n3.find8(arr2);

        // 返回类型可以是一个对象
        Student stu = n.createNew("2324", "你好");

        // 像素
        Screen s = new Screen();
        s.height = 768;
        s.width = 1366;
        int p = s.pixel(s.width, s.height);
        System.out.println("像素值是：" + p);
        // 用 that指定
        int p2 = s.pixel2(s);
        System.out.println("像素值2是：" + p2);
        // 当前对象 this
        int p3 = s.pixel3();
        System.out.println("像素值3是：" + p3);

        // 显示从 m，n之前所有的质数 用到this
        MyMath n4 = new MyMath();
        n4.showPrimes(400, 500);
        // this. 一般可以省略 重名不能省略

        // 有一个换游戏币的机器，可以投1元、5、10元，最后按出货按钮，可以吐出游戏币
        // 每个游戏币=1元人民币
        Machine n5 = new Machine();

        n5.insertCash(5);
        n5.insertCash(10);
        n5.insertCash(50);
        // 出货
        int coins = n5.exchange();
        System.out.println("拿到了" + coins + "个游戏币");

        // 用户输入：数组data
        // 把打他数组里面，所有的质数都放到result
        PrimeFilter filter = new PrimeFilter();
        int[] a4 = { 128, 38, 103, 89 };
        int[] a5 = { 34, 8, 11, 29 };
        filter.put(a4);
        filter.put(a5);
        int[] numbers = filter.values();
        // 对象=属性+方法
        // 属性就是数据
        // 方法就是算法
        // 对象就是数据和算法的整合体
        // 给它所需的数据>>让它干活>>取出结果
        // 面向对象程序设计

        // 访问修饰符
        // public private
        // 可见性
        // private 不可访问，即不可见
        // public 可以访问，即可见

        // 构造方法
        // 用于构造对象的方法 当创建对象时调用的方法
        // 规则: 方法名与类名相同；无返回值
        Student2 stu2 = new Student2("123", "Jenrry", true);
        // 默认构造方法 无参数
        // 如果没有构造方法，java编译器会默认一个空的构造方法
        /*
         * public Student2() {
         * 
         * }
         * 
         */

        // 对象的销毁
        // 程序员只管创建对象，不管销毁对象，对象的销毁由系统自动完成
        // 当对象不再被使用时，由垃圾回收机制GC自动回收 GC: Garbage Collect
        // 对象不再被使用。即对象失去引用

        // extends 继承
        // 在 java语言里，用exends来表示两个类的父子关系
        // public class B extends A
        // 表示B继承A
        // A:父类 B:子类
        // 当B继承于A时，自动继承A中的public 属性/方法
        MyVideoFile file = new MyVideoFile();
        file.size = 123034;
        file.name = "文档";
        file.duration = 120;
        file.info();
        file.play();
        file.stop();

        // 重写
        // 如果父类的方法不满足要求，则可以在子类里重写一遍
        file.info();

        // 父类构造方法
        // 子类会先调用父类构造方法 再调用子类的构造方法
        // 可以用 super 制定调用哪个构造方法
        // 创建一个对象时，构造方法被调用
        Child ch = new Child();
        System.out.println("exit");

        // 单根继承
        // java语言里，一个类只能extend是一个父类
        // 继承只能有1个父亲，但是可以有一个继承链
        // 即 A -> B -> C -> D ……
        // 看继承链 右键 Quick Type Hierarchy
        // 在 java 语言中，Object 类是所有类的父类 上面的快捷键可以展示出来
        // 如果一个类没有指定父类，则它默认父类就是 Object

        // 重写 toString() 方法
        // toString() 是 Object 的一个方法
        Student Stu = new Student();
        Stu.id = "1234";
        Stu.name = "4567";
        Stu.sex = true;
        System.out.println(Stu);// 重写 toString 函数，修改 Stu 显示的格式

        // 多态
        // java里，包含：重载 Overload ；重写 Override ；泛型
        // 有一个饼干，是苹果味饼干
        Pie pi = new ApplePie();
        // 有一个宝宝
        Baby bb = new Baby();
        // 宝宝要吃饼干
        bb.eat(pi);
        // 语法上：
        // 1. 子类转换成父类顺理成章(隐式转换)
        // 如上 Pie pi = ApplePie();
        // 2. 父类转换成子类型要谨慎 需要显式转换

        // 多态
        MyVideoFile f1 = new MyVideoFile();
        f1.name = "abc.mp4";
        f1.size = 14000;
        f1.duration = 130;

        MyFile file2 = f1;
        file2.info();
        // 注意 当调用一个方法是，不是看引用(声明)的类型，而是看对象的实际类型
        // file 指向的是一个MyVideoFile对象，因而调用的是子类的info()方法
        // 在 java里，由于所有的类型都是Object的直接或者间接子类
        // 所以。 Object x = new MyVideoFile(); 是没有问题的。

        // 包
        // 右键点击包名， show in -> System Explorer
        // 建立目录是用 . 分隔
        // 一个类XXX，对应的文件是 XXX.java
        // 类的全路径： af.util.AfMath
        // 类的文件路径： af/util/AfMath.java

        // 导入类
        AfMath a8 = new AfMath();

        // 类改名
        // 左窗口右键对应的类 -> refactor->rename
        // 改属性名、方法名 对应属性/方法 右键-> refactor -> rename

        // 快捷键
        // 注释：选中要注释的行 ctrl+ /
        // 查看定义： CTRL+鼠标点击
        // 打开提示： ATL+ /
        // 格式化选中代码： CTRL+SHIFT+F

        // 静态方法(全局方法)
        // 该方法与类的关系不大。随便拷贝到别的类里也仍然可以运行，没有语法错误；没有this对象
        // 动态方法
        // 该方法与类关系密切。如果拷贝到别的类里就失去意义，有语法错误。
        // 静态方法用 static 修饰
        // 静态方法调用无需创建对象，因为是一个全局的
        boolean result5 = Example.isPrime(123);

        // Math 类
        // 有很多数据计算相关的静态方法
        // 和 String类似，Math 也是 java 语言自带的类
        // abs(a): 求a的绝对值
        // pow(a,b): 求a的b次幂
        // sqrt(a) : 求a的平方根
        // round(a): 四舍五入
        // sin/cos/tan:
        // 应用 Math.

        // 程序入口：
        // main 方法，仅有一个格式
        // 可以有多个，用于类的调试
        // 如有多个 入口需指定

        // 字符串
        // 字符串长度 String s = ""; int n = s.length();
        // 注：中文字符和英文字符都只占一个字符
        // 空字符串和null是两回事；空字符串是一个正常的字符串对象；null不指向任何对象
        // 截断 substring(begin,end) ; s.substring
        // 相等 equals 注：不能使用 == 符号来验证
        // 比较 compareTo
        // 忽略大小写比较 compareToIgnoreCase()
        // 格式化 format
        // 查找 indexOf
        // 前缀 startWith()
        // 后缀 endsWith

        // 基本类型与包装类型
        // 在java里面。每一个基本类型都对应一个包装类型
        // long -> Long
        // int -> Integer
        // short -> Short
        // byte -> Byte
        // double -> Double
        // float -> Float
        // boolean -> Boolean
        // 包装类型： 将对应的基本类型封装在内，得到一个类大概就是这种形式
        // class Integer
        // {
        // private int value = 0;
        // ... Getter/Setter/...方法
        // }
        // 使用Integer等包装类，就可以统一用“对象”的思路；来处理问题
        // 所有的类都是Object的子类，Interger也是，但 int，double，boolean 却不是,他们是基本的数据类型
        // Java是面向对象的编程语言，一切都是对象，但是为了编程的方便还是引入了基本数据类型，为了能够将这些基本数据类型当成对象操作，Java为每一个基本数据类型都引入了对应的包装类型
        // 基本类型和包装类型的转换
        // Integer ai= new Integer(10);
        // int bi = ai.intValue();
        // // 也可以简写，java支持自动转换
        // Integer ki =123;
        // int mi = ki;
        // 数值-> String
        // int -> String
        // String s = String.valueOf(123);
        // String -> int
        // int a = Integer.valueOf("123");

        // 为什么要设计这些包装类：
        // 1. 提供一些用于转换的方法；
        // 2. 将所有类型统一成类的范围，都是Object的子类

        // 控制台
        // 在上个世纪，在图形界面出现之前、一种基于文字的用户交互界面
        AfConsole cf = new AfConsole();
        cf.print("请输入用户名：");
        String username = cf.readString("");
        cf.print("请输入密码：");
        String password = cf.readString("");

        if (password.equals("123456"))
        {
            cf.println(username + "，你好！欢迎进入系统！");
        } else
        {
            cf.println("密码错误！");
        }

        // 随机数
        // Random 类是JDK里自带的基本类
        // java.util.Random
        // 使用Random可以生成随机数
        // Random rand = new Random();
        // int s = rand.nextInt(1000);
        // nextInt(1000)表示生成一个0~1000 的随机数
        Random rand = new Random();
        for (i = 0; i < 3; i++)
        {
            int sr = rand.nextInt(1000);
            System.out.println("生成随机数：" + sr);
        }
        // 抽3个人获奖 ，不能重复
        int[] resultr = new int[3];
        int count = 0;
        Random rand2 = new Random();
        while (count < 3)
        {
            // 抽一个幸运员工。sra是它的号码
            int sra = rand2.nextInt(95);
            // 检查sra是否已经中过奖，检查sra是否在result里
            boolean exist = false;
            for (i = 0; i < count; i++)
            {
                if (resultr[i] == sra)
                {
                    exist = true;
                    break;
                }
            }
            if (exist)
            {
                continue;
            } else
            {
                resultr[count] = sra;
                count++;
            }
        }

        // 字符
        // 一个字符 char c1 = 'A';
        // 字符编码
        // 地球上所有的文字和符号都有一个编码Unicode，其中，把 0 -128 之前的称为 ASCII码，仅英文、数字、英文标点符号等，对应键盘上的按键

        // 字符与字符串
        // String -》 char
        // String str = "afanihao阿发你好";
        // char ch = str.charAt(8);//下标从0开始计数
        // char[] chs= str.toCharArray();
        // char -> String
        // char[] chs = {'阿','发'.'你'.'好'};
        // String str = new String(chs,1,3);
        // str += '的';

        // 在字符串字符中查找字符
        // String str ="afanihao阿发你好";
        // int p = str.indexOf('发');
        // System.out.println("位置" + p);

        // 容器:存储对象的东西
        // 容器是一个设计上的术语，不是一个语法的概念
        // 比如说，数组就是一个容器

        // 链表： 一种组织数据的方式
        Monkey m1 = new Monkey(100, "100");
        Monkey m2 = new Monkey(200, "200");
        Monkey m3 = new Monkey(300, "300");
        Monkey m4 = new Monkey(400, "400");

        m1.next = m2;
        m2.next = m3;
        m3.next = m4;
        m4.next = null;

        Monkey node = m1;
        while (node != null)
        {
            System.out.println("链表中的节点：" + node);
            node = node.next;
        }

        // 链表插入和删除节点
        // 1.插入到末尾
        Monkey m5 = new Monkey(500, "500");
        m4.next = m5;
        // 正规写法，从头开始
        Monkey tail = m1;
        while (true)
        {
            if (tail.next == null)
                break;
            tail = tail.next;
        }
        tail.next = m5;
        // 2.插到头节点之后
        Monkey head = m1;
        m5.next = m1.next;
        m1.next = m5;

        // 3.插到300 之后
        node = m1;
        while (node != null)
        {
            if (node.id == 200)
            {
                m5.next = node.next;
                node.next = m5;
                break;
            }
            node = node.next;
        }

        // 插入节点
        // 有头链表：用一个固定的加节点来充当头节点。
        // 此节点不算作链表长度，仅用于简化算法
        // 有头链表的构造
        // 创建一个假节点，作为链表的头节点
        Monkey head1 = new Monkey(0, "0");
        head1.next = m1;
        // 遍历
        Monkey m = head1.next;
        while (m != null)
        {
            System.out.println("链表");
            m = m.next;
        }
        // 有头链表：插入节点
        // 直接插入假节点后面
        m5.next = head1.next;
        head1.next = m5;
        // 有头链表：删除节点200
        Monkey node1 = head.next;
        Monkey prov = head1;
        while (node1 != null)
        {
            if (node1.id == 200)
            {
                prov.next = node1.next;
                break;
            }
            prov = node1;
            node1 = node1.next;
        }
        // 或者采用如下
        Monkey node3 = head1;
        while (node.next != null)
        {
            if (node.next.id == 200)
            {
                node.next = node.next.next;
                break;
            }
            node = node.next;
        }
        
        // 链表只是容器的一种实现方法
        
    }

}

package myhello;

import java.io.BufferedReader;
import java.io.InputStreamReader; 

public class AfConsole
{
    BufferedReader reader;

    public AfConsole()
    {
        InputStreamReader n = new InputStreamReader(System.in);
        reader = new BufferedReader(n);
    }

    // 输出显示一个字符串
    public void print(String s)
    {
        System.out.print(s);
    }

    // 输出显示一个字符串，并换行
    public void println(String s)
    {
        System.out.println(s);
    }

    // 从控制台读取用户输入，读取一个字符串
    // 如果用户直接按了回车，则返回默认值
    public String readString(String defValue)
    {
        try
        {
            return reader.readLine();
        } catch (Exception e)
        {
            return defValue;
        }
    }

    // 从控制台读取用户输入，读取一个整数
    // 如果用户直接按了回车，则返回默认值
    public int readInt(int defValue)
    {
        try
        {
            String s = readString(null);
            return Integer.valueOf(s);
        } catch (Exception e)
        {
            return defValue;
        }
    }
}

package myhello;

public class ApplePie extends Pie
{

    public ApplePie()
    {
        // TODO Auto-generated constructor stub
    }

}

package myhello;

public class Baby
{

    public void eat(Pie p)
    {
        
    }

}

package myhello;

public class Child extends Parent
{

    public Child()
    {
        // TODO Auto-generated constructor stub
        // 显示指定父类的那个构造函数
        // 子类会默认先去父类的构造函数
        // 除非先显示的取某个构造函数
        super(23);
        System.out.println("子类的构造方法……");
    }
    
    
    

}

package myhello;

public class Example
{

    // 判断n是否为质数
    public static boolean isPrime(int n)
    {
        for (int i = 2; i < n; i++)
        {
            if (n % i == 0)
            {
                return false;
            }
        }
        return true;
    }

}

package myhello;

public class Machine
{
    public int money = 0;// 机器里投入了多少钱
    // 人民币 ：1，5，10

    public void insertCash(int cash)
    {
        if (cash > 10)
        {
            System.out.println("只能识别1元，5元，10元");
            return;
        }
        this.money += cash;
        System.out.println("当前余额：" + this.money);
    }

    // 交易完成
    public int exchange()
    {
        int numOfCoin = this.money / 1;
        this.money = 0;
        System.out.println("交易完成，当前余额清0" + this.money);
        return numOfCoin;
    }
}

package myhello;

// 一个一个猴子从头至尾排列
public class Monkey
{

    public int id;// 编号
    public String name; // 名字
    public Monkey next; // 它后面的猴子
    // null 表示后面没有猴子

    public Monkey()
    {

    }

    public Monkey(int id, String name)
    {
        this.id = id;
        this.name = name;
    }

    @Override
    public String toString()
    {
        // TODO Auto-generated method stub
        // return super.toString();
        return String.format("(%s,%s)", name, id);
    }

}

package myhello;

public class MonkeyList
{
    private Monkey head = new Monkey(0, "0");

    public MonkeyList()
    {
        // TODO Auto-generated constructor stub
    }

    // 添加一个对象
    public void add(Monkey n)
    {
        n.next = head.next;
        head.next = n;
    }

    // 按编号查找
    public Monkey get(int id)
    {
        Monkey n = head.next;
        while (n.next != null)
        {
            if (n.id == id)
                return n;
            n = n.next;
        }
        return null;
    }

}

package myhello;

public class MyFile
{
    public long size;// 文件大小
    public String name;// 文件名

    // 显示文件信息
    public void info()
    {
        System.out.println("文件" + name + " 大小" + size);
    }
}

package myhello;

public class MyMath
{
    public void getMax(int[] data)
    {
        int result = 0;
        for (int i = 0; i < data.length; i++)
        {
            if (data[i] > result)
            {
                result = data[i];
            }
        }
        System.out.print("最大值：" + result);
    }

    public int getMax2(int[] data)
    {
        int result = 0;
        for (int i = 0; i < data.length; i++)
        {
            if (data[i] > result)
            {
                result = data[i];
            }
        }
        return result;
    }

    public boolean check(int[] arr)
    {
        boolean result = false;
        int sum = 0;
        for (int i = 0; i < arr.length; i++)
        {
            sum += sum + arr[i];
            if (sum > 100)
            {
                result = true;
                break;
            }
        }
        return result;
    }

    // check 可以写成如下
    public boolean check2(int[] a)
    {
        int sum = 0;
        for (int i = 0; i < a.length; i++)
        {
            sum += sum + a[i];
            if (sum > 100)
            {
                return true;
            }
        }
        return false;
    }

    // 给定一个int值，结果打印一个三角形
    public void print(int n)
    {
        if (n <= 0)
        {
            System.out.print("小于0");
            return;
        }
        int rows = 0; // 行数
        int cols = 0; // 列数
        for (int k = 1; k <= n; k++)
        {
            System.out.print(k + " ");
            cols++;
            if (cols > rows)
            {
                System.out.print("
");
                rows++;
                cols = 0;
            }
        }
    }

    // 数组里能被8整除
    public int[] find8(int[] arr)
    {
        int[] temp = new int[arr.length];
        int count = 0;
        for (int i = 0; i < arr.length; i++)
        {
            if (arr[i] % 8 == 0)
            {
                temp[count] = arr[i];
                count++;
            }
        }
        int[] result = new int[count];
        for (int i = 0; i < count; i++)
        {
            result[i] = temp[i];
        }
        return result;

    }

    public Student createNew(String id, String name)
    {
        Student temp = new Student();
        temp.id = id;
        temp.name = name;
        return temp;
    }

    // 判断n是否为质数
    public boolean isPrime(int n)
    {
        for (int i = 2; i < n; i++)
        {
            if (n % i == 0)
            {
                return false;
            }
        }
        return true;
    }

    // 显示m,n之前所有的质数
    public void showPrimes(int m, int n)
    {
        for (int i = m; i <= n; i++)
            if (this.isPrime(i))
            {
                System.out.println("质数：" + i);
            }
    }

}

package myhello;

public class MyVideoFile extends MyFile
{
    // 父类的public成员自动继承

    // 添加子类的特性
    public int duration;// 时长

    public void play()
    {
        System.out.println("播放视频" + this.name);
    }

    public void stop()
    {
        System.out.println("停止播放" + this.name);
    }

    public MyVideoFile()
    {
        // TODO Auto-generated constructor stub
    }

    @Override
    // 右键-source-override/...
    public void info()
    {
        // TODO Auto-generated method stub
        // 完全重写
        // System.out.println("文件名：" + this.name + ",大小：" + this.size + ",时长：" +
        // this.duration);
        // 补充
        super.info();
        System.out.println("时长：" + this.duration);
    }

}

package myhello;

public class Parent
{
    int a;
    public Parent()
    {
        // TODO Auto-generated constructor stub
        System.out.println("父类的构造方法……");
    }
    public Parent(int a)
    {
        this.a = a;
    }

}

package myhello;

public class Pie
{

    public Pie()
    {
        // TODO Auto-generated constructor stub
    }

}

package myhello;

public class PrimeFilter
{
    public int[] result = new int[512];
    public int total = 0;

    // 用户输入：数组data
    // 把打他数组里面，所有的质数都放到result
    public void put(int[] data)
    {
        for (int i = 0; i < data.length; i++)
        {
            if (this.isPrime(data[i]))
            {
                this.result[total] = data[i];
                this.total += 1;
            }
        }
    }

    public boolean isPrime(int n)
    {
        for (int i = 2; i < n; i++)
        {
            if (n % i == 0)
            {
                return false;
            }
        }
        return true;
    }

    // 取出最终过滤得到所有的质数
    public int[] values()
    {
        int[] r = new int[total];
        for (int i = 0; i < this.total; i++)
        {
            r[i] = this.result[i];

        }
        return r;
    }

}

package myhello;

public class Screen
{
    public int width;
    public int height;

    public int pixel(int v, int h)
    {
        return v * h;
    }

    public int pixel2(Screen that)
    {
        int result = that.width * that.height;
        return result;
    }

    public int pixel3()
    {
        int result = this.height * this.width;
        return result;
    }
}

package myhello;

public class Student
{
    public String id;
    public String name;
    public boolean sex;
    public String cellphone;
    // 类的嵌套
    public StudentCards cards = new StudentCards();

    // 类的方法

    public void show()
    {
        System.out.print("
");
        for (int i = 0; i < 10; i++)
        {
            System.out.print("报数 " + (i + 1));
        }
    } 
    @Override
    public String toString()
    {
        // TODO Auto-generated method stub
        // return super.toString();
        String s = "学号："+ id+"，姓名："+name;
        if (sex)
        {
            s = s+ "，性别：男";
        }
        else
        {
            s = s + "，性别：女";
        }
        return s;
    } 
    public void show2(int maxNumber)
    {
        System.out.print("
");
        for (int i = 0; i < maxNumber; i++)
        {
            System.out.print("count  " + (i + 1));
        }
    }
 
}

package myhello;

public class Student2
{
    public String id;
    public String name;
    public boolean sex;

    // 构造方法
    public Student2(String id, String name, boolean sex)
    {
        this.id = id;
        this.name = name;
        this.sex = sex;
    }
    // 默认构造方法  无参数
    public Student2()
    {
        this.id = "000";
        this.name = "Jenrry";
        this.sex = true;
    }
}

package myhello;

public class StudentCards
{
    public String schoolCardNumber;
    public String bankCardNumber;
}