Java两周半速成之路（第八天)

已于 2024-03-04 09:00:22 修改
阅读量884 收藏 24
点赞数 24
分类专栏： Java 文章标签： java
于 2024-03-03 07:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52134189/article/details/136402164
版权
本文详细解释了Java中的形式参数和返回值类型，包括基本类型和引用类型（类、抽象类、接口）的处理规则。此外，文章还介绍了包的概念、包的划分、类的修饰符、成员内部类、局部内部类以及匿名内部类的使用。
摘要由CSDN通过智能技术生成

一.形式参数和返回值问题

1.形式参数：

基本类型: byte,short,int,long,float,double,boolean,char

引用类型:类，抽象类，接口

1.1     类：当一个类作为方法参数类型传递的时候，将来调用时应该传入该的类对象

演示：

package com.shujia.day09;
/*
    形式参数
        基本类型: byte,short,int,long,float,double,boolean,char
        引用类型:
            类：当一个类作为方法参数类型传递的时候，将来调用时应该传入该的类对象
            抽象类：
            接口：

 */

public class Student1 {
    public void show(){
        System.out.println("断桥是否下过雪");
    }
}
class Demo1{
    public void fun(Student1 s1){
        s1.show();
    }
}

class Test1{
    public static void main(String[] args) {
        Demo1 demo1 = new Demo1();
        Student1 s1 = new Student1();
        demo1.fun(s1);

    }
}

1.2       抽象类：当你看到一个抽象类作为方法形式参数类型的时候，将来调用时，应该传入该抽象类的具体子类的对象 

演示：

/*
    形式参数
        基本类型: byte,short,int,long,float,double,boolean,char
        引用类型:
            类：当一个类作为方法参数类型传递的时候，将来调用时应该传入该的类对象
            抽象类：当你看到一个抽象类作为方法形式参数类型的时候，将来调用时，应该传入该抽象类的具体子类的对象
            接口：

 */

abstract class Demo2 {

    abstract void print1();

    public void show() {
        System.out.println("桃花岛屿之间");
    }
}

class DemoZi extends Demo2 {
    @Override
    void print1() {
        System.out.println("输出：许嵩");
    }
}

public class Student2 {
    public void fun2(Demo2 d2) {           // Demo2 d2 = new DempZi    抽象多态
        d2.show();
    }
}

class Test {
    public static void main(String[] args) {
        Student2 s2 = new Student2();
        DemoZi demoZi = new DemoZi();
        s2.fun2(demoZi);

    }
}

1.3 接口：当你看到一个接口作为方法形式参数类型的时候，将来调用该方法时，应该传入实现该接口的具体子类对象

演示：

/*
    形式参数
        基本类型: byte,short,int,long,float,double,boolean,char
        引用类型:
            类：当一个类作为方法参数类型传递的时候，将来调用时应该传入该的类对象
            抽象类：当你看到一个抽象类作为方法形式参数类型的时候，将来调用时，应该传入该抽象类的具体子类的对象
            接口：当你看到一个接口作为方法形式参数类型的时候，将来调用该方法时，应该传入实现该接口的具体子类对象
 */

interface JieKou1{
    public void print1();
}


class Demo3{
    public void show(JieKou1 j1){   //JieKou j1 = new Demo4();         //接口多态
        j1.print1();
    }
}

class Demo4 implements JieKou1{
    @Override
  public void print1(){
      System.out.println("许嵩");
  }
}

public class Student3 {
    public static void main(String[] args) {
        Demo3 demo3 = new Demo3();
        demo3.show(new Demo4());

    }
}

 2.返回值类型

返回值类型：

                基本类型:  byte,short,int,long,float,double,boolean,char

                引用类型:类，抽象类，接口

2.1类：当你看到一个类作为方法的返回值类型的时候，将来方法内部定义时应该返回该类的对象

演示:


/*
    返回值类型
        基本类型: byte,short,int,long,float,double,boolean,char
        引用类型:
            类：当你看到一个类作为方法的返回值类型的时候，将来方法内部定义时应该返回该类的对象
            抽象类：
            接口：

 */

class TeacherDemo1{
    public void fun1(){
        System.out.println("雅俗共赏");
    }
}

class TeacherDemo2{
    public TeacherDemo1 show(){   //类：当你看到一个类作为方法的返回值类型的时候，将来方法内部定义时应该返回该类的对象
     return new TeacherDemo1();
    }
}

public class Teacher1 {
    public static void main(String[] args) {
        TeacherDemo2 t2 = new TeacherDemo2();
        t2.show().fun1();             //t2.show返回的是一个TeacherDemo1对象，之后调用fun()方法
    }
}

 2.2抽象类：当你看到一个抽象类作为方法的返回值类型的时候，将来方法内部定义时应该返回该抽象类具体子类对象

演示：


/*
    返回值类型
        基本类型: 跳过
        引用类型:
            类：当你看到一个类作为方法的返回值类型的时候，将来方法内部定义时应该返回该类的对象
            抽象类：当你看到一个抽象类作为方法的返回值类型的时候，将来方法内部定义时应该返回该抽象类具体子类对象
            接口：

 */

 abstract class TeacherDemo3 {
    public void print() {
        System.out.println("许嵩");
    }
}

class TeacherDemo3Zi extends TeacherDemo3 {

}

class TeacherDemo4 {
    public TeacherDemo3 show() {
        return new TeacherDemo3Zi();
    }
}
public class Teacher2 {
    public static void main(String[] args) {
        TeacherDemo4 t4 = new TeacherDemo4();   //第一种
        t4.show().print();
        TeacherDemo3 tt3 = t4.show();          //第二种
        tt3.print();

    }
}

 3.3       接口：当你看到一个接口作为方法的返回值类型的时候，将来方法内部定义时应该返回实现该接口的具体子类对象

/*
    返回值类型
        基本类型: 跳过
        引用类型:
            类：当你看到一个类作为方法的返回值类型的时候，将来方法内部定义时应该返回该类的对象
            抽象类：当你看到一个抽象类作为方法的返回值类型的时候，将来方法内部定义时应该返回该抽象类具体子类对象
            接口：当你看到一个接口作为方法的返回值类型的时候，将来方法内部定义时应该返回实现该接口的具体子类对象
 */

interface JieKou2{
    void jiSuan();
}


class JieKOuTmpl implements JieKou2 {
    @Override
    public void jiSuan() {
        System.out.println("计算");
    }
    
}

class Teacher3Demo{
    public JieKou2 show(){
        return new JieKOuTmpl() ;
    }
}

class Test2{
    public static void main(String[] args) {
        Teacher3Demo t3 = new Teacher3Demo();
        JieKou2 j2 = t3.show();
        j2.jiSuan();



    }
}

二.包

1.包:其实就是文件夹

2.作用：  

(1)方便管理查找对应的文件
(2)让工程与工程之间的关系更加清晰，将来修改的时候方便一些

3.包的划分:

一般情况下，包会按照两种类型进行划分：
(1)按照角色划分
(2)按照功能划分

举例：

基于ssm的xxxx管理系统
老师（增删改查）
学生（增删改查）

一般情况下，包的划分是不会频繁更新的
1、按照角色划分
    老师(包)
        增加.java
        删除.java
        修改.java
        查询.java
    学生(包)
        增加.java
        删除.java
        修改.java
        查询.java

2、按照功能划分
    增(包)
        老师增加.java
        学生增加.java
    删(包)
        老师删除.java
        学生删除.java
    改(包)
        老师修改.java
        学生修改.java
    查(包)
        老师查询.java
        学生查询.java

3.SpringBoot结构：（面试题）
    --Controller     主要是前端与后端的交互层
    --entity(pojo)   实体类层
    --dao            数据库操作接口层
    --service        实现类接口层
        --serviceImpl
    --utils          工具类层

4.定义包的格式:

                            package 包名;            (多级包用.分开即可)

注意事项： package语句必须是程序的第一条可执行的代码

                   package语句在一个java文件中只能有一个

                   如果没有package，默认表示无包名

 5.导包

格式：import 包名;

注意： 这种方式导入是到类的名称。 虽然可以最后写*（表示导入一个包下所有的类），但是不建议。

6.权限修饰符

 三.类及其组成可以用的修饰符

四种权限修饰符：public，protected，默认的，private

四. 内部类

1.概述：

                 把类定义在其他类的内部，这个类就被称为内部类。

2. 分类：

成员内部类：在类中方法外定义的类，叫做成员内部类

局部内部类：在方法内部定义的类，叫做局部内部类

3.创建成员内部类对象的语法：

成员内部类（非静态）：

                         外部类名.内部类名  对象名 = new  外部类名().new 内部类名();

演示：



class Outer1 {
    //成员变量
    private int a = 10;

    //成员内部类
    class Inner1 {
        public void show() {
            System.out.println(a);  //在成员内部类可以获取成员变量
        }
    }
}

public class InnerDemo1 {
    public static void main(String[] args) {
        Outer1.Inner1 oi1 = new Outer1().new Inner1();  //创建内部类对象
        oi1.show();
    }
}

3.注意：

1、成员内部类（非静态）既可以访问外部类的中的成员变量，也可以是私有的成员变量

2、内部类都不会单独编译出一个class文件

3.成员内部类可以使用private关键字和static关键字进行修饰，如果内部类被privata修饰，则其他类中无法创建内部类的对象了

演示：

/*
 成员内部类可以使用private关键字和static关键字进行修饰
 */

class Outer2 {

    //如果内部类被privata修饰，则其他类中无法创建内部类的对象了
    private class Inner2 {
        public void fun1() {
            System.out.println("庐州月光");
        }
    }
    public void show(){
        //创建成员内部类
        Inner2 inner2 = new Inner2();
        inner2.fun1();
    }
}

public class InnerDemo2 {
    public static void main(String[] args) {
        Outer2 outer2 = new Outer2();
        outer2.show();
    }
}

4. 创建静态的成员内部类的对象语法：

                       外部类名.内部类名 对象名 = new 外部类名.内部类名();

演示：

/*
创建静态的成员内部类的对象语法：
           外部类名.内部类名 对象名 = new 外部类名.内部类名();
 */

class Outer3 {


    static class Inner3 {         //class Inner3
        public void show() {
            System.out.println("千百度");
        }
    }

    public void fun() {
        Inner3 inner3 = new Inner3();
        inner3.show();
    }
}

public class InnerDemo3 {
    public static void main(String[] args) {

        //当内部类为静态
        //  创建静态的成员内部类的对象语法：
        //  外部类名.内部类名 对象名 = new 外部类名.内部类名();
        Outer3.Inner3 oi3 = new Outer3.Inner3();
        oi3.show();
//       new Outer3.Inner3().show();
//
    }
}

 5.局部内部类：将类定义在类中方法的内部

演示：

package com.shujia.day09.InnerClass;

/*
    局部内部类：将类定义在类中方法的内部

 */
class Outer4 {
    int a = 80;

    public void fun1() {
        //局部变量
        int a = 10;

        //在这里定义的类，叫做局部内部类
        class Inner4 {

            public void show() {
//                a = 40;  //   在JDK1.8之后，方法中的局部变量在内部中无法修改
                System.out.println(a);
                System.out.println("孤芳自赏");
            }
        }
        Inner4 inner4 = new Inner4();
        inner4.show();
    }

}

public class InnerDemo4 {
    public static void main(String[] args) {
        Outer4 outer4 = new Outer4();
        outer4.fun1();
    }
}

 五.匿名内部类

1.匿名内部类的语法定义格式：

                  Xxx xx =  new  类名/抽象类名/接口(){  重写方法;  }

演示：


abstract class Demo1{
    abstract void show();
}

//class Demo1Zi extends Demo1{
//    @Override
//    void show() {
//        System.out.println("我乐意");
//    }
//}
class Demo2{
    public void fun1(Demo1 demo1){
        demo1.show();
    }
}
public class NiminDemo2 {
    public static void main(String[] args) {
        Demo2 demo2 = new Demo2();
        demo2.fun1(new Demo1() {          //匿名内部类
            @Override
            void show() {
                System.out.println("年少初遇");
            }
        });
//        demo2.fun1(new Demo1Zi());
    }
}

匿名内部类的练习：

按照要求，补齐代码：

   interface Inter { void show(); }
class Outer { //补齐代码 }
class OuterDemo {
    public static void main(String[] args) {
          Outer.method().show();
      }
}

要求在控制台输出”HelloWorld”

第一种（不用匿名内部类）：

/*
    interface Inter { void show(); }
	class Outer { //补齐代码 }
	class OuterDemo {
	    public static void main(String[] args) {
		      Outer.method().show();
		  }
	}

	要求在控制台输出”HelloWorld”

 */
interface Inter {
    void show();
}

class InterTmpl implements Inter {
    public void show() {
        System.out.println("hello world");
    }
}

class Outer {
    public static Inter method() {
        return new InterTmpl();           //当你看到一个接口作为方法的返回值类型的时候，方法内部返回的是实现了该接口的具体子类对象
    }
}

public class NiMIngTest {
    public static void main(String[] args) {
        //分析：
        //1、发现method()直接可以通过Outer5类名的方式进行调用，说明method()是静态的
        //2、发现调用完method()之后，可以继续调用show方法，而show方法在接口中，说明method()调用完毕之后返回的是Inter类型的对象
        Outer.method().show();
    }
}

第二种（使用匿名内部类）：

/*
    interface Inter { void show(); }
	class Outer { //补齐代码 }
	class OuterDemo {
	    public static void main(String[] args) {
		      Outer.method().show();
		  }
	}

	要求在控制台输出”HelloWorld”

 */

//使用 匿名内部类改写
interface Inter1 {
    void show();
}

class Outer1 {
    public static Inter1 methond() {
        return new Inter1() {
            public void show() {
                System.out.println("hello world");
            }
        };
    }
}


public class NiMingTest2 {
    public static void main(String[] args) {
        Outer.method().show();

    }
}

灰太狼！！
关注
  • 24
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java编程21天速成!!.pdf
04-26
在Java中有3种方法表示整数 –十进制(0~9)：不需要任何解释 •int i = 99; –八进制(0~7)：在数的前面放置一个0(零) •int six = 06; //值为6 •int nine = 011; //值为9 –十六进制(0~9,a~f)：在数前放置0x或者0X ...
【拯救者】javaSwing界面速成GUI(含实战)
07-01
是否苦恼于javaSwing界面编写?是否找不到合适的视频观看?是否考试要考swing界面?是否不满足于在黑窗口运行程序?..... 恭喜!你发现了宝藏!我们从基础知识入手,然后进行实战swing连接Mysql数据库,实现简单的登陆,带你...
Java两周半速成之路（第一天）
weixin_52134189的博客
02-20 483
关键字概述：被Java语言赋予特定含义的单词关键字特点： 组成关键字的字母全部小写 关键字注意事项：（1） goto和const作为保留字存在,目前并不使用 （2）类似IDEA这样的集成工具,针对关键字有特殊的颜色标记，非常直观 标识符：就是更类，方法，接口，变量等起名字时使用的字符序列组成规则： 由英文大小写字母，数字， $和_组成注意事项 ： 1. 不能以数字开头 2.不能是Java中的关键字
Java两周半速成之路（第二天）
weixin_52134189的博客
02-21 1194
1、在同一作用域（理解为一个大括号内部）下，变量名不能重复2、整数默认是int类型，要想定义一个long类型的变量，需要在值的后面加上L或者l，推荐L3、小数默认是double类型 要想定义一个float类型的变量,需要在值的后面加上F或者f，推荐F4、变量必须要有初始化值,否则无法使用。
Java两周半速成之路（第四天）
weixin_52134189的博客
02-25 1159
一维，二维数组的初始化以及在内存中的位置分配，数组排序和二分查找
Java两周半速成之路（第十一天）
weixin_52134189的博客
03-06 1440
Collection接口，基本数据结构，list接口，Vector类，LinkedList类，list集合练习
Java两周半速成之路（第十天）
weixin_52134189的博客
03-05 1046
String和StringBuffer的互相转换，String和StringBuffer作为方法的参数，Arrays类，包装类，Random类，Data类和DateFromat类,SimpleDateFormat
Java两周半速成之路（第十三天）
weixin_52134189的博客
03-11 1381
异常处理，file类，IO流（字节流和字符流）,序列化流（对象流）
Java两周半速成之路（第十二天）
weixin_52134189的博客
03-10 1015
泛型，增强for循环，方法的静态导入,可变参数，Set接口及其子类HashMap类和TreeMap类, 集合工具类Collections类
Java两周半速成之路（第五天）
weixin_52134189的博客
02-27 1058
面对对象的思想，类与对象及其使用，封装
Java两周半速成之路（第三天）
weixin_52134189的博客
02-25 999
for循环的语句定义格式：for(初始化条件语句;判断条件语句;控制条件语句){语句体;2.2 for循环注意事项：1、初始化条件语句只会在循环开始执行一次，后续不执行2、初始化条件语句可以提前写在for循环外面, 这样作用域在for循环外部也可以使用初始化条件语句定义的变量3、当for循环中的语句体只有一行的时候，大括号可以省略, 建议不要省略大括号4、判断条件语句能否不写？可以，但是不写就是无条件执行，会变成死循环5、最简单的for死循环就是for(;;){...}
21天速成Java学习指南.rar
04-05
day01-java开发前奏 day02变量、关键字 day03 流程控制语句 day04-函数与数组 day05-day09面向对象 day10-JavaAPI day11线程 day12-day15集合 day17JDK5.0新特性与正则表达式 day18-day21.IO 附赠Java进阶知识
Java学习速成笔记
03-23
本篇“Java学习速成笔记”旨在帮助读者在短期内快速掌握Java编程的核心概念和技术要点，并能够在学习后的七天内具备基本的工作能力。该笔记内容详实，既适合零基础的新手，也适合有一定编程经验但希望快速上手Java的...
Java编程速成教材
03-07
Java是一种跨平台的语言，一次编写，到处运行，在世界编程语言排行榜中稳居第二名（第一名是C语言）。 Java用途广泛，可以用来开发传统的客户端软件和网站后台，也可以开发如火如荼 Android 应用和云计算平台。 本...
J031_使用TCP协议支持与多个客户端同时通信
最新发布
lzn20161229的博客
08-03 186
使用TCP协议支持与多个客户端同时通信。
SpringBoot+Vue图书(图书借阅)管理系统-附项目源码与配套文档
m0_74283290的博客
08-03 602
本论文阐述了一套先进的图书管理系统的设计与实现，该系统采用Java语言，结合现代Web开发框架和技术，旨在为图书馆提供高效、灵活且用户友好的资源管理解决方案。系统利用Spring Boot框架为核心，整合MyBatis ORM工具，以及MySQL数据库，构建了一个高性能、可扩展的后端服务。前端界面则采用了Vue.js框架，以提供流畅的用户交互体验。论文首先进行了详尽的需求分析，确定了系统的核心功能，包括图书的添加、编辑、删除、查询，读者的注册、登录、个人信息管理，以及图书的借阅、归还、续借流程。
社区养老服务小程序的设计
Karen198的博客
07-31 525
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
深入理解Java注解
weixin_55745942的博客
08-01 565
Java注解是用来描述程序元素（如类、方法、变量等）的一种机制。它们可以提供关于程序的补充信息，帮助编译器、框架或其他工具更好地理解和处理代码。注解通常以符号开头，后跟注解名称和可能的参数。要创建自定义注解，需要使用@interface关键字定义一个接口，并在接口中声明注解的属性。这个注解名为，可以被用来标记方法。它有一个名为value的属性，具有默认值"default"。
Java编程21天速成指南：菜鸟起飞之路
"这是一本名为《21天学通java》的编程学习书籍，由Laura Lemay和Charles L. Perkins撰写，旨在帮助编程初学者在21天内掌握Java语言，构建applets和应用程序。书中内容全面，适合有一定基础的读者，特别是对HTML、CGI...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值