JavaSE基础学习

自己总结的一些常用的IDEA快捷键，有需要的拿走：
ctrl+shift+alt：多行操作
psvm：生成main()方法；
fori：生成for循环；
Ctrl+Alt+v：自动补齐返回值类型
ctrl+o：覆写方法
ctrl+i：实现接口中的方法
ctrl+shift+u：大小写转换
CTRL+SHIFT+Z：取消撤销
Alt＋Insert：生成构造方法、getter、setter
ctrl+y：删除当前行
Ctrl+Shift+J：将选中的行合并成一行
ctrl+g：定位到某一行
Ctrl+Shitft+向下箭头：将光标所在的代码块向下整体移动
Ctrl+Shift+向上箭头：将光标所在的代码块向上整体移动
Alt+Shift+向下箭头：将行向下移动
Alt+Shift+向上箭头：将行向上移动
Ctrl+F：在当前文件中查找
Ctrl+R：替换字符串
Ctrl+Shift+F:在全局文件中查找字符串
Ctrl+Shift+R：在全局中替换字符串
Ctrl+Shift+Enter：自动补齐{}或者分号;
Shift+Enter：在当前行的下方开始新行
Ctrl+Alt+Enter：在当前行的上方插入新行
Ctrl+Delete：删除光标所在至单词结尾处的所有字符

注释

单行注释 //

多行注释/**/

文本注释/***/

标识符

*标识符是大小写敏感的

*标识符开头只能是大小写字母a-z A-Z、下划线_、美元$

*不能使用关键字作为变量名或方法名

*可以使用中文名和拼音，但是最好不要用

*String不是关键字，是类！！！

数据类型

java是强类型语言，所有变量必须先定义后才能使用

java数据类型分为两大类

八大基本数据类型 (很重要！！！)

*整数类型

byte 1字节 1B=8bit

short 2

int 4

long 8

*浮点类型

float 4字节

double 8字节

*字符类型

char 2字节

*boolean类型

true和false只占1个位 1 bit

引用数据类型

*类

*接口

*数组

拓展

*整数拓展：

进制： 二进制0b 十进制 八进制0 十六进制0x

//===================================================

*浮点数拓展：

float 有限 离散 舍入误差 大约 接近但并不等于

double

！最好避免完全使用浮点数进行比较！

银行业务表示？ 钱 要使用BigDecimal 数学工具类 表示

//===================================================

*字符拓展：

所有的字符本质还是数字

编码 Unicode 表(97=a 65=A)

char c2='\u0061';
System.out.println(c2);
//输出的就是a

char c1='a';
System.out.println((int)c1);// 强制转化
//输出的就是 97

转义字符

\t 制表符

\n 换行

…

//===================================================

*布尔值扩展

  boolean flag =true;
    if (flag=true){}//新手
    if (flag){}//老手

类型转换

！运算中不同类型的数据先转换为同一类型，然后进行运算！

//强制类型转换 (类型)变量名 高–低

int b=128;
byte i=(byte) b;//内存溢出
System.out.println(b);
System.out.println(i);

/**输出 128
-128**/

//自动转换 低–高

int b=128;
double i= b;
System.out.println(b);
System.out.println(i);

/**输出
128
128.0**/

*注意点：

1.不能对布尔值进行转换

2.不能把对象类型转换为不相干的类型

3.把高容量转换为低容量用强制转换，反之可自动转换

4.转换的时候可能窜在内存溢出。或者精度问题！！！！！！！

int money = 10_0000_0000;
int year = 20;
int total = year*money;
System.out.println(total);
//输出-1474836480  内存溢出！！！！！！！

int money = 10_0000_0000;
long year = 20L;
long total = year*money;
System.out.println(total);
//输出20000000000

变量

*java变量是程序中最基本的存储单位，其元素包括变量名、变量类型和作用域。

  public class demo04 {
        //类变量 static
        static double salary =2500;
        // 属性：变量
        //实例变量: 从属于对象; 如果不自行初始化，这个类型的默认值 0 0.0
        //布尔值 ：默认为false
        //除了基本类型，其余的默认值都为null；
        String name;
        int age;
        //main方法
        public static void main(String[] args) {
            //局部变量；
            int i=10;
            System.out.println(i);
            //变量类型 变量名字 == new Demo04();
            demo04 demo04=new demo04();
            System.out.println(demo04.age);
            System.out.println(demo04.name);
            //类变量 static
            System.out.println(salary);
    
        }
        //其他方法
        public void add(){
        }
    }

类成员变量：首字母小写和驼峰原则：mouthSalary

局部变量：首字母小写和驼峰原则

常量

final 常量名 = 值;

   //修饰符，不存在先后顺序
    static final double PI = 3.14;
    
    public static void main(String[] args) {
        System.out.println(PI);
    }
    //输出 3.14

常量名：一般使用大写字符和下划线。

类名：首字母大写和驼峰原则：Man, GoodMan

方法名：首字母小写和驼峰原则：run(), runRun()

运算符

优先级()

*算术运算符：+ - * / % ++ –

*赋值运算符： =

*关系运算符：> ,<, >=,<=,==,!=,instanceof

*逻辑运算符：&&,||,!

//以下了解

位运算符：&,|,^,~,>>,<<,>>>

条件运算符: ? ,:

扩展赋值运算符：+=，-=，*=，/=

关于++，-- ：

   public class Demo04 {
        public static void main(String[] args) {
            //++ -- 自增，自减  一元运算符
            int a = 3;
            int b=a++;//a++ 输出 b=3 ，先给b赋值，后自增
            System.out.println(a);
            System.out.println(b);
            int c=++a;//++a 输出 c=5，a先自增，后给c赋值
            System.out.println(a);
            System.out.println(c);
        }
    }

    //Math类 求幂函数3^2:
    double pow = Math.pow(3,2);
    System.out.println(pow);

*逻辑运算

  //逻辑运算符
    public class Demo05 {
        public static void main(String[] args) {
            // 与and   或or   非 取反
            boolean a = true;
            boolean b = false;
    
            System.out.println("a && b: "+(a&&b));
            System.out.println("a || b: "+(a||b));
            System.out.println("! (a && b): "+!(a&&b));
            // 输出 false true true
    
            //短路运算
            int c = 4;
            boolean d = (c<3&&c++<4);
            System.out.println(d);
            System.out.println(c);
            //输出 false 4  说明与运算执行一次错误就停止
    
        }

*位运算

 public class Demo06 {
        public static void main(String[] args) {
            /*
            * A = 0011 1100
            * B = 0000 1101
            *
            * A&B = 0000 1100
            * A|B = 0011 1101
            * A^B = 0011 0001  相同为0，反之为1
            * ~B  = 1111 0010  取反
            *
            * 面试题: 2*8 = 16 2*2*2*2
            * << *2
            * >> /2
            * 效率极高
            *
            * 0000 0000 0
            * 0000 0001 1
            * 0000 1000 8
            * 0001 0000 16
            * */
            System.out.println(2<<3);
        }
    }

 public static void main(String[] args) {
        //扩展运算符
        int a = 10;
        int b = 20;
        a+=b;
        System.out.println(a);//输出30
    	int c = 10;
        int d = 20;
        //字符串连接符 +， String
        System.out.println(""+c+d);//输出 1020
    
        System.out.println(c+d+"");//输出30
    
    }

*三元运算符

  public static void main(String[] args) {
        // x ? y:z
        //如果x为true，则结果为y，否则结果为z
    
        int score = 80;
        String a = score<60?"不及格":"及格";//   必须掌握
        System.out.println(a);
        //输出 及格
    }

包机制

一般用公司域名倒置作为包名； com.baidu.www

JavaDoc

javadoc命令是用来生成自己API文档的。

参数信息

*author作者名

*version版本号

*since指明需要最早使用的jdk版本

*param参数名

*return返回值情况

*throws异常抛出情况

  package com.ml.base;
    /**
     * @author miaolin
     * @version 1.0
     * since 1.8
     */
    public class Doc {
        String name;
    
        /**
         * @author miaolin
         * @param name
         * @return
         * @throws Exception
         */
        public String test(String name) throws Exception{
            return name;
        }
    }

Scanner对象

*通过Scanner类获取用户的输入

next():

不能得到带有空格的字符串

public class Demo01 {
    public static void main(String[] args) {
        //创建一个扫描器对象，用于接收键盘数据
       Scanner scanner = new Scanner(System.in);
        System.out.println("使用next方式接收：");
        //判断用户有没有输入字符串
        if (scanner.hasNext()){
            //使用next方式接收
            String str = scanner.next();
            System.out.println("输出的内容为："+str);
        }
        //凡是属于IOl流的类如果不关闭会一直占用资源，要养成好习惯关闭
        scanner.close();
    }
}

nextLine():

可以获得空白

public class Demo02 {
    public static void main(String[] args) {
        // 从键盘接收数据
        Scanner scanner = new Scanner(System.in);

        System.out.println("使用nextline方式接收：");
        // 判断是否还有输入 *不判断也可以输出
        if(scanner.hasNextLine()){
            String str = scanner.nextLine();
            System.out.println("输出的内容为："+str);
        }

        scanner.close();
    }
}

例题：

  package com.ml.scanner;
    
    import java.util.Scanner;
    
    public class Demo05 {
        public static void main(String[] args) {
            //我们可以输入多个数字，并求其总和与平均值，每输入一个数字用会回车确认，通过输入非数字来结束输入并输出执行结果：
    
            Scanner scanner = new Scanner(System.in);
    
            double sum = 0;
            int m = 0;
            while (scanner.hasNextDouble()){
                double x = scanner.nextDouble();
                sum = sum + x;
                m++;
            }
            System.out.println(m + "个数的和为" + sum);
            System.out.println(m + "个数的平均值为" + (sum/m));
    
        }
    }

自动补全左边语句 ctrl alt v

顺序结构

选择结构

if选择结构

*单选择：

public class ifDemo01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String s =scanner.nextLine();
        //equals：判断字符串是否相等
        if(s.equals("Hello")){
            System.out.println(s);
        }
        System.out.println("End");

        scanner.close();
    }
}

*双选择：

public class IfDemo02 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int s = scanner.nextInt();
        if(s>60){
            System.out.println("yes");
        }else {
            System.out.println("no");
        }

        scanner.close();
    }
}

*多选择：

public class IfDemo03 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int s = scanner.nextInt();

        if(s==100){
            System.out.println("best");
        }else if (s>=60 && s<100){
            System.out.println("a");
        }else if (s<60){
            System.out.println("b");
        }

        scanner.close();

switch多选择结构

switch case 语句判断一个变量与一系列值中某个值是否相等，每个值被称为一个分支

  public class SwitchDemo01 {
        public static void main(String[] args) {
            char grade = 'C';
            switch (grade){
                case 'A':
                    System.out.println("优秀");
                    break;
                case 'B':
                    System.out.println("良好");
                    break;
                case 'C':
                    System.out.println("不及格");
                    break;
                default:
                    System.out.println("未知等级");
                    break;
            }
        }
    }

java7之后switch支持字符串比较

while循环

两个例子：

 public class WhileDemo01 {
        public static void main(String[] args) {
            //输出1-100
    
            int i = 0;
            while (i<100){
                i++;
                System.out.println(i);
            }
        }
    }

    public class WhileDemo02 {
        public static void main(String[] args) {
            int i = 0;
            int sum = 0;
            while (i<=100){
                sum = sum + i;
                i++;
            }
            System.out.println(sum);
        }
    }

DoWhile

public static void main(String[] args) {
        int i = 0;
        int sum = 0;
        do{
            sum = sum + i;
            i++;
        }while(i<=100);
        System.out.println(sum);
    }

For循环（重要）

```java
   public class ForDemo01 {
        public static void main(String[] args) {
            int a = 1;
            while (a<=100){
                System.out.println(a);
                a+=2;
            }
            System.out.println("while循环结束");
            for(int i=1;i<=100;i++)
            {
                System.out.println(i);
            }
            System.out.println("for循环结束");
        }
    }

增强for循环

public static void main(String[] args) {
        int[] numbers = {10,20,30,40};//定义一个数组

        //遍历数组的元素
        for(int x:numbers){
            System.out.println(x);
        }
    }

方法

   public class Demo01 {
        //main 方法
        public static void main(String[] args) {
    //        int sum = add(1,2);
    //        System.out.println(sum);
            test();
        }
        //加法
        public static int add(int a,int b){
            return a+b;
        }
        //定义一个打印三角形方法
        public static void test(){
            //打印三角形
            for (int i = 1; i <= 5; i++) {
                for (int j = 5; j >= i; j--) {
                    System.out.print(" ");
                }
                for (int j = 1; j <= i; j++) {
                    System.out.print("*");
                }
                for (int j = 1; j < i; j++) {
                    System.out.print("*");
                }
                System.out.println();
            }
        }
       
    }

定义

调用

java都是值传递

值传递(pass by value)：在调用函数时，将实际参数复制一份传递到函数中，这样在函数中对参数进行修改，就不会影响到原来的实际参数；

引用传递(pass by reference):在调用函数时，将实际参数的地址直接传递到函数中。这样在函数中对参数进行的修改，就会影响到实际参数；

重载

命令行传参

 public class Demo03 {
        public static void main(String[] args) {
            //args.length 数组长度
            for (int i = 0; i < args.length; i++) {
                System.out.println("args["+i+"]:"+args[i]);
            }
        }
    }

可变参数

   public class Demo04 {
        public static void main(String[] args) {
    
            Demo04 demo04 = new Demo04();
            demo04.test(1);
    
        }
        public void test(int... i){
            System.out.println(i[0]);
        }
    }

递归⭐

计算器

   import java.util.Scanner;
    
    //计算器
    public class Demo07 {
        static Scanner scanner = new Scanner(System.in);
        public static void main(String[] args) {
            boolean flag = true;
            int i= 1;//判断次数
            while (flag){
                if (i==1){//第一次使用计算器
                    System.out.println("第一次使用计算器");
                    calculator();
                    System.out.println("=============我是一个分隔符===============");
                    i++;//次数+1
                }else {//非第一次使用计算器
                    System.out.print("继续使用计算机？（x：继续，y：停止）");
                    String next = scanner.next();
                    if (next.equals("x")) {//判断是否继续使用计算器
                        calculator();
                        System.out.println("=============我是一个分隔符===============");
                    } else if (next.equals("y")) {
                        flag = false;
                        System.out.println("停止使用计算器");
                    }
                }        }
            scanner.close();
        }
        public static void calculator(){
    
            System.out.print("请输入第一个数字：");
            double num1 = scanner.nextDouble();
    
            System.out.print("请输入运算符：");
            String ope = scanner.next();
    
            System.out.print("请输入第二个数字：");
            double num2 = scanner.nextDouble();
    
            switch (ope){
                case "+":
                    add(num1,num2);
                    break;
                case "-":
                    minus(num1,num2);
                    break;
                case "/":
                    division(num1,num2);
                    break;
                case "*":
                    mul(num1,num2);
                    break;
                default:
                    System.out.println("请输入合法的运算符 + ，- ，* ，/");
                    break;
    
            }
        }
        public static void add(double num1,double num2){
            double result = num1 + num2;
            System.out.println(num1 + "+" + num2 + "=" + result);
        }
        public static void minus(double num1,double num2){
            double result = num1 - num2;
            System.out.println(num1+"-"+num2+"="+result);
        }
        public static void division(double num1,double num2){
    
            if (num2==0){//判断分母num2为0
                System.out.println("分母num2不能为0");
                return;
            }else {
                double result = num1 / num2;
                System.out.println(num1 + "/" + num2 + "=" + result);
            }
        }
        public static void mul(double num1,double num2){
            double result = num1 * num2;
            System.out.println(num1+"*"+num2+"="+result);
        }
    
    }

数组

定义

声明创建

内存分析

三种初始化

四个基本特点

数组边界

多维数组

Arrays类

冒泡排序

稀疏数组（拓展）

 public class ArrayDemo08 {
        public static void main(String[] args) {
            //1.创建一个二维数组 11*11 0：没有棋子 1：黑棋 2：白棋
            int[][] array1 = new int[11][11];
            array1[1][2] = 1;
            array1[2][3] = 2;
            //输出原始的数组
            System.out.println("输出原始的数组");
            for (int[] ints : array1) {
                for (int anInt : ints) {
                    System.out.print(anInt+"\t");
                }
                System.out.println();
            }
            //转换为稀疏数组保存
            //获取有效值的个数
            int sum =0;
            for (int i = 0; i < 11; i++) {
                for (int j = 0; j < 11; j++) {
                    if(array1[i][j]!=0){
                        sum++;
                    }
                }
            }
            System.out.println("有效值的个数："+sum);
            //2.创建一个稀疏数组的数组
            int[][] array2 = new int[sum+1][3];
            array2[0][0] = 11;
            array2[0][1] = 11;
            array2[0][2] = sum;
    
            //遍历二维数组，将非零的值，存放在稀疏数组
            int count = 0;
            for (int i = 0; i < array1.length; i++) {
                for (int j = 0; j < array1[i].length; j++) {
                    if(array1[i][j]!=0){
                        count++;
                        array2[count][0] = i;
                        array2[count][1] = j;
                        array2[count][2] = array1[i][j];
                    }
                }
            }
            //输出稀疏数组
            System.out.println("稀疏数组");
            for (int i = 0; i < array2.length; i++) {
                System.out.println(array2[i][0]+"\t"
                        +array2[i][1]+"\t"
                        +array2[i][2]+"\t");
            }
        }
    }

面向对象

面向过程&面向对象

回顾方法及加深

值传递和引用传递

值传递

  //值传递
    public class Demo04 {
        public static void main(String[] args) {
            int a =1;
            System.out.println(a);//1
            Demo04.change(a);
            System.out.println(a);//1
        }
    
        //返回值为空
        public static void change(int a){
            a = 10;
        }
    
    }

引用传递

  //引用传递：对象，本质还是值传递
    public class Demo05 {
        public static void main(String[] args) {
            Person person = new Person();
            System.out.println(person.name);//null
            Demo05.change(person);
            System.out.println(person.name);//ml
    
        }
        public static void change(Person person){
            person.name = "ml";
        }
    
    
    }
    class Person{
        String name;
    }

类与对象的关系

创建与初始化对象

Student b = new Student();// 类型 对象名 = new 类；

构造器

  public class Person {
    
        //一个类即使什么也不写，他也会存在一个方法。
        //现实的定义构造器
    
        String name;
    
        //构造器
        //1.使用new关键字，本质是在调用构造器
        //2.用来初始化值
        public Person(){
            this.name = "ml";
        }
    
        //有参构造：一旦定义了有参构造，无参就必须显示定义
        public Person(String name){
            this.name = name;
        }
    
    }

    public class Application {
    
        public static void main(String[] args) {
    
            //new 实例化了一个对象
            Person person = new Person();
    
            System.out.println(person.name);//输出结果是 ml
        }
    }

alt + insert 自动生成构造器

构造器：
1.和类名相同
2.没有返回值
作用：
1.new 本质在调用构造方法
2.初始化对象的值
注意点：
定义有参构造后，必须使用无参构造，显示定义的一个无参构造
快捷键：
Alt + Insert

创建对象内存分析

public class Pet {
    public String name;
    public int age;

    public void shout(){
        System.out.println("叫了一声");
    }
}

  public class Application {
        public static void main(String[] args) {
            Pet dog = new Pet();
            dog.name = "zsz";
            dog.age = 5;
            dog.shout();
            System.out.println(dog.name);
            System.out.println(dog.age);
    
            Pet cat = new Pet();
        }
    
    }

小结

java三大特征

封装

 //类  private：私有
    public class Student {
        private String name;//名字
        private int id;//学号
        private char sex;//性别
        private int age;
        //提供一些可以操作这个属性的方法
        //提供一些public的get、set方法
    
        //get 获得这个数据
        public String getName(){
            return this.name;
        }
        ///set 这个个数据设置值
        public void setName(String name){
            this.name = name;
        }
    
    
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            if (age>120 || age<0){
                this.age = 3;//不合法
            }else {
                this.age = age;
    
            }
        }
    }

/**
    1.提高程序的安全性，保护数据
    2.隐藏代码的细节
    3.统一接口
    4.系统可维护性增加了
  **/
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();

        s1.setName("ml");
        System.out.println(s1.getName());
        s1.setAge(90);
        System.out.println(s1.getAge());
    }

}

Alt + Insert 自获生成get/set方法

继承

Super详解

代码见opp.demo05

super注意点：

1.super调用父类的构造方法，必须在构造方法的第一个！
2.super必须只能出现在子类的方法或者构造方法中！
3.super 和 this 不能同时调用构造方法！

VS this：

代表的对象不同：
    this：本身调用者这个对象
    super：代表父类对象的引用

前提：
    this：没有继承也可以使用
    super：只能在继承条件才可以使用

构造方法：
    this():：本类的构造
    suepr()：父类的构造

方法重写

代码见opp.demo06

重写：需要有继承关系，子类重写父类的方法！
1、方法名必须相同
2、参数列表必须相同
3、修饰符：范围可以扩大但不能缩小 Public>Protected>Default>Private
4、抛出的异常范围可以被缩小，但不能扩大  ClassNotFoundException --> Exception(大)

重写：子类的方法必须和父类一直，方法体不同！

为什么要重写：
    父类的功能，子类不一定需要，或者不一定满足！
    Alt + Insert：override

多态

代码见opp.demo07

多态注意事项：
1.多态是方法的多态，属性没有多态
2.父类和子类，有联系，类型转换异常
3.存在条件：继承关系，方法需要重写，弗父类引用指向子类对象！ Faher a = new Son()；
    不能重写的方法：
    1.static 方法，属于类，不属于实例
    2.final 常量；
    3.private方法；

System.out.println(X instanceof Y);//可以用来检查是否是父子类型

类型转换

//类型之间的转换： 父  子
//子类转换为父类，可能丢失自己的本来的一些方法！
Person a = new Student();
((Student) a).go();//父转子，高转低

Student b = new Student();
Person person = b;//低转高

static关键字详解

代码见opp.demo08

执行速度：静态代码块>匿名代码块>构造方法
静态代码块只能执行一次

抽象类

代码见opp.demo09

//abstract 抽象类
public abstract class Action {

    //abstract 抽象方法，只有方法名字没有方法的实现！
    public abstract void doSomething();

    /**
     1.不能new一个抽象类，只能靠子类去实现它
     2.抽象类可以写普通方法
     3.抽象方法必须写在抽象类中
     **/
}

如果父类是抽象类，子类必须实现父类的所有方法！ 除非子类也是抽象类new存在构造器吗？

接口

代码见opp.demo10

接口的本质是契约

作用：

1.约束
2.定义一些方法，让不同的人实现
3.接口不能被实例化，接口中没有构造方法
4.implements可以实现多个接口
5.必须重写接口中的方法

内部类

异常机制

Error和Exception

异常处理机制

int a = 1;
int b = 0;

try {//try监控区域
    System.out.println(a/b);
}catch (ArithmeticException e){//catch(想要捕获的异常类型！) 捕获异常
    System.out.println("程序出现异常");
}finally {//finally 处理善后工作
    System.out.println("finally");
}
//finally 可以不要。 假设IO、资源需要关闭，用到finally

Ctrl + Alt +T //自动生成捕获异常代码

public static void main(String[] args) {
        new Test().test(1,0);

    }
    //假设方法中处理不了某个异常，可以再方法中主动抛出异常
    public void test(int a,int b) throws ArithmeticException{
        if(b==0){
            throw new ArithmeticException();//主动抛出异常,一般在方法中使用
        }
        System.out.println(a/b);
    }
}

自定义异常

代码见exception.demo02

多线程

Thread类

package com.lesson.demo01;

import javax.swing.*;

//创建县城方式一：继承Thread类，重写run()方法，调用start开启线程

//总结：注意线程开启不一定立即执行，由CPU调度执行
public class TestThread1 extends Thread{
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("jjjjjjjjjjjjjjjjjjjj"+i);
        }
    }

    public static void main(String[] args) {
        //main线程，主线程

        //创建一个线程对象
        TestThread1 testThread1 = new TestThread1();
        //调用start()开启线程
        testThread1.start();

        for (int i = 0; i < 2000; i++) {
            System.out.println("mm"+i);
        }
    }
}

注解

com.annotation

package com.annotation;

//什么是注解
public class Test01 extends Object{
    //@Override 重写注解
    @Override
    public String toString(){
        return super.toString();
    }
}

//测试元注解
@MyAnnotation
public class Test02 {

}
//定义一个注解
//Target 表示我们的注解可以用在哪些地方
@Target(value = {ElementType.METHOD,ElementType.TYPE})
//Retention 表示我们的注解在什么地方还有效
@Retention(value = RetentionPolicy.RUNTIME)    
//Documented 表示是否将我们的注解生成在JAVAdoc中
@Documented
//Inherited 子类可以继承父类的注解
@Inherited

@interface MyAnnotation{

 package com.annotation;
    
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    //自定义注解
    public class Test03 {
        //注解可以显示赋值，如果没有默认值，我们必须给注解赋值
        @MyAnnotation2(name = "ml",age = 18)
        public void test(){
    
        }
        @MyAnnotation3("miaolin")
        public void test2(){
    
        }
    }
    
    @Target({ElementType.TYPE,ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    
    @interface MyAnnotation2{
        //注解的参数：参数类型 + 参数名()
        String name() default "";
        int age() default 0;
        int id() default -1; //-1代表不存在
        String[] schools() default "山理工";
    }
    
    @Target({ElementType.TYPE,ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    
    @interface MyAnnotation3{
       String value();
    }

反射

com.reflection 代码

   System.out.println(person.name);
    //方法1：通过对象获得
    Class c1 = person.getClass();
    System.out.println(c1.hashCode());
    //方法2： forname获得
    Class c2 = Class.forName("com.reflection.Student");
    System.out.println(c2.hashCode());
    //方式3：类名.class
    Class c3 = Student.class;
    System.out.println(c3.hashCode());

  package com.reflection;
    
    import java.lang.annotation.ElementType;
    
    //所有类型的Class
    public class Test04 {
        public static void main(String[] args) {
            Class c1 = Object.class;//类
            Class c2 = Comparable.class;//接口
            Class c3 = String[].class;//一维数组
            Class c4 = int[][].class;//二维数组
            Class c5 = Override.class;//注解
            Class c6 = ElementType.class;//枚举
            Class c7 = Integer.class;//基本数据类型
            Class c8 = void.class;//void
            Class c9 = Class.class;//Class
    
            System.out.println(c1);
            System.out.println(c2);
            System.out.println(c3);
            System.out.println(c4);
            System.out.println(c5);
            System.out.println(c6);
            System.out.println(c7);
            System.out.println(c8);
            System.out.println(c9);
    
            //只要元素类型和维度一样，就是同一个Class
            int[][] a = new int[10][10];
            int[][] b = new int[101][101];
            System.out.println(a.getClass().hashCode());
            System.out.println(b.getClass().hashCode());
    
        }
    }

  package com.reflection;
    
    import java.lang.reflect.Field;
    import java.lang.reflect.Method;
    
    public class Test08 {
        public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
            Class c1 = Class.forName("com.reflection.User");
    
            //获得类的名字
            System.out.println(c1.getName());//获取包名+类名
            System.out.println(c1.getSimpleName());//获取类名
    
            //获得类的属性
            System.out.println("=====================");
            Field[] fields = c1.getFields();//只能找到public属性
            fields = c1.getDeclaredFields();//找到全部属性
            for (Field field : fields) {
                System.out.println(field);
            }
            //获得指定属性的值
            Field name = c1.getDeclaredField("name");
            System.out.println(name);
    
            //获得类的方法
            System.out.println("========================");
            Method[] methods = c1.getMethods(); //获得本类及其父类的所有public方法
            for (Method method : methods) {
                System.out.println("正常的:"+method);
            }
            methods = c1.getDeclaredMethods();//获得本类的所有方法
    
            for (Method method : methods) {
                System.out.println("getDeclaredMethods"+method);
            }
    
    
        }
    
    }