JAVA003【多态、代码块、包、权限修饰符、内部类，Object类】

最新推荐文章于 2022-08-14 14:40:53 发布
最新推荐文章于 2022-08-14 14:40:53 发布
阅读量115 收藏 1
点赞数
分类专栏： Java学习之道 文章标签： JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42615105/article/details/101627228
版权

1.什么是多态

同一种事物表现出来的多种形态

2.多态的前提

  • 必须有继承关系或者实现接口关系
  • 必须有方法重写
  • 必须有父类引用指向子类对象

3.多态的格式

  • 父类类名 对象名 =new 子类类名（）；

4.多态的注意事项：

  • 多态下子类和父类出现同名的成员变量时，访问父类的成员变量（）；
  • 多态下子类和父类出现同名的成员变量时，访问父类的成员变量（）；

5.绑定

  • 成员变量的静态绑定：在编译期就确定变量是访问父类的还是子类的
  • 成员方法的动态绑定：在编译期还不确定调用父类的还是子类的方法，是在程序运行过程确定
    • 注意：编译看左边，运行看右边
      • 成员变量编译看左边，运行也看左边（看父类有没有这个方法，没有的话向下转型）
      • 成员方法编译看左边，运行看右边

6.多态的优点

  • 提高代码的复用性
  • 提供代码的维护性

7.多态的缺点

父类引用不能调用子类特有的成员方法

8.多态用于形参或者返回值

1. 多态用于形式参数的好处：可以接受各种子类类型的对象

2. 多态用于方法返回值的好处：可以返回各种子类类型的对象

  • 代码

  • package com.itheima._04多态优缺点;

/**
    目标：理解多态的优点与缺点

    讲解：
        1. 多态的优点
            提高代码的复用性
            提高代码的维护性

        2. 多态的缺点：父类引用不能调用子类特有的成员方法

    小结：
        多态的优点：提高代码的复用性和维护性

    思考：多态后如何调用子类特有的功能？
 */
public class Demo042 {
    public static void main(String[] args) {
        // 买1只?：创建Dog对象
        Dog d1 = new Dog();
        // 让狗吃骨头
       /* d1.eat();
        // 让狗睡觉
        d1.sleep();*/

        feedAnimal(d1);

        // 又买一只
        Dog d2 = new Dog();
        // 让狗吃骨头
        /*d2.eat();
        // 让狗睡觉
        d2.sleep();*/

        feedAnimal(d2);

        System.out.println("----------------");
        // 买一只猫
        Cat c1 = new Cat();
        /*c1.eat();
        c1.sleep();*/
        feedAnimal(c1);

        // 买一只猫
        Cat c2 = new Cat();
        /*c2.eat();
        c2.sleep();*/
        feedAnimal(c2);


        Animal d3 = createAnimal(1);
        Animal c3 = createAnimal(2);
    }


    /**
     * 负责创建动物对象
     * type = 1 狗
     * type = 2 猫
     * @return
     */
    //返回值
    public static Animal createAnimal(int type){
        if (type == 1){
            return new Dog();
        } else if (type == 2) {
            return new Cat();
        }
        return new Tiger();
    }


    // 喂养动物
    // Animal a = new Dog();
    // Animal a = new Cat();
    //形参
    public static void feedAnimal(Animal a){
        // 让狗睡觉
        a.sleep();
        // 让狗吃骨头
        a.eat();
    }
}

9.基本数据类型的转换格式

  • 小==》大 double a=100;

  • 大==》小 double b=122.5; int c=(int)b

  • 多态转型的分类:

    • 向上转型：父类引用指向子类对象的过程是向上转型的结果
    • 格式：父类类名 变量名=new 子类类名（）；
    • 向下转型：父类引用转换为子类引用的过程
    • 格式：子类类名 变量名=（子类类名）父类的引用；

10.instanceof关键字的使用

  • 判断父类引用指向哪个子类类型 常用多态之后判断父类引用指向哪个子类类型的对象

  • 格式：boolean b= 父类引用 instanceof 子类类名；

===============================

11.内部类的概述

在一个类中有定义了一个类，在A类定义了B类，A类称为外部类，B类则称为内部类。

12.内部类的分类

  • 静态内部类：定义在外部类的成员位置（有static修饰）
    • 使用格式：class Outer{static class InnerP{} }
  • 实例内部类：定义在外部类的成员位置（没有static修饰）
  • 局部内部类：定义在外部类的成员方法中
  • 匿名内部类：没有名字的类，常用作为方法参数！

13.静态内部

package com.itheima._08静态内部类_了解;

/**
    Tip：静态内部类与外部类的⽤法完全一样。只是访问的时候需要加上外部类.内部类。

    目标：了解静态内部类定义和使用

    讲解：
        1. 静态内部类的使用格式
            class Outer {
                static class Inner{

                }
            }

        2. 静态内部类对象创建格式
            外部类名.内部类名 变量名 = new 外部类名.内部类名(参数);

        3. 静态内部类只能访问外部类的static修饰的成员？这句话对吗？
            正确

    小结：
        1. 静态内部类对象创建格式：
            外部类名.内部类名 变量名 = new 外部类名.内部类名(参数);
 */

class Outer {
    private String name;

    // 静态内部类
    static class Inner{
        // 定义成员变量
        private int age;

        // 定义构造方法
        public Inner(int age) {
            this.age = age;
        }
        public Inner() {
        }

        // 定义成员方法
        public void show(){
            System.out.println("年龄：" + age + ", 姓名：");
        }
    }

    // 外部类方法：创建内部对象
    public void showInfo(){
        Inner inner = new Inner();
        inner.show();
    }

}

public class Demo081 {
    public static void main(String[] args) {
        // 创建静态内部类对象
        /*Outer.Inner i = new Outer.Inner(20);
        // 调用对象调用方法
        i.show();*/

        // 创建外部类对象
        Outer outer = new Outer();
        outer.showInfo();
    }
}

14.实例内部

package com.itheima._09实例内部类_了解;

/**
    实例内部类又称为成员内部类

    目标：了解实例内部类的使用

    讲解：
        1. 实例内部类的定义格式
         class Outer {
              class Inner{

             }
         }

        2. 实例内部类创建对象格式
            外部类名.内部类名 变量名 = new 外部类名().new 内部类名();

        3. 实例内部类的好处
            可以访问外部类的任意成员。

    小结：
        1. 实例内部类创建对象格式：
            外部类.内部类 变量名= new 外部类名(参数).new 内部类名(参数);

        2. 实例内部类的好处
            可以访问外部类所有成员
 */

class Outer {
    // 成员变量
    private static String name;

    public Outer() {
    }

    public Outer(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    // 实例内部类
    class Inner{
        private int age;

        public Inner() {

        }

        public Inner(int age) {
            this.age = age;
        }

        public void show(){
            System.out.println("年龄：" + age+"，外部类name：" + name);
        }
    }
}

public class Demo091 {
    public static void main(String[] args) {
        // 外部类名.内部类名 变量名 = new 外部类名().new 内部类名();
        Outer.Inner i = new Outer("jack").new Inner(30);
        // 调用方法
        i.show();
    }
}

package com.itheima._09实例内部类_了解;

/*
    面试题：请在?地⽅写上相应代码,以达到输出的效果

    目标：了解实例内部类如何访问外部类同名的成员变量

    讲解:

    小结:
        如何访问外部类的成员变量：外部类名.this.成员变量名;
 */
public class Demo092 {
    public static void main(String[] args) {
        Body.Heart heart = new Body().new Heart();
        heart.jump();
    }
}

class Body { // 身体    
    private int weight = 30;
    // 在成员位置定义一个类
    class Heart {
        private int weight = 20;

        public void jump() {
             int weight = 10;
            System.out.println("心脏在跳动 " + weight); // 10
            System.out.println("心脏在跳动 " + this.weight);// 20
            System.out.println("心脏在跳动 " + Body.this.weight); // 30

            Body.this.jump();
        }
    }

    public void jump() {
        System.out.println("外部类jump方法...");
    }
}

15.局部内部类

package com.itheima._10局部内部类_了解;

/**
     目标：了解局部内部类的创建和使用

     讲解:
         1. 什么是局部内部类:
            定义在外部类的方法中

         2. 局部内部类的使用:
            只能在方法内部使用

         3. 局部内部类注意事项：
            * 静态方法中的内部类只能访问外部类的静态成员。
            * 非静态方法中的内部类可以访问外部类静态成员和非静态成员。

     小结:
        1. 什么是局部内部类: 定义方法中类

        2. 局部内部类的使用: 只能在定义的方法中使用
 */

class Outer{

    private static String name;

    public static void test(){
        // 定义局部内部类
        class Inner{
            // 定义成员变量
            private int age;

            public Inner(int age) {
                this.age = age;
            }

            public Inner() {
            }

            public int getAge() {
                return age;
            }

            public void setAge(int age) {
                this.age = age;
            }

            public void show(){
                System.out.println("年龄：" + age + "，姓名:" + name);
            }
        }

        // 创建局部类对象
        Inner inner = new Inner(40);
        inner.show();
    }
}

public class Demo101 {
    public static void main(String[] args) {
        // 创建外部类对象
        Outer outer = new Outer();
        outer.test();
    }
}

16.11@匿名内部类

package com.itheima._11匿名内部类_重要;

/**
    目标：掌握匿名内部类的语法

    讲解：
        1. 匿名内部类概述
            没有名字的类

        2. 使用匿名内部类的前提条件
            必须有一个已知类或已知接口
            直接创建已知类的子类对象
            直接创建已知接口的实现类对象

        3. 匿名内部类的格式
            new 类名或接口名(){ }

    小结：
        1. 匿名内部类的语法：
            new 类名或接口名(){
                重写方法
            }

 */
public class Demo111 {
    public static void main(String[] args) {
        // 使用匿名内部类：直接创建Animal类的子类对象
        /**
            下面代码等价这两行：
            1. class Xxx extends Animal{
                     @Override
                     public void eat() {
                            System.out.println("吃饭....");
                     }
                }
            2. Animal a = new Xxx();
            3. a.eat();
         */
        Animal a = new Animal(){
            @Override
            public void eat() {
                System.out.println("吃饭....");
            }
        };
        a.eat();

        // 直接创建已经接口的实现类对象
        /**
            下面代码等价两行
            1. class Yyy implements Smoking{
                    @Override
                    public void smoke() {
                        System.out.println("抽烟...");
                    }
                }
            2. Smoking s = new Yyy();
            3. s.smoke();
         */
        Smoking s = new Smoking(){
            @Override
            public void smoke() {
                System.out.println("抽烟...");
            }
        };
        s.smoke();
    }
}

=回顾=

17.代码块

  • 静态代码块 ：类中方法外 static{}

    • 特点：类加载的时候会自动执行 只会执行一次
    • 作用：常用执行一次的

  • 实例代码块：每次创建对象都会自动执行一次 {}

package com.itheima._12代码块概述;

/**
     目标：学习静态代码块和构造代码块

     讲解:
        1. 代码块分类
            静态代码块
            构造代码块

        2. 静态代码块概述
            特点：在类加载的时候会自动执行，只会执行1次
            语法：static { }
            作用：常用执行一次性初始化操作

        3. 实例代码块概述
            特点：每次创建对象都会自动执行一次
            语法：{ }

        4. 代码块的定义位置
            类中方法外

    小结
        1. 静态代码块格式： static {}

        2. 实例代码块格式: { }
 */
public class Demo121 {
    public static void main(String[] args) {
        // 创建学生对象
        Student stu01 = new Student();
        Student stu02232323 = new Student();

/*        System.out.println(stu01.getAge());*/
        System.out.println(stu01.getName());
    }
}

18.包

  • 包的概念：包在文件系统中就是文件夹
  • 包的作用：用来解释类命名冲突的问题 将功能相似或相同的类放在一起便于管理
  • 包的定义格式和命名规范：package 包名
  • 包名一般是小写字母 公司域名倒着写 com.itheima

18.导包

  1. 导包方式使用 ：
  • import 包名.包名—类名；一个类
  • import 包名.包名.*; 通配符 导入其他包的所有类

​ 2.类全名字符串：当类名一样的时候

  • 包名.包名…类名

19.访问权限

  • private:只能在本类中使用
  • 默认（null）权限：可以在本包下的类访问
  • protected：可以在本包下的类以及其他包有关联的子类访问
  • public:可以在任意包下的任意类访问

20.Object类

  • 特点：最大 所以类的父亲

    • 类object是类层次结构的跟类
    • 每个类都使用object作为超类父类基类
    • 所有类都是直接或者间接继承object类

  • Oject类常用方法

    • String toString();返回该对象的字符串表示

    默认返回格式：类全名字符串@对象在内存中的地址值

    调用时机：

    自动调用：当打印输出对象时系统内部会自动调用

    手动调用：通过对象调用

    • boolean equals(Object obj);

    用来比较两个对象是否相同，是则返回true 否则false

    默认是通过比较两个对象的地址值判断是否相同 除非重写才是比较内容

    ==比较运算符

    基本数据类型：比较两个变量值是否相同

    引用数据类型：比较两个对象的地址值

    @equals方法的作用：

    比较两个对象是否相同 默认是通过地址值比较

    重写equals方法的目的：

    不希望比较地址判断，而是希望比较对象内容判断是否相同

    !!!判断是不是同一个类

    if (obj == null || !(obj instanceof  Student)) return false;

    等价于

    @Override
public boolean equals(Object o) {
    if (this == o) return true;
    //判断是不是同一个类
    if (o == null || getClass() != o.getClass()) return false;
    Student student = (Student) o;
    return age == student.age &&
            Objects.equals(name, student.name);
}

总结：

package com.itheima._16toString方法;

import java.util.Objects;

public class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student() {
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void showInfo(){
        System.out.println("name = " + name + ", age = "  + age);
    }

    /*@Override
    public String toString() {
        return "name = " + this.name + ", age = " + this.age;
    }*/

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    // 重写equals方法：要比较两个对象的内容判断是否相同
    // Object obj = new Student("小泽", 20);
   /* @Override
    public boolean equals(Object obj) {
        // this ==> s1
        // obj ==> s2
        // 判断obj是否是this
        if (this == obj) return true;
        // 判断obj是否为null
        // 判断obj是否是Student对象
        if (obj == null || !(obj instanceof  Student)) return false;
        // 向下转型：将obj转换Student
        Student s2 = (Student)obj;
        // 判断姓名是否相同
        if (!this.name.equals(s2.name)) return false;
        // 判断年龄是否相同
        if (this.age != s2.age) return false;
        // 来到这里说明姓名和年龄都相同
        return true;
    }
*/
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }
}

  • 21.工具类

  • Objects 类概述：是一个工具类 类中的所有方法都是静态方法

  • 常用的工具类 Arrays Objects Collection Math System

  • static boolean isNull(Object obj)判断对象obj是否为null 是返回true

  • static boolean equals(Object a,Object b)比较对象a和对象b是否相同 相同为true

  • Object.equals(x,y) Object.isNull(x)

    • 对于比较优先使用 Object.equals(x,y)
    • s1=null; if(s1!=null){sout(s1.equals(s2))}; 要先判断是否为空
    • sout( Object.equals(s1,s2) ); 推荐使用 因为已经判断了是否为空

22.总结

 - 能够说出使用多态的前提条件
    必须是子父类关系或类实现接口关系
    必须有方法重写
    必须是父类引用指向子类对象

 - 理解多态的向上转型
    父类类型 变量名 = new 子类类型();
    接口类型 变量名 = new 实现类类型();

 - 理解多态的向下转型
    父类引用转换为子类引用的过程
    子类类型 变量名 = (子类类型)父类引用;

 - 能够写出静态代码块的格式
    static {

    }

 - 能够说出权限修饰符作用范围
    private：只能在本类使用
    默认：本包下的类
    protected：本包下的类或子类
    public：任何包下任意类

 - 说出内部类的概念
    在A类中定义了B类，B类就是内部类，A类称为外部类

 - 能够说出Object类的特点：所有类的父类

 - 能够重写Object类的toString方法：
        通过IDEA快速生成即可
        重写目的：在打印对象时希望输出对象的成员变量值

 - 能够重写Object类的equals方法：
        通过IDEA快速生成即可
        重写目的：希望比较内容判断两个对象是否相同。


    1. 多态(重点)
        概念：同一种事物表现出来的多种形态
        前提：
            * 有子父类关系或类实现接口关系
            * 要有方法重写
            * 父类引用指向子类对象
        格式：父类引用指向子类对象：
                父类类型 变量名 = new 子类类型();
                接口类型 变量名 = new 实现类类型();

        好处：提供代码复用性和维护性
        缺点：不能访问子类特有的功能
        应用场景：
            作为方法形式参数：可以接收各种子类类型的数据
            作为方法返回值：可以返回各种子类类型的数据
        转型：
            向上转型：父类引用指向子类对象
            向下转型：将父类引用强制转换为子类引用

        instanceof关键字：
            判断父类引用指向的子类类型
            父类引用 instanceof 子类类型
            Smoking s = new Student();
            boolean b = s instanceof Student

    2. 内部类(匿名内部类重点)
        匿名内部类语法：
            new 类名或接口名(){ }
            直接创建已知类的子类对象或已知接口的实现类对象

    3. 代码块
    4. 包
    5. 权限修饰符

    6. Object特点和常用方法(重点)
    7. Objects工具类
KeepHadoop
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java 面向对象 -- Java 语言的封装、继承、多态、内部类和 Object 类
栗筝i的博客
06-12 2600
在我们对 Java 语言进行基本介绍之后，本篇文章将带领大家深入了解 Java 的面向对象编程（OOP）概念。我们将探讨封装、继承和多态这三大核心概念，以及内部类的使用和 Object 类的重要性。通过对这些内容的学习，读者将能够更好地设计和实现复杂的 Java 应用程序。
static&继承&多态&包&final&权限修饰符&代码块
最新发布
weixin_52009660的博客
04-01 80
Javabean类：用来描述一类事物的类。比如Student、Teacher、Dog等测试类：用来检查其他类是否书写正确，带有main方法的类，是程序的入口工具类：不是用来描述一类事物的，而是帮我们做一些事情的类。
多态例子——Java代码
Shaun_Guo的博客
03-06 5785
/*多态的好处：提高了代码的维护性和扩展性；弊端：父类不能使用子类的特有功能。要用子类的特有功能，可以：A:创建子类对象，调用方法即可（不合理，太占内存）；B：把父类的引用强制转换为子类的引用（向下转型）；向上转型：Fu f = new Zi();向下转型：Zi z = (Zi) f;//要求该f必须是转换为Zi的。*/class Animal{ public void eat(){ Syste...
Java多态是什么，怎么实现的，多态例子代码
trigger的博客
03-22 547
目录 子类型和子类 多态分两种 多态的用途 多态的转型 运行时多态的例子 多态实现的机制 JVM 部分内容摘自： Java多态的实现机制是什么，写得非常好！_Java技术栈的博客-CSDN博客 子类型和子类 子类型（Subtype）这个词和子类（Subclass）的区别，简单地说，只要是A类运用了extends关键字实现了对B类的继承，那么我们就可以说Class A是Class B的子类，子类是一个语法层面上的词，只要满足继承的语法，就存在子类关系。 子类型比子类有更严格的要求，它不仅
# 数据类型面试题；
weixin_57311602的博客
08-20 1694
数据类型面试题; （数据类型） 一 . Java中有哪些数据类型？ Java中数据类型分为基本数据类型和引用数据类型2种 基本类型：byte short int long double float char boolean 引用数据类型： 类 接口 数组 byte（默认值0，占1字节）、 short（默认值0，占2字节）、 int（默认值0，占4字节）、long （默认值0，占8字节）、float （默认值0.0，占4字节）、 double（默认值0.0，占8字节）、 char（默认值\u0
http://syy7.com/a/25.php,vue_element/vue_elementui.sql at 3ffdcb477ce3fbbc24cf1a4d7e3481a187023a02 ·...
热门推荐
weixin_34064233的博客
04-13 101万+
INSERT INTO `user_tb` VALUES ('1', '女', 'burtyang', 'C041580E1C6192B6084E03CE76D5C05C', '18', null, 'data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEASABIAAD/2wBDAAwICQoJBwwKCQoNDAwOER0TERAQESMZGxUdKiUsKykl...
DB2和ORACLE的印象比较
funnsy的专栏
04-06 696
一个项目需要DB2，以前没用过，用了WINDOWS 2008下的DB29.7 好几周，算入门了吧，下面这文章就当一个ORACLE使用者眼里的DB2的印象吧，也许有些东西可能有偏差，但是就是我自己的印象： 1、体系结构，DB2的实例和数据库分开的做法，我个人还是比较喜欢的，因为实例可以创建多个，数据库的恢复直接恢复到实例下就可以了，相对ORACLE简单多了。 2、管理工具，DB2的管
Java笔记 - 黑马程序员_03（继承，修饰符，多态，抽象类，接口，内部类）
逸乐的博客
04-22 2481
1. 继承 1.1 继承的概述 继承是面向对象三大特征之一。可以使得子类具有父类元素的属性和方法，还可以在子类中重新定义，追加属性和方法。 继承的格式： 格式：public class 子类名 extends 父类名 案例：public class ZI extends FU{} FU类为父类（superclass），超类，基类 ZI类为子类（subclass），派生类，扩展类 继承中子类的特点： 子类可以有父类的内容 子类也可以有自己特有的内容
2.Java笔记:接口与多态，构造器，final类，内部类，Object类，数字与字符串，日期和时间类，代码块
qq_45134373的博客
12-14 246
JAVA初级学习部分总结2:主要包括接口与多态，构造器，final类，内部类，Object类，数字与字符串，日期和时间类。
java基础笔记三（静态、继承与多态、抽象类、接口、权限修饰符、枚举、final关键字、Object&Math&Date&包装类等常见类、Collection集合、Map集合）
fuyaozhishangzzx的博客
08-14 303
java基础知识（三）：stastic、extend、implements、面向对象三大特性：封装、继承、多态，抽象类、接口与开发中常见类、集合的使用.
Linux Shell 笔记
weixin_30352191的博客
08-16 1242
1、查看进程的环境变量 普通：$cat /proc/1642/environ 换行：$cat /proc/1642/environ | tr '\0' '\n' tr的命令格式是tr SET1 SET2，凡是在SET1中的字符，都会被替换为SET2中相应位置上的字符。 2、SHELL脚本赋值与等于判断 赋值：$var=value 相等：$var = value 在赋值时...
[转]Verilog 代码风格-供参考
weixin_33895604的博客
01-22 252
Description 本文主要是收集一些重要的Verilog coding style。一个好的coding style可以减少错误的发生，增加电路的效能，以及较好的可读性。 Text The order of module signals 一个module signal顺序如下 (由左至右): Input clock signals(clk_*) set/reset...
JS正则表达式【1】
Bidding
01-27 1299
经典JavaScript正则表达式实战 1、匹配结尾的数字 来源：如何用 JAVASCRIPT 正则表达式 取出字符串最后一组数字，谢谢 如 30CAC0040 取出40 3SFASDF92 取出92 正则如下：/\d+$/g 2、统一空格个数 来源：正则匹配空格的问题 字符串内字符键有空格，但是空格的数量可能不一致，通过正则将空格的个数统一变为一个。 例如：蓝 色 理 想 变成：蓝 色 理 ...
OkGo的使用
追梦赤子的博客
09-17 952
GitHup网址 github地址：https://github.com/jeasonlzy/okhttp-OkGo 添加依赖 //默认添加okhttp3.4.1、okio1.9.0 compile 'com.lzy.net:okgo:2.1.4' 全局配置 1.进行全局配置，一般在 Aplication，或者基类的onCreate方法中，只需要调用一次即可，可以配置调试开关...
BUUCTF——MISC
bdm1121的博客
04-14 5224
0x01 签到 flag：flag{buu_ctf} 0x02 金仨胖 gif文件，用2345看图王打开，可以看到得到三段信息图片，组合后得到flag： flag{he11ohongke} 0x03 二维码 扫描二维码提示secret is here，binwalk图片得到一个压缩包，提示4位数，爆破得到密码7639，解压得到flag： flag{vjpw_wnoei} 0x04 N种解决方法 得...
[网摘][批处理]批处理学习之一
weixin_33968104的博客
12-01 821
之前搞过批处理,但后来没做了,现在就忘记了.看来知识也像人一样,太久不联系的话就散了,淡了,渐渐的远了,在我们的世界里消失了.这无疑是杯具的事.还是不要忘记吧,丢掉的东西徐亚找回来.收藏一篇文章做学习用,如下: 见:http://www.hackbase.com/tech/2009-09-16/56089_2.html 目录第一章 批处理基础第一节 常用批处理内部命令简介1、REM 和 ::2...
Java日志组件 commons-logging和log4j介绍
Kawaboger的专栏
03-15 862
一、日志系统介绍 日志的重要性是随着系统的膨胀而显现的，在一个庞大的系统中查错没有各种日志信息是寸步难行的。所以在系统加入日志是必须的。 最原始的日志方式，就是在程序的适当地方添加System.out.println()方法，但是带来的问题是，系统稳定后，日志太大，如果要减少日志量，就需要重新修改程序，虽然只是注释掉System.out.println()方法。但是万一系统再次出错，又
【泡泡机器人公开课】公开课链接 机器人俱乐部
开源节流
11-23 1万+
1.工业相机选型及介绍-刘富强 链接: https://pan.baidu.com/s/1nuGw4Vv 密码: tjag 2.深度学习及应用-颜沁睿 链接: https://pan.baidu.com/s/1c31ZcE 密码: r42j 3.SVO & LSD_SLAM解析 - 贺一家 链接: https://pan.baidu.com/s/1mimS6mO 密码: gp7i...
jquery 常用插件收集（有现成的就不用再自己写了和找了）
weixin_30444105的博客
05-23 193
1、轮播图插件 比较好的有 http://web.ue360.net/ui/ 比较复杂，但是绝对首选 2、手机上用的图片墙插件 http://www.photoswipe.com/ 3、多文件上传插件 很好用，比较复杂 http://blueimp.github.io/jQuery-File-Upload/ 还有一个比较简单是单文件的 叫做jquery uploddify ...
Java继承与多态：instanceof操作符解析
- `protected`修饰符允许子类访问父类的受保护成员，但不允许包外的其他类访问。 - `final`关键字用于声明一个类不能被继承，或者一个方法不能被重写，或者一个变量一旦赋值后就不能更改。 9. **Object类** 所有...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值