类与对象笔记-Java-第二部分

对象的组合

组合与复用

如果一个对象a组合了对象b,那么对象a就可以委托对象b,调用对象b调用其方法，即对象a以组合的方式复合对象b的方法

Circle.java

public class Circle {
    double radius,area;
    void setRadius(double r){
        radius=r;
    }
    double getRadius(){
        return radius;
    }
    double getArea(){
        area=3.14*radius*radius;
        return area;
    }
}

Circular.java

public class Circular {
    Circle  bottom;
    double height;
    void setBottom(Circle c){//设置圆锥的底是一个Circle对象
        bottom=c;
    }
    void setHeight(double h){
        height=h;
    }
    double getVolume(){
        if (bottom==null)
            return -1;
        else
            return bottom.getArea()*height/3.0;
    }
    double getBottomRadius(){
        return bottom.getRadius();
    }
    public void setBottomRadius(double r){
        bottom.setRadius(r);
    }

}

 类的关联关系和依赖关系的UML图

关联关系

如果A类中的成员变量是用B类声明的对象，那么A和B的关系是关联关系，称A类的对象关联与B类的对象或A类的对象组合了B类的对象

依赖关系

如果A类中某个方法的参数是用B类声明的对象或某个方法返回的数据类型是B类对象，那么A和B的关系是依赖关系，称A依赖于B

实例成员与类成员

实例变量和类变量的声明

类体中包括成员变量的声明和方法的定义，而成员变量又可细分为实例变量和类变量（用关键字static 修饰的称作类变量，否则为实例变量）

class Dog {
    float x;//实例变量
    static int y;//类变量
}
public class Example {
    // 实例变量
    private int instanceVar;

    // 类变量
    private static int classVar;

    public Example() {
        // 实例变量的初始化
        instanceVar = 10;
    }

    static {
        // 类变量的静态初始化块
        classVar = 20;
    }
    
    // 实例方法，操作实例变量
    public void instanceMethod() {
        instanceVar += 5; // 改变当前对象的instanceVar
    }

    // 静态方法，操作类变量
    public static void classMethod() {
        classVar += 5; // 改变所有对象共享的classVar
    }
}

实例方法和类方法的定义

声明方法时，在方法类型前加关键字static修饰的是类方法，否则是实例方法

public class A {
    int m;
    static int n;

    int max(int x, int y) {     //实例方法
        return x > y ? x : y;
    }

    void jerry() {
        m = 12;
        n = 90;
        int r = max(m, n);
        // 假设 speak 方法是 A 类的一部分，并且是静态的
        speak("hello" + r);
    }

    // speak 方法是静态的，所以应该用类名调用，或者创建 A 的实例来调用
    static void speak(String s) {       //类方法
        n = 100;
        System.out.println(s);
        System.out.println(n);
    }

    public static void main(String[] args) {
        A a = new A(); // 创建 A 类的实例
        a.jerry(); // 调用 jerry 方法
    }
}

注：不能用static修饰构造方法

实例方法和类方法的区别

1、在实例方法中不仅可以操作实例变量，也可以操作类变量

2、类方法不可以操作实例变量，这是因为之前实例成员变量还没有分配内存

3、对于static方法，不必创建对象就可以用类名直接调用（创建对象会导致类中的实例变量被分配内存空间）

public class Example4_11 {

    // 实例变量，属于对象
    private int instanceVar;

    // 类变量，属于类
    private static int classVar;

    // 实例方法，需要通过对象来调用
    public int getInstanceVar() {
        return instanceVar;
    }

    // 实例方法，可以访问实例变量
    public void setInstanceVar(int instanceVar) {
        this.instanceVar = instanceVar;
    }

    // 类方法，可以直接通过类名调用
    public static int getClassVar() {
        return classVar;
    }

    // 类方法，可以修改类变量
    public static void setClassVar(int classVar) {
        Example4_11.classVar = classVar;
    }

    // 主方法，用于程序的入口
    public static void main(String[] args) {
        // 创建Example类的实例
        Example4_11 example1 = new Example4_11();
        Example4_11 example2 = new Example4_11();

        // 通过对象调用实例方法
        example1.setInstanceVar(10);
        example2.setInstanceVar(20);

        // 通过对象访问实例变量
        System.out.println("Instance variable of example1: " + example1.getInstanceVar());
        System.out.println("Instance variable of example2: " + example2.getInstanceVar());

        // 直接通过类名调用类方法
        Example4_11.setClassVar(30);

        // 直接通过类名访问类变量
        System.out.println("Class variable: " + Example4_11.getClassVar());
    }
}

方法重载

方法重载的语法规则

在一个类中可以有多个方法具有相同的名字，但这些方法的参数必须不同（参数个数不同或参数类型不同或都不同）

class People{
    float hello(int a,int b){
        return a+b;
    }
    float hello(long a,int b){
        return a-b;
    }

    double hello(double a,int b){
        return a*b;
    }
}

public class Example4_12 {
    public static void main(String[] args) {
        People tom=new People();
        System.out.println("10+10="+tom.hello(10,10));
        System.out.println("10-10="+tom.hello(10l,10));
        System.out.println("10*10="+tom.hello(10.0,10));
    }
}

注：构造方法也可以重载，但构造方法不参与和非构造方法之间的重载比较

this关键字

在构造方法中使用this

当关键字this出现在类的构造方法中，代表构造方法所创建的对象

public class Eeample14 {
    int leg,hand;
    String name;
    People(String s){
        name=s;
        this.init();    //可以省略this
    }
    void init(){
        leg=2;
        hand=2;
        System.out.println(name+"有"+hand+"只手"+"有"+leg+"条腿");
    }
    public static void main(String args[]){
        People bush= new People();
                                    //在创建bush中的this就是对象bush
    }
}

在实例方法中使用this

当this关键字出现在实例方法中时，this就代表正在调用该方法的当前对象

实例方法可以操作类的成员变量，当实例成员变量在实例方法中出现是时，默认的格式是：

this.成员变量

当static成员变量在实例方法中出现时，默认格式是：

类名.成员变量

public class Example4_9_2 {
    public static void main(String []args){
        class A{
            int x;
            static int y;
            void f(){
                this.x=100;
                A.y=200;
            }
        }
    }
}

通常情况下，可以省略实例成员变量名字前的"this."以及static变量前面的"类名."

但是，当实例或static成员变量的名字和局部变量的名字相同时，成员变量前面的"this."或“类名.”不可以省略

实例方法可以调用类的其他方法，对于实例方法，调用的默认格式是;

this.方法;

对于类方法，调用的默认格式是;

类名.方法;

class f{
        this.g();
        b.h();
    }
    void g(){
        System.out.println("ok");
    }
    static void h(){
        System.out.println("hello");
    }

包 

包语句

通过关键字package声明包语句，package语句的一般格式是：

package 包语句

注：在源程序中最多有一个包语句

包名可以是一个合法的标识符，也可以是若干个标识符加" . "分隔而成，例如：

package sunrise

或

package sun.com.cn;

有包名的类的存储目录

如果一个类有包名，那么就不能在任意位置存放，否则虚拟机将无法加载这样的类

运行有包名的主类

package tom.jiafei;
public class Example4_15 {
    public static void main(Str arg[]){
        Student sty=new = Student(10201);
        stu.speak();
        System.out.println("主类的包名也是 tom.jiafei");
    }
}

访问权限

什么是访问权限

访问限制修饰符有public,private,protected

私有变量和私有方法

用关键字private修饰的成员变量和方法称为私有变量和私有方法

class Tom{
    private float weight;//私有变量
    private float f(float a,float b){//私有方法
        return  a+b;
    }
}

在另外一个类中，使用类Tom创建对象后，该对象不能访问自己的私有变量，调用类中的私有方法，例如：

class Jerry{
    void g(){
        Tom cat =new Tom();
        cat.weight=23f;//违法
        float sun=cat.f;//违法
    }
}
class Student{
    private int age;
    public void setAge(int age ){
        if(age>=7&&age<=28){
            this.age=age;
        }    }
    public int getAge(){
        return age;
    }
}
public class Example4_15 {
    public static void main (String arg[]){
        Student zhang=new Student();
        Student geng=new Student();
        zhang.setAge(23);
        System.out.println("zhang 的年龄是"+zhang.getAge());
        geng.setAge(25);
        //"zhang.age=23;"或"geng.age=25;"都是非法的
        System.out.println("geng的年龄："+geng.getAge());
    }
}

共有变量和共有方法

用关键字public修饰的成员变量和方法称为私有变量和私有方法

class Tom{
    public float weight;//私有变量
    public float f(float a,float b){//私有方法
        return  a+b;
    }
}
class Jerry{
    void g(){
        Tom cat =new Tom();
        cat.weight=23f;//合法
        float sum=cat.f(3,4);//和法
    }
}

友好变量和友好方法

不用关键字public，private,protected修饰的成员变量和方法称为友好变量和友好方法

受保护的成员变量和方法

用关键字protected修饰的成员变量和方法称为私有变量和私有方法

class Tom{
    protected float weight;//私有变量
    protected float f(float a,float b){//私有方法
        return  a+b;
    }
}

当另外一个类中使用了Tom类创建了一个对象后，如果这个类与Tom类在同一个包中，那么该对象可以使用Tom类中的protected变量个protected方法

注：在另外一个类中使用pubic类创建的对象要保证他们在同一个包中

访问限制修饰符按访问权限从高到低的顺序是：public->protect->友好的->private

基本类型的类封装

可以对基本类型类的对象进行四则运算，例如

public class Example {
    public static void main(String[] args){
        int number1 =100;
        double number2=6.18;
        Float number3=3.14F;

        double result=number1+number2+number3;
        System.out.println(result);
    }
}

Var局部变量

在类和类体重，不可以使用Var声明成员变量，即仅限于在方法体内使用var声明局部变量

使用var声明局部变量时，必须显式的指定初值（初值不可以是null）

import java.util.Date;
class Tom{
    void f(double m){
        var width=108; //var声明变量width并判断出是int型
        var height=m;//var声明变量height并判断出是double型
        var data=new Date();//var声明变量double并判断出是Date型
        System.out.printf("%d,%f,%s",width,height,data);
    }
}
public class Example4_14 {
    public static void main(String args[]){
        var tom=new Tom();
        tom.f(6.18);
    }
}

对象数组

class student{
    int number;
}
public class Example4_22 {
    public static void main(String args[]){
        student stu[]=new student[10];//创建对象数组stu
        for (int i=0;i<stu.length;i++){
            stu[i]=new student();
            stu[i].number=101+i;
        }
        for(int i=0;i< stu.length;i++){
            System.out.println(stu[i].number);
        }
    }
}

若有侵权，请联系作者

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/603642.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

计算机组成原理网课笔记

计算机组成原理网课笔记

无符号整数的表示与运算 带符号整数的表示与运算 原反补码的特性对比 移码
阅读更多...
基于 docker-compose 部署 LNMP 架构

基于 docker-compose 部署 LNMP 架构

目录 前言 1、任务要求 2、Nginx 2.1 建立工作目录并上传相关安装包 2.2 编写 Nginx Dockerfile 脚本 2.3 准备 nginx.conf 配置文件 3、Mysql 3.1 建立工作目录并上传相关安装包 3.2 编写 Mysql Dockerfile 脚本 3.3 编写 my.cnf 配置文件 4、PHP 4.1 建立工作目录…
阅读更多...
Spring MVC(一)

Spring MVC(一)

1 Spring MVC概述 我们在之前学习Servlet的时候&#xff0c;认识了在WEB开发中MVC设计模式&#xff0c;其最为经典的设计就是&#xff0c;通过控制器&#xff08;Controller&#xff09;分离模型&#xff08;Model&#xff09;和视图&#xff08;View&#xff09;。在具体的WEB…
阅读更多...
提高谷歌抓取成功率：代理IP的7个使用误区

提高谷歌抓取成功率：代理IP的7个使用误区

在当今数字化时代&#xff0c;数据采集和网络爬取已成为许多企业和个人必不可少的业务活动。对于爬取搜索引擎数据&#xff0c;特别是Google&#xff0c;使用代理IP是常见的手段。然而&#xff0c;使用代理抓取Google并不是一件轻松的事情&#xff0c;有许多常见的误区可能会导…
阅读更多...
在IDEA中通过模块创建新项目的时候，出现无法连接的错误

在IDEA中通过模块创建新项目的时候，出现无法连接的错误

1.找到IDEA中的设置 2.在设置搜索HTTP,选择自动检测代理设置 选择URL: 输入https://start.spring.io 3.点击应用&#xff0c;即可完成
阅读更多...
面试算法-链表-反转链表(golang、c++)

面试算法-链表-反转链表(golang、c++)

目录 1、题目 2、解题思路 2.1 遍历、迭代 2.2 递归 3、源代码 3.1 c 3.2 golang 4、复杂度分析 4.1 遍历、迭代法 4.2 迭代法 1、题目 链表是一种常用的数据结构&#xff0c;链表的特点是插入、删除节点的效率非常高&#xff0c;因为他不需要移动其他任何元素&…
阅读更多...
nginx--防盗链

nginx--防盗链

盗链 通过在自己网站里面引用别人的资源链接,盗用人家的劳动和资源 referer referer是记录打开一个页面之前记录是从哪个页面跳转过来的标记信息 正常的referer信息 none&#xff1a;请求报文首部没有referer首部&#xff0c;比如用户直接在浏览器输入域名访问web网站&…
阅读更多...
使用 Cython 加密 Python 代码防止反编译

使用 Cython 加密 Python 代码防止反编译

文章目录 前言使用 Cython 加密 Python 代码环境Python 源代码编写 Cython 编译配置文件 编译查看输出文件使用 问题error: Microsoft Visual C 14.0 or greater is requiredpyconfig.h(59): fatal error C1083: 无法打开包括文件: “io.h”: No such file or directorydynamic…
阅读更多...
【已解决】‘pip‘ 不是内部或外部命令问题

【已解决】‘pip‘ 不是内部或外部命令问题

&#x1f60e; 作者介绍&#xff1a;我是程序员行者孙&#xff0c;一个热爱分享技术的制能工人。计算机本硕&#xff0c;人工制能研究生。公众号&#xff1a;AI Sun&#xff0c;视频号&#xff1a;AI-行者Sun &#x1f388; 本文专栏&#xff1a;本文收录于《AI实战中的各种bug…
阅读更多...
大模型微调之 在亚马逊AWS上实战LlaMA案例（三）

大模型微调之 在亚马逊AWS上实战LlaMA案例（三）

大模型微调之 在亚马逊AWS上实战LlaMA案例&#xff08;三&#xff09; 使用 QLoRA 增强语言模型&#xff1a;Amazon SageMaker 上 LLaMA 2 的高效微调 语言模型在自然语言处理任务中发挥着关键作用&#xff0c;但训练和微调大型模型可能会占用大量内存且耗时。在本文中&…
阅读更多...
Springboot整合飞书向群组/指定个人发送消息/飞书登录

Springboot整合飞书向群组/指定个人发送消息/飞书登录

Springboot整合飞书向群组发送消息 飞书开放平台创建企业自建应用 添加应用能力-机器人 创建完成后&#xff0c;进入应用详情页&#xff0c;可以在首页看到 App Id 和 App Secret 在飞书pc端创建一群机器人 此处可以拿到该机器人的webhook地址,通过https的方式,也可以调用发送…
阅读更多...
为什么说RK3562可以碾压PX30？

为什么说RK3562可以碾压PX30？

在如今的科技市场中&#xff0c;处理器的性能直接决定了设备的运行速度和用户体验。今天&#xff0c;我们将对比瑞芯微旗下的两款处理器&#xff1a;PX30与RK3562。RK3562比PX30的性价比究竟高在哪里&#xff1f; PX30 瑞芯微PX30是一款高性能的四核应用处理器&#xff0c;专…
阅读更多...
Android单行字符串末尾省略号加icon，图标可点击

Android单行字符串末尾省略号加icon，图标可点击

如图 设置仅显示单行字符串&#xff0c;末尾用省略号&#xff0c;加跟一个icon&#xff0c;icon可点击 tvName.text "test"val drawable ResourcesCompat.getDrawable(resources, R.mipmap.icon_edit, null)tvName.setCompoundDrawablesWithIntrinsicBounds(null,…
阅读更多...
故障——蓝桥杯十三届2022国赛大学B组真题

故障——蓝桥杯十三届2022国赛大学B组真题

问题分析 这道题纯数学&#xff0c;考察贝叶斯公式 AC_Code #include <bits/stdc.h> using namespace std; typedef pair<int,double> PI; bool cmp(PI a,PI b){if(a.second!b.second)return a.second>b.second;return a.first<b.first; } int main() {i…
阅读更多...
在Leaflet中点对象使用SVG和Canvas两种模式的对比

在Leaflet中点对象使用SVG和Canvas两种模式的对比

目录 前言 一、关于SVG和Canvas 1、SVG知识 2、Canvas知识 3、优缺点 二、SVG和Canvas在Leaflet的使用 1、相关类图 2、Leaflet的默认展示方式 三、SVG和Canvas实例及性能对比 1、SVG模式及性能对比 2、Canvas优化 总结 前言 众所周知&#xff0c;在Leaflet当中&#…
阅读更多...
vue3配置element-plus时间选择器中文显示

vue3配置element-plus时间选择器中文显示

修改main.js import ElementPlus from element-plus import element-plus/dist/index.css // 引入中文包 import zhCn from "element-plus/es/locale/lang/zh-cn"; const app createApp(App) app.use(ElementPlus,{ locale: zhCn, }) //挂载 app.mount(#app)
阅读更多...
白盒测试：覆盖测试及测试用例设计

白盒测试：覆盖测试及测试用例设计

白盒测试&#xff1a;覆盖测试及测试用例设计 一、实验目的 1、掌握白盒测试的概念。 2、掌握逻辑覆盖法。 二、实验任务 某工资计算程序功能如下&#xff1a;若雇员月工作小时超过40小时&#xff0c;则超过部分按原小时工资的1.5倍的加班工资来计算。若雇员月工作小时超过…
阅读更多...
数据库系统理论——关系数据库

数据库系统理论——关系数据库

文章目录 一、关系&#xff08;数据结构&#xff09;1、概述2、名词解释3、关系模式、关系数据库、关系数据库模式4、基本关系的性质 二、关系操作&#xff08;数据操作&#xff09;三、关系的完整性1、实体完整性2 、参照完整性3、用户自定义的完整性 四、关系代数五、习题 前…
阅读更多...
Twitch赠送暗区突围测试资格 超简单暗区突围测试资格领取教程

Twitch赠送暗区突围测试资格 超简单暗区突围测试资格领取教程

作为直播界的领航者&#xff0c;Twitch平台不仅是全球游戏文化直播的中心舞台&#xff0c;更是频繁联袂各路游戏大作&#xff0c;为粉丝们奉上别具匠心的互动盛宴&#xff0c;让观赛的同时解锁诱人的游戏内惊喜。正值《暗区突围》PC版测试的热潮涌动&#xff0c;Twitch乘势加强…
阅读更多...
详细分析McCabe环路复杂度（附例题）

详细分析McCabe环路复杂度（附例题）

目录 前言1. 基本知识2. 例题 前言 该知识点常出在408或者软考中&#xff0c;对此此文重点讲讲理论知识以及例题 对于例题平时看到也会更新 1. 基本知识 McCabe环路复杂度是一种用于衡量软件代码复杂性的指标&#xff0c;主要是通过计算代码中的控制流图中的环路数量来衡量…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站