阿小冷学计算机（6）

最新推荐文章于 2024-08-03 21:02:21 发布
最新推荐文章于 2024-08-03 21:02:21 发布
阅读量170 收藏
点赞数
文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47026948/article/details/122523509
版权

注解与反射

文章内容来自b站up主，遇见狂神说的视频
本文使来自作者的笔记，留做后面自己观看

注解

（Annotation 注解）
1、什么是注解？
Annotation是从JDK5.0开始引入的新技术

Annotation的作用：

  • 不是程序本身，可以对程序作出解释，
  • 可以被其他程序（比如：编译器等）读取

Annotation的格式：

  • 注解是以 “@注释名”在代码中存在的，还可以添加一些参数值，例如：
  • @SuppressWarnings(value=“unchecked”).

Annatation在哪里使用？

  • 可以附加在package，class，method，field等上面，相当于给他们添加了额外的辅助信息，我们可以通过反射机制编程实现对这些数据的访问

内置注解

![](https://img-blog.csdnimg.cn/d75f23edd9224e9c9c307853db3f85f5.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAcXFfNDcwMjY5NDg=,size_20,color_FFFFFF,t_70,g_se,x_16

package com.axiaoleng1;

import java.util.ArrayList;
import java.util.List;

@SuppressWarnings("all")
public class Test01 extends Object {
    //@Override 重写的注解
    @Override
    public String toString(){
        return super.toString();
    }
    //Deprecated 不推荐程序员使用，但是可以使用，或者存在更好的方式
    @Deprecated
    public static void test(){
        System.out.println("Deprecated");
    }


    public  void test02(){
        List list = new ArrayList();
    }

    public static void main(String[] args) {
        test();
    }
}

元注解

在这里插入图片描述

package com.axiaoleng1;

import java.lang.annotation.*;

@MyAnnotation
public class Test02 {

    public void test(){

    }
}

//定义一个注解
//Target 表示我们的注解可以用在哪些地方
@Target(value = {ElementType.METHOD,ElementType.TYPE})

//Retention 表示我们的注解在什么地方还有效
// runtime>class>sources
@Retention(value = RetentionPolicy.RUNTIME)
//Documented 表示是否将我们的注解生成在JAVAdoc中
@Documented

//Inherited 子类可以继承父类的注解
@Inherited
@interface MyAnnotation{
}

自定义注解

在这里插入图片描述

package com.axiaoleng1;

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 = "阿冷",schools = {"湖南理工","湖理"})
    @MyAnnotation2()
    public void test(){}

    @MyAnnotation3("阿冷")
    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{
    //一个参数，建议用value命名
    String value();
}

反射（Reflection）—动态

  • 静态语言 vs 动态语言
    在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述
  • 反射相关的主要API
    java.lang.Class: 代表一个类
    java.lang.reflect.Method: 代表类的方法
    java.lang.reflect.Field: 代表类的成员变量
    java.lang.reflect.Constructor: 代表类的构造器

在这里插入图片描述

package com.axiaoleng1;

//什么叫反射
public class Test04  extends Object{
    public static void main(String[] args) throws ClassNotFoundException {
        //通过反射类获取类的Class对象
        Class c1 = Class.forName("com.axiaoleng1.User");
        System.out.println(c1);

        Class c2 = Class.forName("com.axiaoleng1.User");
        Class c3 = Class.forName("com.axiaoleng1.User");
        Class c4 = Class.forName("com.axiaoleng1.User");

        //一个类在内存中只有一个Class对象
        //一个类被加载后，类的整个结构都会被封装在Class对象中
        System.out.println(c2.hashCode());
        System.out.println(c3.hashCode());
        System.out.println(c4.hashCode());
    }
}

//实体类
class User{
    private String name;
    private int id;
    private int age;

    public User(){
    }

    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;
    }
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

package com.axiaoleng1;

public class Test05 {
    public static void main(String[] args) throws Exception{
        Person person = new Student();
        System.out.println("这个人是："+person.name);

        //方式一 ：通过对象获得
        Class c1 = person.getClass();
        System.out.println(c1.hashCode());

        //方式二 ： forname获得
        Class c2 = Class.forName("com.axiaoleng1.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(){
    }

    public Person(String name){
        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对象
    class ：外部类，成员（成员内部类、静态内部类）、局部内部类、匿名内部类
    interface ：接口
    [ ] : 数组
    enum ：枚举
    annotation ：注解@interface
    primitive type : 基本数据类型
    void
package com.axiaoleng1;

import java.lang.annotation.ElementType;

//所有类型的Class
public class Test06 {
    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];
        int[][] a1= new int[5][5];
        int[] b = new int[100];
        System.out.println(a1.getClass().hashCode());
        System.out.println(a.getClass().hashCode());
        System.out.println(b.getClass().hashCode());
    }
}
  • Java内存分析

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述1、加载到内存，会产生一个类对应的Class对象
2、链接，链接结束后 m = 0
3、初始化
(){
System.out.println(“A类静态代码块初始化”);
m=300;
m=100;
}

package com.axiaoleng1;

import jdk.internal.dynalink.beans.StaticClass;

public class Test07 {
    public static void main(String[] args) {
        A a = new A();
        System.out.println(a.m);
        System.out.println(a.b);
    }
}

class A {
    static {
        System.out.println("A类静态代码块初始化");
        m = 300;
    }

    static int m = 100;

    static int b = 200;
    static {
        System.out.println("A类静态代码块初始话2");
        b = 500;
    }

    public A(){
        System.out.println("A类的无参构造初始化");
    }
}

在这里插入图片描述

  • 分析类的初始化

在这里插入图片描述

package com.axiaoleng1;

public class Test08 {

    static{
        System.out.println("Main类被加载");
    }
    public static void main(String[] args)  throws Exception{
        //Father m1 = new Father();

        //1、主动引用
        //Son m2 = new Son();

        //System.out.println(m1.b);
        //System.out.println(m2.m);

        //反射也会产生主动引用
        //Class.forName("com.axiaoleng1.Son");

        //不会产生类的引用的方法
        //System.out.println(Son.b);

        //Son[] array = new Son[5];

        System.out.println(Son.M);
    }
}

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;
}
  • 类加载器

在这里插入图片描述
在这里插入图片描述

package com.axiaoleng1;

public class Test09 {
    public static void main(String[] args) throws Exception {

        //获取系统类的加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);

        //获取系统类加载器的父类加载器-->扩展类加载器
        ClassLoader parent = systemClassLoader.getParent();
        System.out.println(parent);

        //获取扩展类加载器的父类加载器-->根加载器
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);

        //测试当前类是哪个加载器加载的
        ClassLoader classLoader = Class.forName("com.axiaoleng1.Test09").getClassLoader();
        System.out.println(classLoader);

        //测试JDK内置的类是谁加载的
        classLoader = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(classLoader);

        //如何获得系统类加载器可以加载的路径
        System.out.println(System.getProperty("java.class.path"));
    }
}

双亲委派机制

  • 获取类的运行时类的完整结构
package com.axiaoleng1;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class Test10 {
    public static void main(String[] args) throws Exception{
        Class c1 = Class.forName("com.axiaoleng1.User");

        //获得类的名字
        System.out.println(c1.getName());    //获得包名 + 类名
        System.out.println(c1.getSimpleName());  //获得类名

        //获得类的属性
        System.out.println("=============");
        Field[] fields = c1.getFields();  //只能找到public属性
//        for(Field field : fields){
//            System.out.println(field);
//        }

        fields = c1.getDeclaredFields();   //找到全部的属性
        for(Field field : fields){
            System.out.println(field);
        }

        //获得指定属性的值
       // Field  name=c1.getField("name");
        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);
        }

        //获得指定方法
        //重载
        Method getName = c1.getMethod("getName", null);
        Method setName = c1.getMethod("setName", String.class);
        System.out.println(getName);
        System.out.println(setName);

        //获得指定的构造器
        System.out.println("=============");
        Constructor[] constructors = c1.getConstructors();
        for(Constructor constructor : constructors){  //只能找到public构造器
            System.out.println(constructor);
        }

        constructors = c1.getDeclaredConstructors();
        for(Constructor constructor : constructors){  //本类全部构造器
            System.out.println(constructor);
        }

        //获得指定的构造器
        Constructor declaredConstructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
        System.out.println("指定"+declaredConstructor);
    }
}
  • 动态创建对象执行方法

在这里插入图片描述
在这里插入图片描述

  • 两个重点

Object invoke(Object obj,Object … args)
1、Object对应原方法的返回值，若原方法无返回值，此时返回null
2、若原方法为静态方法，此时形参Object obj 可为null
3、若原方法形参列表为空，则Object[] args为null
4、若原方法声明为private,则需要在调用此 invoke()方法前，显示调用方法对象的setAccessible(true)方法，将可访问private的方法

setAccessible
1、Method和Field、Constructor对象都有setAccessible()方法
2、setAccessible作用是启动和禁用访问安全检查的开关
3、参数值为true则指示反射的对象在使用时应该取消JAVA语言访问检查

  • 提高反射的效率，如果代码中必须用反射，而该句代码需要频繁的被调用，那么请设置为true
  • 使得原本无法访问的私有成员也可以访问

参数值为false则指示反射的对象应该实施java语言访问检查

package com.axiaoleng1;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class Test11 {
    public static void main(String[] args) throws Exception{
        //获得Class对象
        Class c1 = Class.forName("com.axiaoleng1.User");

        //构造一个对象
//        User user = (User)c1.newInstance();  //本质是调用了类的无参构造器
//        System.out.println(user);


        //通过构造器创建对象
//        Constructor constructor = c1.getDeclaredConstructor(String.class,int.class,int.class);
//        User user1 = (User)constructor.newInstance("阿冷",001,20);
//        System.out.println(user1);

        // 通过反射调用普通方法
        User user2 = (User) c1.newInstance();
        // 通过反射获取一个方法
        Method setName = c1.getDeclaredMethod("setName", String.class);

        //invoke : 激活的意思
        // (对象 ; "方法的值")
        setName.invoke(user2,"阿冷");
        System.out.println(user2.getName());

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

        //不能直接操作私有属性，我们需要关闭程序的安全检测，属性或者方法的setAccessible
        name.setAccessible(true);
        name.set(user3,"阿小冷");
        System.out.println(user3.getName());
    }
}
  • 性能对比分析
package com.axiaoleng1;

import java.lang.reflect.Method;

public class Test12 {

    //普通方式调用
    public static void test01(){
        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 test02() throws Exception{
        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++){
            //user.getName();
            getName.invoke(user,null);
        }

        long endTime = System.currentTimeMillis();

        System.out.println("反射方法执行10亿次："+(endTime-startTime)+"ms");
    }


    //反射方式调用  关闭检测
    public static void test03() throws Exception{
        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++){
            //user.getName();
            getName.invoke(user,null);
        }

        long endTime = System.currentTimeMillis();

        System.out.println("反射方法关闭检测执行10亿次："+(endTime-startTime)+"ms");
    }

    public static void main(String[] args) throws Exception {
        test01();
        test02();
        test03();
    }
}
  • 获取泛型信息
    在这里插入图片描述
package com.axiaoleng1;

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 Test13 {

    public void test01(Map<String,User> map, List<User> List){
        System.out.println("test01");
    }

    public Map<String,User> test02(){  //返回值的使用
        System.out.println("test02");
        return null;
    }

    //通过一个注解获得泛型
    public static void main(String[] args) throws Exception {
        Method method = Test13.class.getMethod("test01",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);
                }
            }
        }

        method = Test13.class.getMethod("test01",Map.class,List.class);
        Type genericReturnType = method.getGenericReturnType();

        if(genericReturnType  instanceof ParameterizedType){  //
            Type[] actualTypeArguments = ((ParameterizedType) genericReturnType ).getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
                System.out.println(actualTypeArgument);
            }
        }
    }

}
  • 反射操作注解

在这里插入图片描述

package com.axiaoleng1;

import java.lang.annotation.*;
import java.lang.reflect.Field;

public class Test14 {
    public static void main(String[] args)  throws Exception{
        Class c1 = Class.forName("com.axiaoleng1.Student2");

        //通过反射获得注解
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }

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

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

        Field f1 = c1.getDeclaredField("id");
        Fieldleng annotation1 = f1.getAnnotation(Fieldleng.class);
        System.out.println(annotation1.columnName());
        System.out.println(annotation1.type());
        System.out.println(annotation1.length());

        Field f2 = c1.getDeclaredField("age");
        Fieldleng annotation2 = f2.getAnnotation(Fieldleng.class);
        System.out.println(annotation2.columnName());
        System.out.println(annotation2.type());
        System.out.println(annotation2.length());
    }
}

@Tableleng("db_student")
class Student2{

    @Fieldleng(columnName = "db_id",type = "int",length = 10)
    private int id;
    @Fieldleng(columnName = "db_age",type = "int",length = 10)
    private int age;
    @Fieldleng(columnName = "db_name",type = "varchar",length = 3)
    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 Tableleng{
    String value();
}


//属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface Fieldleng{
    String columnName();
    String type();
    int length();
}
qq_47026948
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
计算机cpu制冷,成熟的解决方案：制冷技术：用冷却芯片冷却CPU
weixin_39832829的博客
07-25 4333
简介：每个人都知道CPU温度越低越好。许多文章都讨论了CPU散热是否良好是超频成功的关键因素。通常，通过使用大风扇并涂导热油脂可以改善CPU的散热条件，但是这些方法不可能使CPU的温度低于室温。有人曾经在四川一家报纸上刊登并出版了四川齐文先生的《酷暑酷酷的核心》。看完报纸后，我收到了许多朋友的来信，询问情况。同时，几个热心的朋友也写了关于他们的经历的文章并发送给他们。为了让更多的人了解，他们决定在...
学计算机的电脑尺寸多大合适,16寸笔记本电脑尺寸大小是多少
weixin_29023471的博客
06-18 6476
16寸的笔记本电脑尺寸有多大呢?有这么大尺寸的笔记本吗?下面由学习啦小编给你做出详细的16寸笔记本电脑尺寸大小介绍!希望对你有帮助!16寸笔记本电脑尺寸大小介绍一：屏幕尺寸是用英寸单位来计算的，也就是对角距离16英寸。1英寸=25.4MM，16英寸也就是对角距离为406.4MM。长和宽没有一个绝对的尺寸，只要对角距离为406.4MM的屏幕都统称16寸。16寸笔记本电脑尺寸大小介绍二：笔记本16寸的...
小语种能学计算机吗,这五个最热的专业，就业前景很好，但是学习很难
weixin_35141284的博客
07-15 1164
这五个最热的专业，就业前景很好，但是学习很难。现在受欢迎的专业很多，就业前景和工资待遇都不错，所以考生们都争着报名，但是，来了大学以后，很多学生都觉得自己“不行”，这些专业就业很好，但是很难，学习很辛苦，那么，接下来我们来看这五个最热的专业，到底哪里难？一、护理专业看护专家说，这个行业现在人非常少，所以很多专科学校的学生都能找到同样的工作，但是，在学校应该学习的东西有很多，不能像基础医学和药理那样...
大学计算机系最努力的同学都是如何学习的？
热门推荐
启舰
06-21 23万+
经常会被同学们问到这个问题，要怎么努力才能找到好工作？ 学习好就能进好公司？ 屁！ 被学校教育坑的一把鼻涕一把泪的老学长来回答一波。 我上大学时，连续三年得过国家励志奖学金，英语过六级，以为软考有用，还考了个软件设计师证书，以为四级有用，也考了个软件测试工程师证书，看人家用c++写软件，自学MFC写了几个桌面小程序。 自以为很牛逼的去找工作，结果要价2500，都没人收，2011年，一个计算机系top级毕业生，薪资还没流水线的高。 现在工作近十年，也辗转几个大厂，做校招、社招面试也不下于上百场，这
大专学计算机专业学得到不,大专学计算机真的没用吗
weixin_30652105的博客
06-16 1720
大专学计算机真的没用吗以下文字资料是由(历史新知网www.lishixinzhi.com)小编为大家搜集整理后发布的内容，让我们赶快一起来看一下吧！大专学计算机真的没用吗很难有前途，计算机应用，是一个杂而不精的专业。大专只是低分大学，接受的教育水准有限。通常大专，计算机应用毕业生，想要从事计算机技术行业，是需要，经过培训才可以的。大专选什么专业有前途？计算机类没用吗？都没什么前途，选个冷门好点，计...
程序猿有话说：计算机，学着挺有意思的，就是头冷
a6984021的博客
09-28 3965
程序猿，一个互联网高速发（cui）展（can）下的新生物种，不仅拥有较高的智商，还有无限的忍耐力，日常敲代码，加班已成为了常态，一个高薪与秃头并存的群体… 　　 　　据说程序员的日常是这样的： 　　 　　当然大家一提起程序员的印象都是闷骚，话不多，常年的双肩包与条纹衬衫，单身且仿佛无时不刻的在工作中。看过很经典的一句话：程序员的世界只有两种语言1.没人用的2.经常被人喷的。 　　一天，朋友在地铁上...
学计算机还是药学好,读什么专业好找工作，计算机怎么样？
weixin_28833069的博客
06-15 2179
选一个好的专业，无非就是希望能够高薪就业一、计算机计算机无疑是一个很热门的专业，从社会分析，这是一个信息革命时代，国家大力提倡互联网 ，抓紧信息基础建设，需要大量的人才，薪资也是超前的高，最差的程序员，最低也要一万块一个月打底缺点：竞争力度真的很大，不是学习一点点知识就能上任，而且这一辈子都在学习中度过，学校的知识只为基础，科技是日新月异的，否则人们常说读计算机的三十五岁面临失业的危险，因为跟不上...
腐烂国度的计算机学知识,腐烂国度2手工艺知识
weixin_36475451的博客
06-24 4041
1、腐烂国度2特殊技能哪个好？腐烂国度2特殊技能效果汇总《腐烂国度2》不同特殊技能效果有很大差别，具体是怎样的呢？下面就为大家带来腐烂国度2特殊技能效果汇总，一起来看看。点击进入：腐烂国度2基地系统中文详解腐烂国度2特殊技能效果汇总就到这里，希望对玩家有所帮助。2、腐烂国度2计算机学知识怎么升级？腐烂国度2第五技能升级方法 第五技能怎么升级 第五技能升级方法介绍 把鼠标悬浮在那项技能上，看到Imp...
211计算机冷门学校,新闻传播硕士冷门学校（考研适合捡漏的211大学）
weixin_36356040的博客
07-08 2009
目前新闻专业有细微的区分，在一些院校会细分为新闻学与传播学两块，所以会有侧重。就考研来说，有张全国高校新闻传播学科的考研排名供参考：这个图表基本已把全国有新闻传播专业的高校一网打尽了。可以根据自己的情况进行选择。另外，总体来说，新闻媒体目前处于一个转型阶段，就业前景想对比较不明，所以在选择考研方向上需要投入更多的精力去分析，找到合适的目标。相比传统媒体，以数字技术和互联网技术为依托的新媒体，在信息...
武汉哪所技术学校学计算机好,武汉计算机专业学校排名
weixin_34561373的博客
06-14 1697
武汉计算机专业学校排名，让一些计算机学校的知名度进一步得到提升。在大部分人看来，如果计算机专业学校的排名比较靠前的话，这种学校的报考率会比较高，而如果只是根据计算机专业学校的排名来择校的话，可能有失偏颇。那么，怎么选学校好呢？下面，3721职校网搜集了一些相关的信息，为择校的人提供参考。武汉计算机专业学校排名随着我国社会背景的发展，计算机专业已经成为我国热门专业之一，尤其是工科男生，报考计算机专业...
计算机基础学习材料.pdf
10-11
1. **计算机发展史**：第一台电子管计算机ENIAC于1946年诞生，随后发展至晶体管计算机、中小规模集成电路和大规模集成电路阶段。 2. **应用领域**：计算机广泛应用于科学计算、信息管理、实时控制、办公自动化、...
基于Bresenham算法画圆(计算机图形学实验).rar
05-30
1、实验目的： 理解Bresenham光栅化算法，掌握绘制曲线的程序设计方法。 2、基本要求： 要求一：利用Bresenham中点画圆法画出圆形。 要求二：动态表现画圆过程。 要求三：根据Bresenham光栅化画圆算法，以（0，0）为...
计算机专业教学改革的冷思考.docx
06-28
【计算机专业教学改革的冷思考】 计算机专业教育在当今时代面临着诸多挑战，尤其是在中等职业教育领域。本文将探讨计算机专业教学中存在的主要问题，包括学生学习状况差、实习就业安置困难以及师资力量不足，并提出...
J031_使用TCP协议支持与多个客户端同时通信
最新发布
lzn20161229的博客
08-03 188
使用TCP协议支持与多个客户端同时通信。
SpringBoot+Vue图书(图书借阅)管理系统-附项目源码与配套文档
m0_74283290的博客
08-03 605
本论文阐述了一套先进的图书管理系统的设计与实现，该系统采用Java语言，结合现代Web开发框架和技术，旨在为图书馆提供高效、灵活且用户友好的资源管理解决方案。系统利用Spring Boot框架为核心，整合MyBatis ORM工具，以及MySQL数据库，构建了一个高性能、可扩展的后端服务。前端界面则采用了Vue.js框架，以提供流畅的用户交互体验。论文首先进行了详尽的需求分析，确定了系统的核心功能，包括图书的添加、编辑、删除、查询，读者的注册、登录、个人信息管理，以及图书的借阅、归还、续借流程。
社区养老服务小程序的设计
Karen198的博客
07-31 529
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
深入理解Java注解
weixin_55745942的博客
08-01 568
Java注解是用来描述程序元素（如类、方法、变量等）的一种机制。它们可以提供关于程序的补充信息，帮助编译器、框架或其他工具更好地理解和处理代码。注解通常以符号开头，后跟注解名称和可能的参数。要创建自定义注解，需要使用@interface关键字定义一个接口，并在接口中声明注解的属性。这个注解名为，可以被用来标记方法。它有一个名为value的属性，具有默认值"default"。
JavaSE面向对象进阶
qq_45348840的博客
07-30 488
需求：在实际开发中，经常会遇到一些数组使用的工具类;请按照如下要求编写一个数组的工具类：ArrayUtil提供一个工具类方法printArr,用于返回整数数组的内容。返回的字符串格式如：[10,20,50,34,100 ]（只考虑整数数组，且只考虑一维数组)提供这样一个工具方法getAerage,用于返回平均分。（只考虑浮点型数组，且只考虑一维数组)定义一个测试类TestDemo,调用该工具类的工具方法，并返回结果。// 私有化构造方法// 定义静态方法，方便调用。i++) {
深度排序在计算机图形学中的关键策略
"计算机图形学是一门研究计算机中图形的表示、生成、处理和显示的学科，它在计算机科学中占据着重要地位，应用广泛，如图形硬件、图形标准、交互技术、光栅图形生成算法等都是其核心内容。本课程的重点之一是对场景...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值