首页 > 编程语言 >Java从零到1的开始-Day11

Java从零到1的开始-Day11

时间：2025-01-15 09:00:15浏览次数：3  
标签：Java void 零到 Person Day11 println new public out

一、代码块

1构造代码块

1.格式:
  {
    代码
  }
2.执行特点:
  优先于构造方法执行,而且构造方法执行几次,构造代码块就执行几次

public class Person {
    public Person(){
        System.out.println("我是Person的无参构造");
    }

    //构造代码块
    {
        System.out.println("我是Person的构造代码块");
    }
}

public class Test01 {
    public static void main(String[] args) {
        Person person1 = new Person();
        Person person2 = new Person();
    }
}

2静态代码块

1.格式:
  static{
      代码
  }

2.执行特点:
  优先于构造方法以及构造代码块执行,只执行一次

public class Person {
    public Person(){
        System.out.println("我是Person的无参构造");
    }

    //构造代码块
    {
        System.out.println("我是Person的构造代码块");
    }

    //静态代码块
    static{
        System.out.println("我是Person的静态代码块");
    }
}

public class Test01 {
    public static void main(String[] args) {
        Person person1 = new Person();
        Person person2 = new Person();
    }
}

静态代码块以及构造代码块还有构造方法的执行顺序

静态代码块>构造代码块>构造方法

3.静态代码块使用场景

如果有一些数据需要先初始化,而且是需要初始化一次,那么这些数据就可以放到静态代码块中

二、内部类

1.什么时候使用内部类:
  当一个事物的内部,还有一个部分需要完整的结构进行描述,而这个内部的完整的结构又只为外部事物提供服务,那么整个内部的完整结构最好使用内部类
  比如:人类都有心脏,人类本身需要用属性,行为去描述,那么人类内部的心脏也需要心脏特殊的属性和行为来描述,此时心脏就可以定义成内部类,人类中的一个内部类
  
  当一个类内部的成员也需要用属性和行为描述时,就可以定义成内部类了
      
2.在java中允许一个类的定义位于另外一个类内部,前者就称之为内部类,后者称之为外部类
  class A{
      class B{
          
      }
  }
  A就是B的外部类
  B就是A的内部类
      
3.分类:
  成员内部类(静态,非静态)
  局部内部类
  匿名内部类(重点) -> 匿名内部类属于局部内部类一种

1 静态成员内部类

1.格式:直接在定义内部类的时候加上static关键字即可
  public class A{
      static class B{
          
      }
  }

2.注意:
  a.内部类中可以定义属性,方法,构造等
  b.静态内部类可以被final或者abstract修饰
    给final修饰,不能被继承
    被abstract修饰,不能new
  c.静态内部类不能调用外部的非静态成员
  d.内部类还可以被四种权限修饰符修饰
 
3.调用静态内部类成员:
  外部类.内部类 对象名 = new 外部类.内部类()

public class Person {
    public void eat(){
        System.out.println("人要吃饭");
    }

    /**
     * 静态成员内部类
     */
    static class Heart{
        public void jump(){
            System.out.println("心脏在咣咣咣地跳");
        }
    }
}

public class Test01 {
    public static void main(String[] args) {
        Person.Heart heart = new Person().new Heart();
        heart.jump();
    }
}

外部类的成员变量和内部类的成员变量以及内部类的局部变量重名时,怎么区分?

public class Student {
 String name = "张三";
 
 class Heart{
     String name = "李四";
     public void display(String name){
         System.out.println(name);//参数name 就近原则,先访问局部的
         System.out.println(this.name);//本类name  李四 
         System.out.println(Student.this.name);//外部类name  张三
     }
 }
}

3.局部内部类

1.局部内部类基本操作

1.可以定义在方法中,代码块中,构造方法中

public class Person {
    public void eat(){
        //局部内部类
        class Heart{
            public void jump(){
                System.out.println("跳跳跳跳");
            }
        }

        Heart heart = new Heart();
        heart.jump();
    }
}

public class Test01 {
    public static void main(String[] args) {
        Person person = new Person();
        person.eat();
    }
}

2.局部内部类实际操作

1.接口类型作为方法参数传递和返回

接口作为方法参数传递,传递的是实现类对象

接口作为方法返回值返回,返回的也是实现类对象

public interface USB {
    public abstract void open();
}

public class Mouse implements USB{
    @Override
    public void open() {
        System.out.println("鼠标打开了");
    }
}

public class Test01 {
    public static void main(String[] args) {
        Mouse mouse = new Mouse();
        method(mouse);
        System.out.println("==============");
        USB usb = method02();//USB usb = mouse
        usb.open();
    }

    public static void method(USB usb){//USB usb = mouse
        usb.open();
    }

    public static USB method02(){
        Mouse mouse = new Mouse();
        return mouse;
    }
}

2.抽象类作为方法参数和返回值

1.抽象类作为方法参数传递,传递的是子类对象

2.抽象类作为方法返回值返回,返回的也是子类对象

public abstract class Animal {
    public abstract void eat();
}

public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗啃骨头");
    }
}

public class Test01 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        method01(dog);
        System.out.println("============");
        Animal animal = method02();
        animal.eat();

    }

    public static void method01(Animal animal){//Animal animal = dog
        animal.eat();
    }

    public static Animal method02(){
        return new Dog();
    }
}

3.普通类做方法参数和返回值

1.普通类做方法参数传递,传递的是对象

2.普通类做方法返回值返回,返回的也是对象

public class Person {
    public void eat(){
        System.out.println("人要吃饭");
    }
}


public class Test01 {
    public static void main(String[] args) {
        Person person = new Person();
        method(person);
        System.out.println("==============");
        Person person1 = method01();
        person1.eat();
    }
    public static void method(Person person){
        person.eat();
    }

    public static Person method01(){
        return new Person();
    }
}

4.局部内部类实际操作

public interface USB {
    public abstract void open();
}
public class Test01 {
    public static void main(String[] args) {
        USB usb = method();
        usb.open();
    }

    /**
     * 接口类型作为方法返回值返回,我们应该返回的是USB的实现类对象
     * @return
     */
    public static USB method(){
        class Mouse implements USB{
            @Override
            public void open() {
                System.out.println("USB开启");
            }
        }
        return new Mouse();
    }
}

4.匿名内部类(重点)

1.之前写的局部内部类我们是显式的声明出了这个内部类叫啥,所以我们可以理解为这个叫做有名的内部类,而且这个内部类都是做了接口的实现类使用
    
2.匿名内部类:没有显式地定义出来的内部类(咱们看不见定义内部类这个操作),这个匿名内部类,也是做接口的实现类使用
    
3.如何快速学习匿名内部类:
  a.知道所谓的匿名内部类就是没有显式定义出来的内部类
  b.直接从new匿名内部类的对象开始学习

1.匿名内部类基本使用

1.格式1:利用匿名对象的方式来创建匿名内部类对象
  new 接口/抽象类(){
     重写方法  
  }.重写的方法();

  好比是: new Person().eat()

2.格式2:利用有名对象的方式来创建匿名内部类对象
  接口名/抽象类名 对象名 =  new 接口/抽象类(){
     重写方法  
  };

  对象名.重写的方法();

  好比是: Person p = new Person() 
         p.eat()

3.作用:
  假如,我们就只临时实现一下某个接口的某个抽象方法,然后临时调用一次这个重写的方法,我们之前的做法:
  a.定义一个实现类
  b.实现这个接口
  c.重写我们要调用的方法
  d.创建这个实现类对象,调用重写的方法
      
  如果接口中的方法只调用一次,我们就没有必要写以上四步了,因为为了简单的一次调用做以上四步操作,麻烦
  所以我们可以考虑使用匿名内部类方式去实现想要调用的方法
      
  从格式上来看,我们使用匿名内部类去实现想要调用的方法,我们用了一种格式代替了以上四步骤 -> 四合一

public interface USB {
    void open();
}


public class Test01 {
    public static void main(String[] args) {
        /*
           1.格式1:利用匿名对象的方式来创建匿名内部类对象
             new 接口/抽象类(){
                重写方法
             }.重写的方法();

             好比是: new Person().eat()
         */
        new USB(){
            @Override
            public void open() {
                System.out.println("USB打开了");
            }
        }.open();

        System.out.println("========================");

        /*
          2.格式2:利用有名对象的方式来创建匿名内部类对象
                 接口名/抽象类名 对象名 =  new 接口/抽象类(){
                    重写方法
                 };

                 对象名.重写的方法();

                 好比是: Person p = new Person()
                        p.eat()
         */
        USB usb = new USB(){
            @Override
            public void open() {
                System.out.println("usb又打开了");
            }
        };

        usb.open();
    }
}

2 匿名内部类复杂用法_当参数传递

public interface USB {
    public abstract void open();
}


public class Test {
    public static void main(String[] args) {
        method(new USB() {
            @Override
            public void open() {
                System.out.println("open");
            }
        });
    }

    public static void method(USB usb){
        usb.open();
    }
}

3 匿名内部类复杂用法_当返回值返回

public interface USB {
    public abstract void open();
}

public class Test02 {
    public static void main(String[] args) {
        USB usb = method();
        usb.open();
    }

    public static USB method(){
        return new USB() {
            @Override
            public void open() {
                System.out.println("usb打开了");
            }
        };

        /*USB usb = new USB() {
            @Override
            public void open() {
                System.out.println("usb打开了");
            }
        };

        return usb;*/
    }
}

三、lombok

如何导入第三方jar包:
 1.在当前模块下创建文件夹-> 右键 -> new -> Directory(文件夹) -> 取名为lib或者libs
 2.将想要导入的jar包粘贴到lib文件夹下
 3.解压jar包 -> 对着想要解压的jar包或者对着lib文件夹右键 -> add as library -> level选项中选择module,此时上面名字叫做name的输入框会变成空的-> ok   

1.概述:属于第三方工具
2.作用:简化javabean开发
3.使用:
  a.导入jar包
  b.使用里面的注解

1.lombok介绍

Lombok通过增加一些“处理程序”，可以让javabean变得简洁、快速。

Lombok能以注解形式来简化java代码，提高开发效率。开发中经常需要写的javabean，都需要花时间去添加相应的getter/setter，也许还要去写构造器、equals等方法，而且需要维护。

Lombok能通过注解的方式，在编译时自动为属性生成构造器、getter/setter、equals、hashcode、toString方法。出现的神奇就是在源码中没有getter和setter方法，但是在编译生成的字节码文件中有getter和setter方法。这样就省去了手动重建这些代码的麻烦，使代码看起来更简洁些。

2.lombok常用注解

1.@Getter和@Setter

  • 作用：生成成员变量的get和set方法。

  • 写在成员变量上，指对当前成员变量有效。

  • 写在类上，对所有成员变量有效。

  • 注意：静态成员变量无效。

2.@ToString

  • 作用：生成toString()方法。

  • 注解只能写在类上。

3.@NoArgsConstructor和@AllArgsConstructor

  • @NoArgsConstructor：无参数构造方法。

  • @AllArgsConstructor：满参数构造方法。

  • 注解只能写在类上。

4.@EqualsAndHashCode

  • 作用：生成hashCode()和equals()方法。

  • 注解只能写在类上。

5.@Data

  • 作用：生成get/set，toString，hashCode，equals，无参构造方法

  • 注解只能写在类上。

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Person {
    private String name;
    private int age;
}

public class Test01 {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("涛哥");
        person.setAge(18);
        System.out.println(person.getName()+"..."+person.getAge());
        System.out.println("=======================");
        Person person2 = new Person("小明", 18);
        System.out.println(person2.getName()+"..."+person2.getAge());
    }
}

四、单元测试

1.Junit介绍

1.概述:单元测试框架
2.作用:代替main方法测试其他开发好的方法是否能运行成功,以及查看结果
3.使用:导入Junit的jar包

2.Junit的基本使用(重点)

1.在要测试的方法上面用注解: @Test

public class Demo01Junit {
    @Test
    public void test01(){
        System.out.println("我是@Test");
    }
}

3.Junit的注意事项

1.@Test不能修饰带参数的方法
2.@Test不能修饰带返回值的方法
3.@Test不能修饰静态方法

4.Junit相关注解

@Before:在@Test之前执行,有多少个@Test一起执行@Before就执行多少次 -> 初始化数据
@After:在@Test之后执行,有多少个@Test一起执行@After就执行多少次 -> 销毁对象使用

public class Demo01Junit {
    @Test
    public void test01(){
        System.out.println("我是@Test");
    }

    @Test
    public void test02(){
        System.out.println("我是@Test");
    }

    @Before
    public void testBef(){
        System.out.println("我是@Before");
    }

    @After
    public void testAft(){
        System.out.println("我是@After");
    }
}

5.@Test以后怎么使用

public class Demo02CategoryJunit {
    
    /**
     * 测试添加商品分类的方法
     */
    @Test
     public void insert(){
         CategoryImpl category = new CategoryImpl();
         boolean result = category.insertCategory("服装", "箱包", "手机", "电脑");
         System.out.println("result = " + result);
     }

    /**
     * 测试查询所有商品分类的方法
     */
    @Test
    public void selectAll(){
        CategoryImpl category = new CategoryImpl();
        ArrayList<String> list = category.selectAllCategory();
        System.out.println(list);
    }
}


public class CategoryImpl {
    /**
     * 添加功能
     */

    public boolean insertCategory(String...str){
        /*
           创建集合-> ArrayList
           <String> 规定集合中能存储什么类型的数据
         */
        ArrayList<String> list = new ArrayList<>();
        for (int i = 0; i < str.length; i++) {
            //将元素放到集合中
            list.add(str[i]);
        }

        return true;
    }

    /**
     * 查询所有分类
     */
    public ArrayList<String> selectAllCategory(){
        ArrayList<String> list = new ArrayList<>();
        list.add("手机");
        list.add("电脑");
        list.add("服装");
        list.add("图书");
        list.add("食品");
        list.add("运动");
        list.add("家电");
        list.add("家具");
        list.add("食品");
        return list;
    }
}

标签：Java,void,零到,Person,Day11,println,new,public,out
From： https://blog.csdn.net/NJG1013/article/details/145152101

相关文章

  • 解决 IDEA 编译报错：Error:(2048,1024) java: 找不到符号
    摘要在使用IntelliJIDEA开发Java项目时，“找不到符号”(Cannotfindsymbol)是一种常见的编译错误。本文将从初学者的角度，详细分析这一问题的可能原因，提供排查步骤，并附上代码示例，帮助你快速解决问题。引言“找不到符号”是Java编译器的一种错误提示，通常发生在......
  • 基于JAVA学生信息管理系统设计与实现(源码+文档 )
    目录一.研究目的二.需求分析三.数据库设计 四.系统页面展示五.免费源码获取方式一.研究目的信息数据的处理完全依赖人工进行操作，会耗费大量的人工成本，特别是面对大量的数据信息时，传统人工操作不仅不能对数据的出错率进行保证，还容易出现各种信息资源的低利用率与低安全......
  • 数据结构——链表(概念，类型，java实现、增删、优缺点)
    文章目录链表链表介绍链表类型1.单向链表2.双向链表3.循环链表链表实现(增删改查)链表节点插入节点删除节点链表的特点与优势......
  • Java个人驾校预约管理系统web驾校教练预约系统springboot/ssm代码编写
    Java个人驾校预约管理系统web驾校教练预约系统springboot/ssm代码编写基于springboot(可改ssm)+html+vue项目开发语言：Java框架：springboot/可改ssm+vueJDK版本：JDK1.8（或11）服务器：tomcat数据库：mysql5.7（或8.0）数据库工具：Navicat/sqlyog开发软件：eclipse/idea依赖管理......
  • 【Java开发】Java、Maven、gradle、SQL、Redis常用命令大全：java程序员必备神器
    在Java开发的世界中，掌握Java、Maven、Gradle、SQL、Redis的常用命令是每个程序员的必修课。无论是构建项目、管理依赖，还是操作数据库，这些工具都能让你的开发效率提升一个档次！本文将为你整理一份超实用的命令清单，助你成为开发高手！一、Java：核心开发语言......
  • java面向对象（一）
    面向对象面向对象编程面向过程的程序设计思想（Process-OrientedProgramming），简称POP关注的焦点是过程：过程就是操作数据的步骤，如果某个过程的实现代码在很多地方重复出现，那么就可以把这个过程抽象为一个函数，这样就可以大大简化冗余代码，也便于维护。代码结构：以函数为组织单......
  • java面向对象（二）
    面向对象特征二：继承通过extends关键字，可以声明一个类B继承另外一个类A，定义格式如下：[修饰符]class类A{ ...}[修饰符]class类Bextends类A{ ...}继承中的基本概念类B，称为子类、派生类(derivedclass)、SubClass类A，称为父类、超类、基类(baseclass)、SuperCla......
  • Java 语法糖详解
    什么是语法糖？语法糖（SyntacticSugar） 也称糖衣语法，是英国计算机学家Peter.J.Landin发明的一个术语，指在计算机语言中添加的某种语法，这种语法对语言的功能并没有影响，但是更方便程序员使用。简而言之，语法糖让程序更加简洁，有更高的可读性。 有意思的是，在编程领域，除了语法糖......
  • 基于Java的愤怒的小鸟游戏的设计与实现【源码+文档+部署讲解】
    目录摘要Abstract1 绪论1.1游戏开发的背景1.2典型的Java游戏介绍1.2.1Minecraft介绍1.2.2SuperMarioBros介绍1.2.3 TheSims介绍1.3 游戏开发的意义2开发环境2.1开发语言2.2开发工具2.3JDK介绍2.4Java Awt介绍2.5 Java Swi......
  • 【吐血整理】Java 的 MyBatis 从入门到精通。
    目录❤️二、开发环境搭建指南......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99