Java学习第十天_面向对象学习第五天

最新推荐文章于 2024-08-06 10:22:43 发布
最新推荐文章于 2024-08-06 10:22:43 发布
阅读量82 收藏
点赞数
分类专栏： # Java EE学习记录 文章标签： java jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Survivor_susu/article/details/126133503
版权
本文详细讲解了Java源文件中关于public类的规定，非public类的默认修饰符，以及内部类的多种类型（成员内部类、静态内部类和局部内部类）。讨论了访问权限、实例化方式和常见应用场景，如匿名内部类、枚举和方法重载等。
摘要由CSDN通过智能技术生成

一个Java文件中定义多个类

  • 只能有一个public类

  • 其它的非public类只能默认修饰符，可以有多个非public类

  • 在public类里是可以访问非public的类（因为在同一个包下）

package com.hqyj;

//一个源文件中只能有一个public类，类名跟文件名相同
public class A {
    public static void main(String[] args) {
        B b = new B();
        b.btest();
    }
}

//一个源文件中还可以有其它的非public(只能是默认修饰符)的类
class B{
    public void btest(){
        System.out.println("B类的方法");
    }
}

class D{
    
}

内部类

定义在类中的类称为内部类

作用是封装，一般自己使用的类定义为内部类，不让别的类知道或使用这个内部类

成员内部类（内部类定义在大括号里）

  • 内部类定义为一个成员（跟成员变量或方法同一级）

  • 内部类可以用任意访问修饰符（一般起封装作用的话用private）

  • 内部类可以访问外部类的属性或方法；外部类不能直接访问内部类的属性或方法，只能通过对象去访问

  • 内部类的初始化要借助外部类的对象：Outer.Inner inner = outer.new Inner();

package com.hqyj;

public class Outer {
    private String id = "abcd123";

    private void funOuter(){
        System.out.println("外部类的方法funOuter");
    }

    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.funOuter();

        Outer.Inner inner = outer.new Inner();
        inner.funInner();
        System.out.println(inner.name);
    }

    private class Inner{
        public Inner() {
            System.out.println("Inner的构造方法");
        }

        private String name = "innerclass";

        private void funInner(){
            System.out.println(id);
            System.out.println("内部类的方法funInner");
            funOuter();
        }
    }
}

静态成员内部类

  • 如果成员内部类是静态的，创建内部对象的方式： Inner inner = new OuterStatic.Inner();
  • 内部类中只能访问外部类的静态属性和方法
  • 在外部类中可以通过内部类的类名直接访问内部类的静态属性和方法
package com.hqyj;

public class OuterStatic {
    private String nameOuter = "外部类的属性";
    private static String nameOuterStatic = "外部类的静态属性";

    private void funOuter(){
        System.out.println("外部类的方法");
//        System.out.println(nameInner);//不能访问内部类的属性
        //funInner();  //不能访问内部类的方法
    }
    private static void funStaticOuter(){
        System.out.println("外部类的静态方法");
        System.out.println(Inner.nameStaticInner);
        Inner.funStaticInner();
    }

    private static class Inner{
        private String nameInner = "内部类的属性";
        private static String nameStaticInner = "内部类的静态属性"; 

        private void funInner(){
            System.out.println("内部类的方法");
            System.out.println(nameOuterStatic);
            funStaticOuter();
        }
        
        private static void funStaticInner(){
            System.out.println("内部类的静态方法");
            System.out.println(nameOuterStatic);
            funStaticOuter();
        }
    }

    public static void main(String[] args) {
        OuterStatic outer = new OuterStatic();
        outer.funOuter();

        Inner inner = new OuterStatic.Inner();
        inner.funInner();
        System.out.println(Inner.nameStaticInner);
        OuterStatic.Inner.funStaticInner();
        
    }
}

局部内部类（定义在方法中）

  • 内部类定义在方法中
  • 内部类的对象创建只能在这个方法中，创建内部类的方式：Inner inner = new Inner();
  • 内部类可以访问外部类的属性和方法； 外部类不可以直接访问内部类的属性和方法，但是可以通过内部类的对象去访问
package com.hqyj;

public class OuterLocal {
    private String nameOuter = "外部类的属性";
    
    private void fun2Outer(){
        
    }

    private void funOuter(){
        System.out.println("外部类的方法");

        class Inner{
            private String nameInner = "内部类的属性";

            private void funInner(){
                System.out.println("内部类的方法");
                //内部类可以访问外部类的属性
                System.out.println(nameOuter);
                //内部类可以访问外部类的方法
                fun2Outer();
            }
        }

        // System.out.println(nameInner); //外部类不能直接访问内部类的属性
        // funInner(); //外部类不能直接访问内部类的方法
        
        Inner inner = new Inner();
        inner.funInner();
        System.out.println(inner.nameInner);
    }

    public static void main(String[] args) {
        OuterLocal outer = new OuterLocal();
        outer.funOuter();

    }

}

匿名内部类

类只用一次，所以没有类名

一般用在接口作为方法的参数的情况

  • Usb接口
package com.hqyj;

public interface Usb {
    void work();
}
  • Computer类

有一个方法的参数是Usb接口类型

package com.hqyj;

public class Computer {
    //方法的参数是一个接口
    public void useUsb(Usb usb){
        usb.work();
    }

}
  • 调用接口参数的方法时，直接实现接口

这个接口的实现类没有名字，所以叫匿名类， 其它地方不可能用到它

package com.hqyj;

public class ComputerTest {
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.useUsb(new Usb() {
            @Override
            public void work() {
                System.out.println("鼠标正在工作...");
            }
        });
    }
}

枚举 Enum

  • 枚举定义
package com.hqyj;

public enum Season {
    SPRING, SUMMER, AUTUMN, WINTER
}
  • 枚举的使用
package com.hqyj;

public class SeasonTest {
    public static void main(String[] args) {
        Season spring = Season.AUTUMN;
        switch (spring){
            case SPRING:
                System.out.println("春天播种");
                break;
            case SUMMER:
                System.out.println("夏天施肥");
                break;
            case AUTUMN:
                System.out.println("秋天收获");
                break;
            case WINTER:
                System.out.println("收藏种子");
                break;
        }
    }
}

类的方法

方法就是类的行为，通过方法执行一段代码，完成特定的功能

方法的定义：

[public] [static] [abstract] [fianl] 返回类型 方法名(类型 参数名, 类型 参数名){

​ //方法体代码

}

方法的特性：

  • 除构造方法外，所有的方法都有返回类型，如果不需要返回值，返回类型是void

  • 如果有返回值，方法必须有return语句（保证每一个分支都有return 语句），return语句后不能再有其它代码

  • 方法可以无参数，有参数，还可以是不定长的参数

  • 可变长参数放在方法参数的最后一个， 类型后面加3个点， 可变长参数在方法中当数组处理

  • 方法同名，参数不同，就构成重载。可变长参数方法和固定长度参数的方法同时存在，优先调用定长参数的方法

    public void fun1(){
        System.out.println("没有返回值，返回类型是void");
    }

    //有返回类型，方法体必须有return语句，返回的内容必须跟返回类型一致
    //    保证每一个分支都有返回语句
    public String getName(){
        String name = "";
        if( 3 > 2){
            name =  "姓名";
        }else {

        }
        return name;

/*
        if( 3 > 2){
           return  "姓名";
        }else {
            return "";
        }*/
    }

    //固定个数参数
    public int sum(int a, int b){
        System.out.println("a,b");
        return a + b;
    }

    //类型后面有三个点参数叫可变长参数
//    可变长的参数只能是方法的最后一个参数
//    可变参数可以当数组处理
    public int sum(int a, int... b){
        System.out.println("a, b...");
        int sum = 0;
        sum += a;
        for (int tmp : b) {
            sum += tmp;
        }
        return sum;
    }

    public static void main(String[] args) {
        MethodDemo methodDemo = new MethodDemo();
        System.out.println(methodDemo.sum(1, 2, 3, 4, 5, 6));
    }

传值调用和传引用调用

形参：形式参数，定义方法时给出参数名

//a, b就叫形参
public int sum(int a, int b){
    
}

实参：实际参数，调用方法时传的变量

int m = 3, n = 2;
//m,n 就叫实参
sum(m, n);
  • 传值调用

当参数类型为基本类型时，在方法里面改变形参的值，不影响实参（理解为调用方法时copy了一份参数）

//定义方法
public int sum(int a, int b){
        int sum = a + b;
        a++;
        b--;
        return sum;
    }

//调用方法
       int x = 10;
        int y = 20;
        int sum = methodDemo.sum(x, y);
        System.out.println(sum);
        System.out.println("x:" + x + ", y:" + y); //x:10, y:20
  • 传引用调用

当参数类型为引用类型（类，接口，数组），在方法里面改变这个对象的值，实参的对象的值也跟着改变（因为它们指向的是堆中的同一个对象实例）

Student实体类

package com.hqyj;

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

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

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

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

测试类

package com.hqyj;

public class StudentTest {
    public static void main(String[] args) {
        StudentTest test = new StudentTest();
        Student student = new Student("张三", 22);
        test.updateStudent(student);
        System.out.println(student);
    }

    public void updateStudent(Student stu){
        stu.setAge(25);
    }
}

方法的递归调用

方法里面调用自己，替代循环代码

(理解递归调用，知道方法被调用会在栈里压入一个方法帧，直到最后一次调用方法结束，再依次出栈，返回)

//    求1~n的和的递归方法
    public int sumone2n(int n){
        if(n == 1){
            return 1;
        }else {
            return n + sumone2n(n - 1);
        }
    }

//    求n的阶乘的递归方法
    public int factorial(int n){
        if(n == 0){
            return 1;
        }else{
            return  n * factorial(n - 1);
        }
    }

//    斐波那契数列用递归
    public long fibonacci(int n){
        if(n == 1 || n == 2){
            return 1;
        }else {
            return fibonacci(n - 1) + fibonacci(n - 2);
        }
    }
王上大人
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
完整版 Java编程基础入门教程 Java语言程序设计 第3章_面向对象程序设计基础（共16页）.ppt
12-18
Java编程基础入门教程的第三章主要讲解了面向对象程序设计的基础知识。面向对象编程（OOP）是一种基于对象和类的编程范式，它强调通过模拟现实世界中的实体及其交互来构建软件系统。以下是该章节的主要知识点： 1. ...
JAVA学习笔记第九、十、十一天——飞机大战
07-25
在第九、十、十一天的学习笔记中，我们将重点关注如何构建和使用这些核心概念，以及它们在实际编程中的应用。 首先，类是JAVA面向对象编程的基础，它是对象的蓝图或模板。在"飞机大战"的实现中，我们可以创建多个类...
java面向对象程序设计第4章源代码
03-09
在Java编程语言中，面向对象程序设计（Object-Oriented Programming, OOP）是一种核心的编程范式，它基于“对象”概念，将数据和处理数据的方法封装在一起。本章节的源代码着重于讲解和实践Java中的面向对象特性，...
java面向对象程序设计第5章源代码
03-09
以上是Java面向对象程序设计第5章可能涵盖的一些关键知识点，通过深入理解和实践，可以为后续的Java编程打下坚实的基础。在实际编程过程中，这些概念会被广泛运用，以构建高效、可维护的软件系统。
J031_使用TCP协议支持与多个客户端同时通信
lzn20161229的博客
08-03 406
使用TCP协议支持与多个客户端同时通信。
C++ - 函数重载
最新发布
jiaowenjie的专栏
08-06 158
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
SpringBoot+Vue图书(图书借阅)管理系统-附项目源码与配套文档
m0_74283290的博客
08-03 1236
本论文阐述了一套先进的图书管理系统的设计与实现，该系统采用Java语言，结合现代Web开发框架和技术，旨在为图书馆提供高效、灵活且用户友好的资源管理解决方案。系统利用Spring Boot框架为核心，整合MyBatis ORM工具，以及MySQL数据库，构建了一个高性能、可扩展的后端服务。前端界面则采用了Vue.js框架，以提供流畅的用户交互体验。论文首先进行了详尽的需求分析，确定了系统的核心功能，包括图书的添加、编辑、删除、查询，读者的注册、登录、个人信息管理，以及图书的借阅、归还、续借流程。
枚举工具类
qq_43049583的博客
08-04 389
java枚举工具类
等待唤醒机制两种实现方法-阻塞队列
泰勒今天想展开的博客
08-04 482
桌子上有面条-》吃货执行桌子上没面条-》生产者制造执行。
深入理解Java注解
weixin_55745942的博客
08-01 715
Java注解是用来描述程序元素（如类、方法、变量等）的一种机制。它们可以提供关于程序的补充信息，帮助编译器、框架或其他工具更好地理解和处理代码。注解通常以符号开头，后跟注解名称和可能的参数。要创建自定义注解，需要使用@interface关键字定义一个接口，并在接口中声明注解的属性。这个注解名为，可以被用来标记方法。它有一个名为value的属性，具有默认值"default"。
社区养老服务小程序的设计
Karen198的博客
07-31 738
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
Springboot+Websocket+Security+Vue 实现弹幕推送功能
Gemini1995的博客
08-01 704
【代码】Springboot+Websocket+Security+Vue 实现弹幕推送功能。
string类的模拟实现(C++)
2302_80190394的博客
08-02 1127
C++ string的功能函数实现
javaweb_03：在ide中配置tomcat
qq_52200849的博客
08-01 225
④创建artifact。②点击加号创建，选择。
Spring-包扫描
Promise_J_Z
08-03 241
二次判断类是否可独立实例化对象，内部类或者接口，抽象类都会对应生成一个.class文件，但是这些文件部分是不能够实例化的，不可以生成bean，所以在生成BeanDefinition之前需要进行过滤判断。对扫描到的BeanDefinition进行赋值，但是此时只是将className赋值到BeanDefinition中，因为还没有创建该类。spring在启动的时候就会往includeFilters中加入component注解。判断当前类是否需要当作bean进行处理。
在java java.util.Date 已知逝去时间怎么求年月日
huanghm88的专栏
08-05 262
这样，你就可以得到逝去时间的年月日。需要注意的是，这只是一个简单的方法，不考虑闰年等情况。如果你需要更准确的结果，可以使用其他时间处理库，如Joda-Time或java.time包。
java中static关键字的作用
weixin_41020960的博客
08-01 661
这意味着这个变量被类的所有实例共享，而不是每个实例拥有自己的副本。类变量可以通过类名直接访问，而不需要创建类的实例。关键字是 Java 中一个非常重要的特性，它允许开发者在不创建对象的情况下访问类的方法和变量，这在很多场景下非常有用。这类方法可以在没有创建类的实例的情况下被调用，它们只能访问类的静态变量和静态方法。关键字也可以用于静态初始化块，这是一段在类加载时执行的代码块，用于初始化静态变量。: 静态变量是不变的，一旦在静态初始化块或静态方法中被初始化，它们的值就不能被修改。关键字可以声明静态内部类。
linux安装weblogic
m0_46400195的博客
08-05 577
域文件位置就是python文件中设置的，位置（cd /root/web/weblogic/softWare/projects/doamins/testDomain）（以自己python为主）想要启动weblogic 12版本及以后都需要去oracle_common目录下配合启动脚本进行服务器启动。weblogic不允许root用户进行安装，所以要提前创建weblogic用户来进行安装。例如：http://192.168.0.143:7001/console。用户名：启动weblogic的用户名。
《Thinking in Java》中文第四版：深度探索面向对象编程
"Thinking In Java（中文版 第四版）" 《Thinking In Java》是由Bruce...《Thinking In Java》是一本全面而深入的Java教程，它不仅教授语言本身，还引导读者理解面向对象编程的哲学，是Java学习者不可或缺的参考资料。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值