java（1）

//数组类型
public class Main {

	public static void main(String[] args) 
	{
		int[] ns = new int[5];
		System.out.println(ns[0]);
	}

}

package hello;

//输入程序

import java.util.Scanner;

public class hello
{
    public static void main(String[] args)
    {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入名字");
        String name = scanner.nextLine();
        System.out.println("请输入年龄：");
        int age = scanner.nextInt();
        System.out.printf("Hi, %s, you are %d\n", name, age);
    	//遍历数组
        int[] ns = {1,3,4};
        int size = ns.length;
        for (int i = 0; i < size; i++)
        {
            System.out.println(ns[i]);
        }
        //第二种方法 foreach
        for (int n: ns)
        {
            System.out.println(n);
        }
        //第三种方法
        System.out.println(Arrays.toString(ns));

        //倒序输出
         for (int i = size - 1; i >= 0; i--)
         {
             System.out.println(ns[i]);
         }
         
        //数组排序
        int[] ns = {1,3,4};
        int size = ns.length;
        Arrays.sort(ns);
        System.out.println(Arrays.toString(ns));
	
        * */
        /*
        * java 引用对象，一切标识符都是对于一个对象的引用，
        * java默认是强引用，可以通过手动置null使JVM适时回收对象
        * */

		
        //继承, extends 实现继承
        class Person
        {
            protected String name;
            protected int age;

            public Person(String nameIn, int ageIn)
            {

            }
        }

        class Student extends Person
        {
            private int score;

            public Student(String nameIn, int ageIn, int scoreIn)
            {
                super(nameIn, ageIn);
                score = scoreIn;
            }


            public String hello()
            {
                return "hello,"+ super.name;
            }

        }
        //super 表示父类，子类引用父类的字段时使用super.xxx
        //java会自动添加上 extends Object

        //判断是否是某种类型 instanceof
    }
}

class Person
{
    final String name;

    public Person(String nameIn)
    {
        name = nameIn;
    }

    @Override
    public String toString()
    {
        return "name:" + name;
    }

    @Override
    public boolean equals(Object o)
    {
        if (o instanceof Person)
        {
            Person p = (Person) o;
            return (p.name.equals(this.name));
        }
        return false;
    }

    @Override
    public int hashCode()
    {
        return this.name.hashCode();
    }

    public final String hello()
    {
        return "hello"+name;
    }
}

class Student extends Person
{
    public Student(String nameIn) {
        super(nameIn);
    }

    public void hel()
    {
        String name =  super.name;
    }

}

class Income
{
    protected double income;

    public Income(double incomeIn)
    {
        income = incomeIn;
    }


    public double getTax()
    {
        return income * 0.1;
    }
}

class Salary extends Income
{
    public Salary(double incomeIn) {
        super(incomeIn);
    }

    @Override
    public double getTax()
    {
        if (income < 5000)
            return 0;
        return (income - 5000) * 0.2;
    }
}


        //多态
        // @Override 让编译器检车是否进行了正确的覆写
        Income[] incomes = new Income[] {
                new Income(2000)

        };
        //标记为final，不允许父类对子类覆写
// 抽象类

abstract class Person
{
    public abstract void run();
}


//接口， 比抽象类还要抽象的纯抽象接口,不能有字段，接口默认所有方法是public abstract的
//继承只能继承一个类，接口可以实现多个interface，在接口中可以定义default方法
//接口也可以继承接口
interface Hello
{
    void hello();
}


interface Person extends Hello
{
    default void run()
    {

    }
    String getName();
}

class Student implements Person
{
    private String name;

    @Override
    public void run()
    {

    }

    @Override
    public String getName()
    {
        return null;
    }

    @Override
    public void hello()
    {

    }
}


//包名.类名
//包作用域，没有使用private public protected 就是包作用域
// 会自动import java.lang.* 和 import package 的其他 class

//Java 支持嵌套类
//一个.java文件只能含有一个public类，但可以包括多个非public类，如果有public类，文件名必须和public的类名相同

//jar包jar包相当于目录，可以包含很多.class文件，方便下载和使用；
/*
jar包实际上就是一个zip格式的压缩文件，而jar包相当于目录。如果我们要执行一个jar包的class，就可以把jar包放到classpath中：

java -cp ./hello.jar abc.xyz.Hello
这样JVM会自动在hello.jar文件里去搜索某个类。

那么问题来了：如何创建jar包？

因为jar包就是zip包，所以，直接在资源管理器中，找到正确的目录，点击右键，
在弹出的快捷菜单中选择“发送到”，“压缩(zipped)文件夹”，就制作了一个zip文件。
然后，把后缀从.zip改为.jar，一个jar包就创建成功。
 */
/*
模块：
jar包只是将class存放起来了，并不关心class之间的依赖，模块是 jmod，
模块之间的依赖关系写到了 module-info.class文件中，所有的模块都直接或间接的依赖java.base模块
 */
/*
//StringBuilder是一个可变对象，预分配缓冲区
StringBuilder sb = new StringBuilder(1024);// 预分配空间,
for (int i = 0; i < 10; i++)
{
    sb.append("hello").append(i).insert(0,"hello");
}
字符串比较必须使用equals()
去除首尾空白字符使用trim()
替换字串e.g.
String s = "hello";
s.replace('l', 'w'); // "hewwo"，所有字符'l'被替换为'w'
//拼接字符串
String[] s = {"A","B"};
String str = String.join("***",s);
//类型转换
String.valueOf(123); // "123"
String.valueOf(true); // "true"
int n = Integer.parseInt("123");
//String && char[] 相互转化
char[] cs = "hello".toCharArray(); // String->char[]
String st = new String(cs); //char[]->String
//编码转换
byte[] b1 = "hello".getBytes("GBK");
String s1 = new String(b1, StandardCharsets.UTF_8);
//String 和 char是以unicode编码的
 */
/*

    static String buildSelectSql(String table, String[] fields)
    {
        // TODO:
        var s = String.join(", ", fields);
        String str = "SELECT " + s.toString() + " FROM " + table;

        return str;
    }
       String[] fields = { "name", "position", "salary" };
        String table = "employee";
        String select = buildSelectSql(table, fields);
        System.out.println(select);
        System.out.println("SELECT name, position, salary FROM employee".equals(select) ?
                "测试成功" : "测试失败");

        //StringJoiner
        String[] names = {"bob", "alice"};
        StringJoiner sj = new StringJoiner(", ", "hello", "!");
        for (String name : names)
        {
            sj.add(name);
        }
        System.out.println(sj.toString());
 */


        int i = 100;
        Integer n1 = new Integer(i);
        Integer n2 = Integer.valueOf(i);
        Integer n3 = Integer.valueOf("100");
        //int x = n1.intValue();
        //java 编译器可以帮自动在int 和 Integer之间转型
        Integer n = 100; // 编译器自动使用Integer.valueOf(int)
        int x = n; // 编译器自动使用Integer.intValue()
        // 把int 变成 Integer 的赋值写法，称为自动装箱，把 Integer 变成 int 的写法称为自动拆箱
        // Integer 是int 的包装类,由int 基本类型变成了引用类型，
        // 由于被声明为final，所以是不变类，引用类型——比较使用equals
        // 我们把能创建“新”对象的静态方法称为静态工厂方法。Integer.valueOf()就是静态工厂方法，
        // 它尽可能地返回缓存的实例以节省内存。
        // 创建新对象时，优先选用静态工厂方法而不是new操作符
        // 所有整数浮点数都继承自Number
        // 向上转型为Number:
        Number num = new Integer(999);
        // 获取byte, int, long, float, double:
        byte b = num.byteValue();
        //int n = num.intValue();
        long ln = num.longValue();
        float f = num.floatValue();
        double d = num.doubleValue();

/*
javabean 是一种符合命名规范的class，通过getter和setter定义属性

class Person
{
    public String getName()
    {
        return name;
    }

    public void setName(String name)
    {
        this.name = name;
    }

    String name;
}
 */

//枚举类，enum 继承 Enum
    enum Weekday
    {
        Sun(0, "星期天"), Mon(1, "星期一");

        public final int dayValue;
        private final String chinese;

        Weekday(int dayValue, String chinese) {
            this.dayValue = dayValue;
            this.chinese = chinese;
        }
        //toString 本来和 name 都是相仿的，都是返回名字，所以通过override
        @Override
        public String toString()
        {
            return this.chinese;
        }
    }

    Weekday day = Weekday.Sun;
    String s = Weekday.Sun.name(); //"Sun"
    int n = Weekday.Mon.ordinal(); // 1 返回定义的常量的顺序
    //enum && switch
        switch(day)
    {
        case Mon:
            System.out.println(day.toString());
            break;
        case Sun:
            System.out.println(day.toString());
            break;
        default:
            throw new RuntimeException("不是周一和周日");
    }