[java学习笔记]-注解和反射

最新推荐文章于 2024-07-14 22:18:32 发布
最新推荐文章于 2024-07-14 22:18:32 发布
阅读量278 收藏
点赞数
分类专栏： java基础 文章标签： java 学习 spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/noob0208/article/details/126059243
版权

[java学习笔记]-注解和反射

注解

@Override  规则和约束

@Deprecated 危险的方法，过时的方法

@SuppressWarnings 抑制编译时的警告信息

@Override

public class Test1 {

    //@Override是重写的注解
    
    @Override
    public String toString() {
        return super.toString();
    }
}

@Deprecated

//Deprecated不推孝程序员使用,但是可以使用。或者存在更好的方式
@Deprecated
public static void test(){
    System.out.println("Deprecated");
}

@SuppressWarnings

@SuppressWarnings("all")
public void test1(){
    List list = new ArrayList();
}

元注解

@Documented
@Target()
@Retention()
@Inherited

在这里插入图片描述

定义一个注解

//定义一个注解
public @interface MyAnnotation{
}

把注解的范围限制在方法和类中

//类注解
@MyAnnotation
public class Test2 {
    //方法注解
    @MyAnnotation
    public void test(){
    }
}

//定义一个注解
@Target(value = {ElementType.METHOD,ElementType.TYPE})
@interface MyAnnotation{
}

//Retention表示我们的注解在什么地方还有效。
//runtime>class>source
@Retention(value = RetentionPolicy.RUNTIME)
@interface MyAnnotation{
}

//Documented表示是否将我们的注解生成在JAVAdoc中
@Documented

//子类可以继承父类的注解
@Inherited

自定义注解

关键字 @interface

在这里插入图片描述

多参数

public class Test2 {
    //注解可以显示赋值，如果没有默认值，我们就必须给注解赋值
    @MyAnnotation(name = "Muz1")
    public void test(){
    }
}

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation{
    //注解的参数: 参数类型 + 参数名();
    String name() default "";
    int age() default 0;
    int id() default -1;//如果默认值为-1,代表不存在，indexof,如果找不到就返回-1
    String[] schools() default {"牛马大学","说唱带专"}
}

单参数

public class Test2 {
    //注解可以显示赋值，如果没有默认值，我们就必须给注解赋值
    @MyAnnotation("Muz1")
    public void test(){
    }
}

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation{
    String[] value();
}

参数名是 value() 可以省略注解参数

反射

Reflection (反射)是Java被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法

Class c = Class.forName("java.lang.String");

加载完类之后，在堆内存的方法区中就产生了已个Class类型的对象(一个类只有一个Class对象) ，这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子， 透过这个镜子看到类的结构，所以,我们形象的称之为:反射

在这里插入图片描述

获取一个简单反射

//Test.java

//反射
public class Test {
    public static void main(String[] args) throws ClassNotFoundException {
        //通过反射获取类的Class对象
        Class c1 = Class.forName("com.Reflection.User");
        System.out.println(c1);
    }
}
//实体类 pojo entity
class  User{
    private String name;
    private int id;
    private int age;
    public User(String name, int id, int age) {
        this.name = name;
        this.id = id;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", id=" + id +
                ", age=" + age +
                '}';
    }
}

在这里插入图片描述

可以看到这个类有很多方法

在这里插入图片描述

获取其他的类

//Test.java
public class Test {
    public static void main(String[] args) throws ClassNotFoundException {
        //通过反射获取类的Class对象
        Class c1 = Class.forName("com.Reflection.User");
        System.out.println(c1);

        Class c2 = Class.forName("com.Reflection.User");
        Class c3 = Class.forName("com.Reflection.User");
        Class c4 = Class.forName("com.Reflection.User");
        System.out.println(c2.hashCode());
        System.out.println(c3.hashCode());
        System.out.println(c4.hashCode());
    }
}

......

在这里插入图片描述

一个类在内存中只有一个Class
一个类被加载后，类的整个结构都会被封装在Class对象中。

测试class类的创建方式有哪些

package com.Reflection;
//测试Class类的创建方式有哪些
public class Test1 {
    public static void main(String[] args) throws ClassNotFoundException {
        Person person = new Student();
        System.out.println("这个人是:"+person.name);
        
        //方式一: 通过对象获得
        Class c1 = person.getClass();
        System.out.println(c1.hashCode());
        
        //方式二: forName获得
        Class c2 = Class.forName("com.Reflection.Student");
        System.out.println(c2.hashCode());
        
        //方式三: 通过类名.class获得
        Class c3 = Student.class;
        System.out.println(c3.hashCode());
        
        //方式四: 基本内置类型的包装类都有一个Type属性
        Class c4 = Integer.TYPE;
        System.out.println(c4);

        //获得父类类型
        Class c5 = c1.getSuperclass();
        System.out.println(c5);
    }
}

class Person{
    public String name;
    public Person() {
        this.name = name;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}
class Student extends Person{
    public Student() {
        this.name="学生";
    }
}
class Teacher extends Person{
    public Teacher() {
        this.name="老师";
    }
}

在这里插入图片描述

类型的Class对象

在这里插入图片描述

//Test2.java

package com.Reflection;
import java.lang.annotation.ElementType;

//所有类型的Class
public class Test2 {
    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("void: " + c8);
        System.out.println("Class: " + c9);
    }
}

在这里插入图片描述

类加载内存分析

在这里插入图片描述

小测试

//Test3.java
package com.Reflection;
public class Test3 {
    public static void main(String[] args) {
     A a = new A();
    System.out.println(A.m);
    }
}
class A{
    static {
        System.out.println("A类静态代码块初始化");
        m = 300;
    }
    static int m = 100;
    public A() {
        System.out.println("A类的无参构造器初始化");
    }
}

在这里插入图片描述

在这里插入图片描述

1.加载到内存，会产生一个类对应的class对象
2.链接，链接结束后 m = 0
3.初始化
     <clinit>(){
                 System.out.println("A类静态代码块初始化");
                 m = 300;
                 m = 100;
     }
      m = 100;

分析类的初始化

在这里插入图片描述
Demo

Test4.java

package com.Reflection;
//测试类什么时候会初始化
public class Test4 {
    static {
        System.out.println("main类被加载");
    }
    public static void main(String[] args) {
    }
}
class Father{
    static int b = 2;
    static {
        System.out.println("父类被加载");
    }
}
class Son extends Father{
    static {
        System.out.println("子类被加载");
        m = 300;
    }
    static int m = 100;
    static final int M = 1;
}

然后在main方法中加入

public static void main(String[] args) {
    //1.主动引用
    Son son = new Son();
}

输出

在这里插入图片描述

反射

public static void main(String[] args) throws ClassNotFoundException {
    //反射也会产生主动引用
    Class.forName("com.Reflection.Son");
}

输出

在这里插入图片描述

在这里插入图片描述

不会产生类的引用方法

public static void main(String[] args) {
    //不会产生类的引用方法
    System.out.println(Son.b);
}

在这里插入图片描述

数组

public static void main(String[] args) {
    Son[] array = new Son[5];
}

在这里插入图片描述

常量

public static void main(String[] args) {
    System.out.println(Son.M);
}

在这里插入图片描述

类加载器的作用

在这里插入图片描述

在这里插入图片描述

类加载器

package com.Reflection;
public class Test5 {
    public static void main(String[] args) throws ClassNotFoundException {
        
        //获取系统类的加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);
        
        //获取系统类加载器的父类加载器-->拓展类加载器
        ClassLoader parent = systemClassLoader.getParent();
        System.out.println(parent);
        
        //获取系统类加载器的父类加载器-->根加载器(C/C++)
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);
        
        //测试当前类是哪个加载器
        ClassLoader c1 = Class.forName("com.Reflection.Test5").getClassLoader();
        System.out.println(c1);
        
        //测试JDK内置的类是谁加载的
        ClassLoader c2 = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(c2);
        
        //如何获得系统加载器可以加载的路径
        System.out.println(System.getProperty("java.class.path"));
    }
}

在这里插入图片描述

创建运行时类的对象

之前的 User类

//Test6.java
//获得类的信息
public class Test6 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class c1 = Class.forName("com.Reflection.User");
        //获得类的名字
        System.out.println(c1.getName());
        System.out.println(c1.getSimpleName());
    }
}

在这里插入图片描述

获得类的属性

//Test6.java
public class Test6 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class c1 = Class.forName("com.Reflection.User");

        //获得类的属性
        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);
    }
}

在这里插入图片描述

//Test6.java
public class Test6 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        
        Class c1 = Class.forName("com.Reflection.User");
        
        //获得类的方法
        //获得本类及其父类的全部public方法
        Method[] methods = c1.getMethods();
        
        for (Method method : methods) {
            System.out.println("正常的: " + method);
        }
        
        //获得本类的所有方法
        methods = c1.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println("getDeclaredMethods: " + method);
        }
    }
}

在这里插入图片描述

获得指定的方法

//Test6.java
public class Test6 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
        Class c1 = Class.forName("com.Reflection.User");
        
        //获得指定的方法
        Method getNames = c1.getMethod("getName", null);
        Method setNames = c1.getMethod("setName", String.class);
        System.out.println(getNames);
        System.out.println(setNames);

    }
}

在这里插入图片描述

动态创建对象执行的方法

通过反射动态的创建对象

//Test7.java

//通过反射动态的创建对象
public class Test7 {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        //获得Class对象
        Class c1 = Class.forName("com.Reflection.User");
        //构造一个对象
        User user = (User)c1.newInstance();     //本质上调用了类的无参构造器
        System.out.println(user);
    }
}

在这里插入图片描述

把User类的无参构造器删除

在这里插入图片描述

再次运行报错

在这里插入图片描述

使用newInstance()函数创建函数，必须有无参构造器

通过构造器创建对象

//Test7.java
//通过构造器创建对象
Constructor c2 = c1.getDeclaredConstructor(String.class, int.class, int.class);
Object muz1 = c2.newInstance("Muz1", 1, 0);
System.out.println(muz1);

在这里插入图片描述

通过反射调用普通方法

//通过反射调用普通方法
User user = (User)c1.newInstance();
//通过反射获取一个方法
Method setName = c1.getDeclaredMethod("setName", String.class);
setName.invoke(user,"Muz1");
System.out.println(user.getName());

在这里插入图片描述

通过反射操作属性

//通过反射操作属性
User user1 = (User)c1.newInstance();
Field name = c1.getDeclaredField("name");
name.set(user1,"Muz12");
System.out.println(user1.getName());

在这里插入图片描述

输出报错，因为 User类里面都是 private 方法

在这里插入图片描述

添加一行代码

//name.setAccessible(true);

User user1 = (User)c1.newInstance();
Field name = c1.getDeclaredField("name");

//不能直接操作私有属性，需要关闭程序安全检测
name.setAccessible(true);

name.set(user1,"Muz12");
System.out.println(user1.getName());

在这里插入图片描述

成功输出

性能对比分析

Demo

三种方式的性能表现

package com.Reflection;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
//分析性能问题
public class Test8 {

    //普通方式
    public static void test1(){
        User user = new User();
        long startTime = System.currentTimeMillis();
        for(int i = 0; i < 1000000000; i++){
            user.getName();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("普通方式执行10亿次"+(endTime-startTime)+"ms");
    }
    //反射方式
    public static void test2() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        User user = new User();
        Class c1 = user.getClass();
        Method getName = c1.getDeclaredMethod("getName", null);
        long startTime = System.currentTimeMillis();
        for(int i = 0; i < 1000000000; i++){
            getName.invoke(user,null);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("反射方式执行10亿次"+(endTime-startTime)+"ms");
    }

    //反射方式，关闭检测
    public static void test3() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        User user = new User();
        Class c1 = user.getClass();
        Method getName = c1.getDeclaredMethod("getName", null);
        getName.setAccessible(true);
        long startTime = System.currentTimeMillis();
        for(int i = 0; i < 1000000000; i++){
            getName.invoke(user,null);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("反射方式，关闭检测执行10亿次"+(endTime-startTime)+"ms");
    }
    public static void main(String[] args) throws InvocationTargetException, NoSuchMethodException, IllegalAccessException {
        test1();
        test2();
        test3();
    }
}

在这里插入图片描述

获取泛型信息

在这里插入图片描述

Demo

//Test9.java
package com.Reflection;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;

//通过反射获取泛型
public class Test9 {
    public void test1(Map<String,User> map, List<User> list){
        System.out.println("test1");
    }
    public Map<String,User> test2(){
        System.out.println("test2");
        return null;
    }
    public static void main(String[] args) throws NoSuchMethodException {
        
        Method method = Test9.class.getMethod("test1", Map.class, List.class);
        Type[] genericParameterTypes = method.getGenericParameterTypes();
        for (Type genericParameterType : genericParameterTypes) {
            System.out.println("#"+genericParameterType);
            if(genericParameterType instanceof ParameterizedType){
                Type[] actualTypeArguments = ((ParameterizedType)genericParameterType).getActualTypeArguments();
                for (Type actualTypeArgument : actualTypeArguments) {
                    System.out.println(actualTypeArgument);
                }
            }
        }
        
        System.out.println("========================================");
        
        method = Test9.class.getMethod("test2",null);
        Type genericReturnType = method.getGenericReturnType();
        if(genericReturnType instanceof ParameterizedType){
            Type[] actualTypeArguments = ((ParameterizedType)genericReturnType).getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
                System.out.println(actualTypeArgument);
            }
        }
    }
}

在这里插入图片描述

获取注解信息

Demo

//Test10.java

package com.Reflection;
import java.lang.annotation.*;
//联系反射操作注解
public class Test10 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class c1 = Class.forName("com.Reflection.Student2");
        //通过反射获得注解
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
    }
}

@AbbMuz1("db_Student")
class Student2{
    @BbbMuz1(columnName = "db_id",type = "int" ,length = 10)
    private int id;
    @BbbMuz1(columnName = "db_age",type = "int" ,length = 10)
    private int age;
    @BbbMuz1(columnName = "db_name",type = "varchar" ,length = 10)
    private String name;
    public Student2() {
    }
    public Student2(int id, int age, String name) {
        this.id = id;
        this.age = age;
        this.name = name;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "Student2{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

//类名注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface AbbMuz1{
    String value();
}
//属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface BbbMuz1{
    String columnName();
    String type();
    int length();
}

获得注解输出

在这里插入图片描述

获得注解value的值

在main方法中添加

//获得注解value的值
AbbMuz1 annotation = (AbbMuz1)c1.getAnnotation(AbbMuz1.class);
String value = annotation.value();
System.out.println(value);

在这里插入图片描述

获得类指定的注解

在main方法中添加

//获得类指定的注解
Field f = c1.getDeclaredField("name");
BbbMuz1 annotation1 = f.getAnnotation(BbbMuz1.class);
System.out.println(annotation1.columnName());
System.out.println(annotation1.type());
System.out.println(annotation1.length());

在这里插入图片描述

木拖把
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C# 如何 override ToString方法
更多原创参见个人小站：http://www.donggeitnote.com/
08-03 2247
众所周知，在C#中所有的class和struct都会继承object类。所以，在C#中，每一个object都有一个ToString的方法，他会返回相关的string。比如我们来看一下下面这个例子： int x = 7; Console.WriteLine(x.ToString()); bool xb = true; Console.WriteLine(xb.ToString()); s
【学习笔记】| Java注解与反射
单词沙漠的博客
07-31 164
1、注解 1.1 注解入门 Annotation是从JDK5.0开始引入的新技术. Annotation的作用: 不是程序本身，可以对程序作出解释.(这一点和注释(comment)没什么区别) 可以被其他程序(比如:编译器等)读取. Annotation的格式: 注解是以"@注释名"在代码中存在的,还可以添加一些参数值﹐例如:@SuppressWarnings(value="unchecked"). Annotation在哪里使用? 可以附加在package , class , method ,
Java类中重写toString方法
热门推荐
光阴迷客的知识库
11-24 1万+
默认方法 当需要将一个对象输出到显示器时，通常要调用他的toString()方法，将对象的内容转换为字符串。java中的所有类默认都有一个toString()方法。默认情况下 System.out.println(对象名)或者System.out.println(对象名.toString())输出的是此对象的类名(包名+类名)和此对象对应内存的首地址，默认输出例子： 如果想自定
Java学习笔记001: @Override 注解
weixin_45444673的博客
03-16 257
@Override注解 这个注解规定当前方法必须重写而不是重载 当你想重写时可以选择添加这个注解 ， 当你想重载这个方法时编译器就会产生一条错误: The method doh(Milhouse) of type Bart must override or implement a supertype method 作用是防止程序员粗心导致失误 ...
Java常用类
skdjq666的博客
06-04 345
Java常用类 Object类 toString方法 源码分析： public String toString() { return getClass().getName() + "@" + Integer.toHexString(hashCode()); } toString 用于返回该对象的字符串表示，它的值等于：getClass()+’@’+Interger.toHexString(hashCode()) 。 由于 toString 方法返回的是内存的地址，实际开发中没太大意义，所以我们需要
Java Spring学习笔记
qq_40378172的博客
04-27 320
1、Spring概述 1.1 简介 网站：https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans-factory-scopes spring理念：使现有的技术更加简单，整合了现有的技术框架。 SSH：Struct2 + Spring + Hibernate SSM：SpringMVC + Spring + Mybatis 导包 (maven)： <!-- https://
【Java学习笔记】反射与注解
weixin_44274263的博客
06-03 67
反射是程序在运行过程中动态加载/修改/访问任意类的能力 要实现反射，Class类的存在是很关键的一个点 每一个被加载进程序的类都会被转换成字节码并以Class类的yige
java注解和反射的个人学习笔记
03-01
java注解和反射的个人学习笔记
注解与反射-狂神说Java学习笔记
07-22
在Java编程语言中，注解（Annotation）和反射（Reflection）是两个非常重要的高级特性，它们为程序提供了元数据信息和运行时动态操作类的能力。本文将深入探讨这两个概念及其在实际开发中的应用。 首先，让我们了解...
2022年Java学习笔记-Java课程配套案例.rar
12-19
这份"2022年Java学习笔记-Java课程配套案例.rar"压缩包文件显然是为了帮助学习者深入理解Java编程，通过实践案例来巩固理论知识。下面将详细探讨Java语言的一些核心知识点，并结合压缩包中的案例进行说明。 1. **...
注解和反射机制的学习笔记
03-05
这篇学习笔记将深入探讨这两个主题，帮助开发者更好地理解和运用它们。 首先，我们来了解注解。注解是Java 5引入的一种元数据，它为编译器和JVM提供了关于代码的附加信息。注解并不直接影响程序的运行，但可以被...
java学习笔记 - 反射机制,头大的难
03-16
Java反射机制是Java编程语言中的一个强大特性，它允许运行时的Java程序访问、操作类、接口、字段和方法的信息，甚至能够动态调用方法和创建对象。在深入理解Java反射机制之前，我们先要明白类加载的过程。当Java程序...
重写类的ToString方法
qq_32393261的博客
11-24 1335
所有的类都有一个基类：Object，即所有的类都继承了Object的ToString()方法，如果这个类自己以及其所有基类都并没有使用override方式重写这个方法的话，此类的实例调用的ToString()即Object的ToString()，返回的将是类型的名称字符串。 C#举例： 主函数中 static void Main(string[] args) { ...
类中重写toString函数可以获得你想要的输出格式
苏杭
03-01 365
系统直接生成的toString: @Override public String toString() { return "Person{" + "name='" + name + '\'' + ", sex=" + sex + ", id='" + id + '\'' + ", phone='" + phone + '\'' +
tostring用法
m0_46293802的博客
04-10 235
经常看到的就是 @Override public String toString() { return "point [a=" + a + ", b=" + b + ", s=" + s + "]"; } toString方法是Object中的一个重要方法，它会返回表示对象的一个字符串。 package test2; public class Mywork { public sta...
java基础学习笔记4
UFOO2的博客
10-02 169
java基础学习笔记4 string String 不可变的字符序列：比如要在一个字符串后面追加一串字符，S1=S1+S2;内存里面是重新开辟了一个内存S3，然后把S1,S2分别复制到S3，并没有改变原来的S1,S2。 内存分析： String a1="hello"; String a2="hello"; // a1==a2为true // 因为两个hello是相同的字符串， // 所以在内存里只需要用一个内存就行了，引用指向他即可 a1=new String("hello"); a2=new
实体类 @Override public String toString()的意义
kevin_loving的博客
05-30 8978
System.out.println（entity）必须实现toString方法
java实验3_java 实验3 继承+多态
weixin_39864489的博客
02-12 1233
实验3 继承与多态**类可以实现多个接口 但只有单继承！**1、继承1)、继承语法class子类名extends父类{}2)、构造函数(通过source即可得到)注意： 当子类实例化，首先调用父类构造函数，其次调用子类本身构造函数3)、函数重载:简单来说 相同函数名 参数需求不同 在调用时自动寻找匹配的函数4)、覆盖问题override子类重写了一个从父类继承过来的函数与属性---当使用时就直接...
《JavaSE》---6.＜基础语法（Java三大程序控制结构）＞
最新发布
m0_73456341的博客
07-14 833
本篇博客主要讲解Java基础语法中的三大结构，一种顺序结构、两大分支结构i（if-else、swich-case）、四大循环结构（while、do while、fot、foreach）
"Java基础与加强完整笔记文档
Java基础最全笔记文档涵盖了从基础到加强的内容，包括Java的环境搭建、快速入门、基础语法、面向对象、常用API、集合、IO流、多线程、网络编程、单元测试、反射、注解等多方面的内容，适合想要系统学习Java编程语言...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值