精华内容
下载资源
问答
  • 常用ActivityFragment,由于操作方便Fragment越来越受欢迎,这样就避免不了ActivityFragment、FragmentFragment之间的通信,我们知道FragmentFragment之间不能直接进行通信的,而是通过Activity进行通信。...

    前言

    开发一个app时,常用Activity和Fragment,由于操作方便Fragment越来越受欢迎,这样就避免不了Activity和Fragment、Fragment和Fragment之间的通信,我们知道Fragment和Fragment之间不能直接进行通信的,而是通过Activity进行通信。那么Activity和Fragment有几种通信方式呢,它们的优缺点又是什么?

    一 常用的Activity和Fragment几种通信方式

    1 通过Handle

    在Activity创建一个Handle机制实例,然后在创建Fragment的通过构造方法把Handle实例传递过去,这样Fragment就可以往Activity传送数据了。但这样如下缺点:

    (1)Activity和Fragment之间耦合性增大;

    (2)Activity处理后的结果不能实时反馈给Fragment;

    (3)提高了内存泄漏风险;

    2 使用static变量

    缺点很明确增大内存消耗;

    3 使用广播

    分别在Activity和Fragment中注册广播,这样就可以实现通信了。其缺点:

    (1)性能差,有延迟,用户体验就会差;

    (2)一般使用的是标准广播,一个发送,多个接收者,大材小用,性能差;

    (3)代码冗余;

    (4)传播的数据有限;

    4 EventBus 、rxBus(俗称万能油)

    其使用方法参考官方文档,其优点就是实用起来简单方便,其缺点也很明显:

    (1)EventBus 、rxBus其内部使用的是反射机制,那么其性能就会降低;

    (2)代码维护困难(不熟悉的项目代码的新人很难找到实现的方法在是如何调用的);

    (3)数据返回困难,它们是单向传递;

    5 普通接口

    在Fragment写一个接口,让Activity去实现这个接口,通过这个接口把Activity与Fragment绑定在一起,这样Activity和Fragment实时进行通信了,其实谷歌推荐就是这么干的,由于每个Fragment都写一个接口,就会造成代码冗余;如果Fragment少的话还好,多的话,Activity实现多个接口,显得Activity头部很大,况且接口的命名也是一个问题;

    二 万能接口

    如果在5的基础能够解决代码冗余、接口命名就好了,我们知道一个函数包括函数名、函数体、参数、返回值,那么就可以通过搭建一个简单的框架实现上述问题。

     

    建立无(有)参数无(有)四类

     

     

    定义完所有的接口抽象类之后,我们在定义一个接口管理类,通过接口管理类来管理调用对应的函数方法。

    public class MainActivity extends AppCompatActivity{
    
        private ArrayList<Fragment> fragmentArrayList = new ArrayList<>();
        private Fragment mCurrentFragment;
        private BottomNavigationBar mBottomNavigationBar;
        BadgeItem badgeItem;
    
        FragmentManager mFragmentManager;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            initView();
        }
    
        private void initView(){
            mFragmentManager = getSupportFragmentManager();
            initFragemnt();
            showFragment(0);
            mBottomNavigationBar = (BottomNavigationBar) findViewById(R.id.bottom_navigation_bar);
            mBottomNavigationBar.setMode(BottomNavigationBar.MODE_FIXED);
            mBottomNavigationBar.setBackgroundStyle(BottomNavigationBar.BACKGROUND_STYLE_STATIC);
            mBottomNavigationBar.setBarBackgroundColor(android.R.color.white);
            badgeItem = new BadgeItem()
                    .setBackgroundColor(Color.RED).setText("99")
                    .setHideOnSelect(true); //设置被选中时隐藏角标
            mBottomNavigationBar
                    .setActiveColor(R.color.colorAccent) //设置选中的颜色
                    .setInActiveColor(R.color.colorPrimary);//未选中
    
            mBottomNavigationBar.addItem(new BottomNavigationItem(R.mipmap.ic_launcher, "首页"))
                    .addItem(new BottomNavigationItem(R.mipmap.ic_launcher, "店铺"))
                    .addItem(new BottomNavigationItem(R.mipmap.ic_launcher, "购物车"))
                    .addItem(new BottomNavigationItem(R.mipmap.ic_launcher, "我的").setBadgeItem(badgeItem))
                    .initialise();
            mBottomNavigationBar.setTabSelectedListener(new BottomNavigationBar.OnTabSelectedListener(){
    
                @Override
                public void onTabSelected(int position) {
                    showFragment(position);
                }
    
                @Override
                public void onTabUnselected(int position) {
    
                }
    
                @Override
                public void onTabReselected(int position) {
    
                }
            });
    
    
        }
    
        private void showFragment(int page) {
            FragmentTransaction mFragmentTransaction = mFragmentManager
                    .beginTransaction();
            if (mCurrentFragment != null) {
                mFragmentTransaction.hide(mCurrentFragment);
            }
            mCurrentFragment = fragmentArrayList.get(page);
            if (mCurrentFragment.isAdded())
            {
                mFragmentTransaction.show(mCurrentFragment);
            }else {
                mFragmentTransaction.add(R.id.fragmenta, mCurrentFragment,mCurrentFragment.getClass().getName());
            }
            mFragmentTransaction.commitAllowingStateLoss();
        }
    
        private void initFragemnt(){
            fragmentArrayList.add(new A());
            fragmentArrayList.add(new B());
            fragmentArrayList.add(new C());
            fragmentArrayList.add(new D());
        }
    
        public void setFunctionForFragment(final String tag){
            BaseFragment fragment=(BaseFragment)mFragmentManager.findFragmentByTag(tag);
            FunctionManager functionManager=FunctionManager.getInstance();
            fragment.setmFunctionManager(functionManager.addFunction(new FunctionNoParamNotResult(A.INTERFCE) {
                @Override
                public void function() {
                    Toast.makeText(MainActivity.this,"无参无返回值"+tag,Toast.LENGTH_LONG).show();
                }
            }).addFunction(new FunctionNoParamWithResult<String>(B.INTERFCE) {
                @Override
                public String function() {
                    Toast.makeText(MainActivity.this,"无参有返回值",Toast.LENGTH_LONG).show();
                    return "张三";
                }
            }).addFunction(new FunctionWithParamNoResult<Integer>(C.INTERFCE) {
                @Override
                public void function(Integer o) {
                    Toast.makeText(MainActivity.this,"有参无返回值"+o,Toast.LENGTH_LONG).show();
                }
            }).addFunction(new FunctionWithParamResultn<String>(D.INTERFCE) {
                @Override
                public String function(String o) {
                    Toast.makeText(MainActivity.this,"有参有返回值"+o,Toast.LENGTH_LONG).show();
                    return "zhangqie";
                }
            }));
        }
    
    }

     

    最后在Activity中实现通信:

    效果图:

     

            

     

     

    源码下载Github:https://github.com/DickyQie/android-fragment-interface

    展开全文
  • 面向对象,Obeject Oriented,是一种编程术语。...类通过一个简单的外部接口与外界发生关系,对象与对象之间通过消息进行通信。程序流程由用户在使用中决定,例如,站在抽象的角度,人具有身高,体重,年...

    面向对象,Obeject Oriented,是一种编程术语。面向对象是当今软件开发方法的主流方法之一,他是把数据以及对数据的操作放在一起,作为一个相互依存的整体,就是我们所说的对象。对同类对象抽象出其共性,就是类,类中的大多数数据,只能被本类的方法进行处理。类通过一个简单的外部接口与外界发生关系,对象与对象之间通过消息进行通信。程序流程由用户在使用中决定,例如,站在抽象的角度,人具有身高,体重,年龄,血型等一些特征,人会劳动,会行走,会吃饭等这些方法,人仅仅是一个抽象的概念,它是不存在的实体,但是所有具备人这个群体的属性与方法的对象都叫做人,这对象人是实际存在的实体,每个人都是人这个群体的一个对象。

    面向过程,Procedure Oriented,是一种以事件为中心的开发方法,就是自顶向下顺序执行,逐步求精,其程序结构是按照功能划分为若干个基本模块,这些模块形成一个树状结构,各模块之间的关系也比较简单,在功能上相对独立,每一个模块内部一般都是由顺序,选择和循环3种基本结构组成,其模块化实现的具体方法是使用子程序,而程序流程在写程序的时候就已经决定了。

    以五子棋为例子

    面向过程的设计思路就是首先分析问题的步骤

    把以下每个步骤用分别的函数来实现就是一个面向过程的开发方法。

    开始游戏;

    黑子先走;

    绘制画面;

    判断输赢;

    轮到白子;

    绘制画面;

    判断输赢;

    返回第二步;

    输出最后结果;

    以下是面向对象分析问题的步骤:

    分析对象:棋子,棋盘,主体框架类,

    棋盘类的属性:需要画一个棋盘,大小背景线条颜色,都是属性。棋盘需要有位置分布,

    棋子的属性,黑棋,白棋,添加到棋盘的方法,

    棋盘的方法:作为一个容器,需要容纳棋子,添加棋子操作,绘制棋盘,当添加棋子进来的时候,判断是否已经绘制棋子,绘制棋盘,判定输赢,输出最后结果。

    将棋盘绘制到主体框架类上面,并调用

    那么总结一下面向对象和面向过程的区别:

    出发点不同。面向对象方法是符合常规思维的方式来处理客观世界的问题,强调把问题域的要领直接映射到对象及对象之间的接口上。而面向过程方法强调的是过程的抽象化与模块化,它是以过程为中心构造或者处理客观世界问题的。

    层次逻辑关系不同。面向对象方法是用计算机逻辑来模拟客观世界中的物理存在,以对象的集合-类-作为处理问题的基本单位,尽可能地使计算机世界向客观世界靠拢,以使问题的处理更清晰直接,面向对象方法是用类的层次结构来体现类之间的继承和发展。而面向过程方法处理问题的基本单位是能清晰准确地表达过程的模块,用模块的层次结构概括模块或模块间的关系与功能,把客观世界的问题抽象成计算机可以处理的过程。

    数据处理方式与控制程序的方式不同。面向对象方法将数据与对应的代码封装成一个整体,原则上其他对象不能直接修改其数据,即对象的修改只能由自身的成员函数完成,控制程序方式上是通过“事件驱动”来激活和运行程序。而面向过程的方法是直接通过程序来处理数据,处理完毕后即可显示处理结果,在控制程序方式上按照设计调用或返回程序,不能自由导航,各模块之间存在控制与被控制、调用与被调用的关系。

    分析设计与编码转换方式不同。面向对象方法贯穿于软件生命周期的分析、设计以及编码中,是一种平滑过程,从分析到设计再到编码是采用一致性的模型表示,即实现的是一种无缝连接。而面向过程方法强调分析、设计以及编码之间按照规则进行转换,贯穿于软件生命周期的分析、设计以及编码中,实现的是一种有缝的连接。

    面向对象的特征

    抽象。抽象就是忽略一个主题中与当前目标无关的那些方面,以便更充分地注意与当前目标有关的方面。抽象不打算了解全部问题,而是选择其中的一部分,暂时不用部分细节。抽象包括两个方面:过程抽象;数据抽象。

    继承。继承是一种连接类的层次模型,并且允许和鼓励类的重用,它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生,这个过程称为类的继承。新类继承了原始类的特性,新类称为原始类的派生类(子类),而原始类称为新类的基类(父类)。派生类可以从它的基类那里继承方法和实例变量,并且派生类可以修改或者增加新的方法使之更适合特殊的需要。

    封装。封装是指将客观事物抽象成类,每个类对自身的数据和方法实行保护。类可以把自己的数据和方法只让可信的类或者对象操作,对不可信的进行信息隐藏。

    多态。多态是指允许不同类的对象对同一消息做出响应。多态包括参数化多态和包含多态。多态性语言具有灵活、抽象、行为共享、代码共享等优势,很好地解决了应用程序函数同名问题。Java中实现多态主要是方法的重载和方法的覆盖。

    面向对象开发方式的优点:

    较高的开发效率。采用面向对象的开发方式可以对现实的事物进行抽象,可以把现实的事物直接映射为开发的对象,与人类的思维过程相似。同时面向对象的开发方式可以通过继承或者组合的方式来实现代码的重用,因此可以提高软件的开发效率。

    保证软件代码健壮。由于其很高的重用性,在开发过程中重用已有的而且在相关领域经过长期测试的代码,稳定性比较高,对软件的健壮性起到了促进作用。

    保证软件的高可维护性。面向对象开发,代码可读性好,面向对象的设计模式使得代码结构更加清晰明了。同时针对面向对象的开发方式,已有非常成熟的设计模式,这些设计模式可以使程序在面向需求的变更时,只需要修改部分的模块就可以满足需求,因此维护起来非常方便。

    为了让学习变得轻松、高效,今天给大家免费分享一套Java入门教学资源。帮助大家在成为Java架构师的道路上披荆斩棘。需要入门的资料欢迎加入学习交流群:9285,05736

    展开全文
  • 类通过一个简单的外部接口与外界发生关系,对象与对象之间通过消息进行通信. 程序流程是由用户在使用中决定的.   面向对象的四个方面: 1.标识 数据被量化成称之对象的离散的实体.每个对象都有它自己的内部标识....

    什么是面向对象,什么是面向过程

    面向对象:

    把软件组织成一系列离散的,合并了数据结构和行为的对象.

     

    类中的大部分数据,只能用本类的方法进行处理.

    类通过一个简单的外部接口与外界发生关系,对象与对象之间通过消息进行通信.

    程序流程是由用户在使用中决定的.

     

    面向对象的四个方面:

    1.标识

    数据被量化成称之对象的离散的实体.每个对象都有它自己的内部标识.即使所有的属性都相同,两个对象也是有差别的.

     

    2.分类

    拥有相同数据结构(属性)和行为(操作)的对象被分组成一个类.

     

    3.继承

    多个类基于一种分层关系,共享类间的属性和操作(合称为特征)

     

    4.多态

    对于不同的类来说相同的操作会有不同的动作.

     

    面向对象的基本概念:

    1. 对象

    把数据(属性)及数据的操作方式(方法)放在一起,作为一个相互依存的整体就是对象

     

    2.对象的状态和行为

    对象的状态,一个对象的数据值来描述他的状态

     

    对象的操作,用于改变对象的状态,对象及其操作就是对象的行为

     

    对象实现了数据和操作的结合,是数据和操作封装与对象的统一体中.

     

    3.类

    具有相同或相似性质的对象的抽象就是类.

    因此,对象的抽象就是类,类的具体化就是对象,也可以说类的实例就是对象

     

    类的状态,就是对象的状态的抽象,用数据结构类描述他的属性.

     

    类的操作,就是对象的行为的抽象,用操作名实和实现该操作的方法来描述.

     

    4.类的结构

    通常有两种主要的结构关系,及一般---具体结构关系, 整体—部分结构关系.

     

    一般—具体结构被称为分类关系,也可以说是”或”的关系.

    整体—部分结构被称为组装关系,也可以说是”与”的关系

     

    5.消息和方法

    对象之间进行通信的结构被叫做消息.

    在对象的操作中,当一个消息发送给某个对象时,消息包含接收对象去执行的某种操作的信息.

    发送一条信息至少要包括说明接收消息的对象名,发送给该对象的消息名称(对象名,方法名).

    一般还要对参数进行说明,参数是可以认识该消息的对象所知道的变量名,或是所有对象都知道的全局变量名

     

    面向对象的特征:

    1.对象唯一性

    每个对象都有自身唯一的标识,通过这种标识,可找到相应的对象.在对象的整个生命期中,他的标识都不改变,不同的对象不能有相同的标识

     

    2.抽象性

    抽象性是指将具有一致的数据类型(属性)和行为(操作)的对象抽象成类.一个类就是这样的一种抽象,它反映了与应用有关的重要性质,而忽略其他一些无关内容,任何类的划分都是主观的,但必须与具体的应用有关.

     

    3.继承性

    继承是子类自动共享父类数据结构和方法的机制,这是类之间的一种关系.在定义和实现一个类的时候,可以在一个已经存在的类的基础上来进行,把这个已经存在的类所定义的内容作为自己的内容,并加入若干新的内容.

     

    继承性是面向对象程序设计语言不同其他语言的最重要的特点,是其他语言没有的.

     

    在类层次中,子类只能继承一个父类的数据结构和方法,则称为单重继承.

     

    在类层次中,子类继承了多个父类的数据结构和方法,则称为多重继承.

     

    多重继承, Java ,Vb,NET,均仅支持单继承,在使用C++多继承时,注意二义性.

     

    继承性的作用

    在软件开发中,类的继承性使所建立的软件具有开放性,可补充性,这是信息组织与分类的行之有效的方法,它简化了对象,类的创建工作量,增加了代码到可重用性.

     

    采用继承性,提供了类的规范的等级结构.通过类的继承关系,使公共的特性能够共享,提高了软件的重用性.

     

     

    4.多态性(多形性)

    多态性是指相同的操作或函数,过程可作用于多种类型的对象上并获得不同的结果.

    不同的对象,收到同一信息可以产生不同的结果,这种现象称之为多态性.

    多态性允许每个对象以合适自身得方法去响应共同的信息.

    多态性的作用

    多态性增强了软件的灵活性和重用性.

     

    面向对象的要素:

    1.抽象

    抽象是指强调实体的本质,内在的属性.

     

    抽象的作用:

    使用抽象可以尽可能避免过早考虑的一些细节.

     

    2.封装性(隐藏性)

    封装性是保证软件部件具有优良的模块性的基础.

     

    封装的作用:

    对象是封装的最基本的单位.

    封装防止了程序互相依赖性而带来的变动影响.

    面向对象的封装比传统语言的封装跟清晰,给为有力.

     

     

    3.共享性

    面向对象技术在不同级别上促进了共享

    同一类的共享.同一类的对象是有着相同的数据结构.这些对象之间是结构,行为特征的共享关系.

     

    在同一应用中共享.在同一应用的类层次结构中,存在继承关系的各相似子类中,存在数据结构和行为的继承,是各相似子类共享共同的数据结构和行为.使用继承来实现代码的共享,这也是面向对象的主要优点之一.

     

    在不同应用中共享.面向对象不仅允许在同一应用中共享信息,而且为未来目标的可重用设计准备了条件.通过类库这种机制和结构来实现不同应用中的信息共享.

     

     

    面向过程:

    自顶向下顺序执行,逐步求精;

    其程序结构是按功能划分为若干个基本模块,这些模块形成一个树状结构;

    各模块之间的关系尽可能简单,在功能上相对独立(解耦合).

    每一模块内部均是由顺序,选择和循环三种基本结构组成;

    其模块化实现的具体方法是使用子程序.程序流程在写程序时就已决定.


    转至:https://baike.so.com/doc/3145517-3315043.html

    展开全文
  • JAVA之类和对象

    2018-03-16 15:58:34
    一:对象的概念: 我们都说万物皆对象,客观...类通过一个简单的外部接口与外界发生关系,对象与对象之间通过消息进行通信。程序流程由用户在使用中决定。 既然在这里提到了类,那么类究竟是什么呢?接下来我们就来...

    一:对象的概念:

        我们都说万物皆对象,客观存在的事物都是对象。

    二:什么是面向对象?

         把数据及对数据的操作方法放在一起,作为一个相互依存的整体——对象。对同类对象抽象出其共性,形成类。类中的大多数数据,只能用本类的方法进行处理。类通过一个简单的外部接口与外界发生关系,对象与对象之间通过消息进行通信。程序流程由用户在使用中决定。

    既然在这里提到了类,那么类究竟是什么呢?接下来我们就来说什么是类。

    三:什么是类?

        简单点来说,类就是模子,确定对象将会拥有的特征(属性)和行为(方法)。

    类的特点:1):类是对象的类型

                         2):具有相同属性和方法的一组对象的集合

    类中具有属性和方法,那么接下来我们就来说一说类的属性和方法。

    四:对象的属性--对象具有的各种特征。

        就比如说手机有屏幕大小,CPU内存大小,内核等特征,也就是手机的属性

    五:对象的方法--对象执行的操作

         比如说手机又发短信,打电话的功能。那么发短信和打电话就是手机的方法

    六:类和对象有什么区别?

       类是抽象的概念,仅仅是一个模板,对象是一个实体。比如"手机"对象是一个你能够看得着,摸得到的实体。


    下面,我们就看如何用代码来创建对象和类以及对象的属性和方法。

    ---------------------------------------------------------------------------------------------------------------------------------

    1:定义类

        主要包括三个步骤: 定义类名,编写类的属性,编写类的方法    

    public class Telphone{//定义类名
        //属性
        float screen;
        float cpu;
        float memory;
        //方法
        void call(){
          System.out.println("有打电话的功能");
        }
        void sendMessage(){
          System.out.println("screen:"+screen+",cpu:"+cpu+",memory"+memory+",并且有发短信的功能");
        }
    }

    2:使用对象

         使用对象有两个步骤:

            创建对象: 类名  对象名=new 类名();

            使用对象 :对象名.属性/方法

    public class InintTelpone{
         public static void main(String[] args){
             //创建对象
             Telphone phone=new Telphone();
             //给实例变量赋值
             phone.screen=254.2f;
             phone.cpu=1.4f;
             phone.memory=2.0f;
             //调用实例变量的方法
             phone.sendMessage();
         }
    }

    七: 成员变量和局部变量的区别

    1:作用域的不同:

               1): 局部变量的作用域仅限于用在定义他的方法中

               2): 成员变量的作用域在整个类内部都是可见的。

    :2:初始值不同:

               1): java会给成员变量一个初始值

                2):java不会给局部变量一个初始值

    在同一个方法中不允许有同名的局部变量,但是在不同的方法中可以允许有同名的局部变量。并且如果局部变量跟成员变量重名,则局部变量的优先级更高。

    public class Telphone {
    	float screen;
    	float cpu;
    	float mem;
    	float var;
    	void call(){
    		int localVar=2;
    		System.out.println(var);
    		System.out.println(localVar);
    		System.out.println("telephone 可以用来打电话");
    	}
    	void sendMessage(){
    		int localVar=3;
    		System.out.println(localVar);
    		System.out.println(var);
    		System.out.println("screen:"+screen+",cpu:"+cpu+",mem:"+mem+"Tel可以用来发短信");
    	}
    }
    public class InitTelphone {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Telphone phone=new Telphone();
    		phone.screen=2.0f;
    		phone.cpu=1.4f;
    		phone.mem=8.0f;
    		phone.call();
    		phone.sendMessage();
    	}
    
    }

    运行结果为:

    八:静态变量

         我们知道,我们可以基于一个类创建多个对象,每个对象的属性都是独立的。然而,在有的时候,我们希望该类的所有对象都能够共用一个成员,此时就需要定义静态变量,用static修饰。

        静态的东西在对象产生之前就已经存在了,所以静态的东西与对象无关,静态变量在类被加载时就执行了,在编译实现时静态变量只有一份备份。

        静态变量可以用类名来访问,也可以用对象名来访问。

    public class HelloWorld {
            //设置静态变量
    	static String className = "高二一班";
    	public static void main(String[] args) {
    	    //通过类名来访问
    	    System.out.println(HelloWorld.className);
    	    //创建新的对象
    	    HelloWorld hello=new HelloWorld();
    	    //使用对象名来访问
    	    System.out.println(hello.className);
    	    //使用对象名的形式来修改静态变量的值
    	    hello.className="高二二班";
    	    //再次使用类名来访问静态变量,值已经被改变
    	    System.out.println(HelloWorld.className);
    	}
    }

        运行结果:

        

    九:实例变量

        实例变量是类声明中没有使用static修饰声明的一个字段,实例变量是在类实例化时才会分配内存,因此同一个实例变量在类的不同实例化而产生的对象中是不同的。

    十:构造方法

    构造方法是定义在java类中的一个用来初始化对象的方法。并且构造方法的名称跟类名相同没有返回值。

    构造方法的几个特点:

            1:当没有指定构造方法的时候,系统会默认的调用构造方法。

            2:当有指定构造方法,无论是有参的还是无参的,都不会自动添加无参的构造方法

             3:构造方法的重载跟普通方法的重载一样。

             4:构造方法不但可以给对象的属性赋值,还可以保证给对象的属性赋一个合理的值。

    无参的构造方法:

    public class Telphone {
    	public Telphone(){
    		System.out.println("无参的构造方法");
    	}
    }
    
    	public static void main(String[] args) {
    		Telphone phone=new Telphone();
    	}
    }

       有参的构造方法:

    public class Telphone {
    	float cpu;
    	float screen;
    	public Telphone(float newScreen,float newCpu){
    		screen=newScreen;
    		cpu=newCpu;
    		System.out.println("有参的构造方法");
    	}
    }
    
    	public static void main(String[] args) {
    		Telphone phone=new Telphone(2.0f,1.4f);
    	}
    }

    十一:静态方法

        静态方法的使用需要注意以下几点:

        1:静态方法中可以直接调用同类中的静态变量,但是不可以直接调用非静态成员。

        2:如果希望能够调用非静态成员,可以通过创建类的对象,然后通过对象来访问非静态成员。

        3:在普通方法中,可以直接访问同类中的静态和非静态成员

        4:静态方法中不可以直接调用非静态方法,需要通过类创建的对象来访问。

            总结起来就是,在静态方法中不可以使用非静态的成员和方法,因为非静态的成员和方法是在实例化的时候才会分配空间,所以要通过类创建的对象来访问

    public class HelloWorld {
        
        // 定义静态变量score1
        static int score1 = 86;
        // 定义静态变量score2
        static int score2 = 92; 
    
        // 定义静态方法sum,计算成绩总分,并返回总分
    	public  static   int sum() { 
              return score1+score2;
    	}
    	public static void main(String[] args) {  
                    // 调用静态方法sum并接收返回值
    		int allScore = HelloWorld.sum();
    		System.out.println("总分:" + allScore);
    	}
    }

    十二:静态初始化块

          静态初始化块只在类加载时执行,且只会执行一次,同时静态初始化块只能给静态变量赋值,不能初始化普通的成员变量

    public class HelloWorld {
        int num1;
        int num2;
        static int num3;
      //通过构造方法初始化num1;
        public HelloWorld(){
        	num1=1;
        	System.out.println("通过构造方法给num1赋值");
        }
      //通过代码块给num2赋值
        {
        	num2=2;
        	System.out.println("通过代码块给num2赋值");
        }
      //通过静态代码块给num3赋值
        static {
        	num3=3;
        	System.out.println("通过静态代码块给num3赋值");
        }
        void show(){
        	System.out.println("num1:"+num1+",num2:"+num2+",num3:"+num3);
        }
        public static void main(String[] args) {
    		HelloWorld hello=new HelloWorld();
        	hello.show();
    	}
    }

    运行结果为: 

      


    展开全文
  • 类通过一个简单的外部接口与外界发生关系,对象与对象之间通过消息进行通信。 程序流程由用户在使用中决定。 理解面向对象 面向对象是相对面向过程而言。 面向对象和面向过程都是一种思想 面向过程,强调的是功能...
  • 常用ActivityFragment,由于操作方便Fragment越来越受欢迎,这样就避免不了ActivityFragment、FragmentFragment之间的通信,我们知道FragmentFragment之间不能直接进行通信的,而是通过Activity进行通信。...
  • 网络编程的底层是IO,通过IO将一台计算机中的数据发送到另一台计算机中。发送的时候,要知道接受方的地址,改地址即为IP地址。直到IP地址后即可进行发送。A向B发消息,消息是发过去了,但是B要怎样接受呢?因此定义...
  • SOAP,或者说简单对象访问协议是一个基于 XML 的对象调用协议,它最初是为通过 HTTP 进行通信的分布式应用而开发的。SOAP 定义了如何使用 XML HTTP 对平台无关的服务进行访问。相比之下,XML-RPC 是一个远程过程...
  • 面向对象的思想

    2017-02-14 22:09:35
    类通过一个简单的外部借口发生关系,对象与对象之间通过消息进行通信。面向对象就是一种编程思想,就是为了能够让计算机直接模拟现实的环境,用人类的思路、习惯、步骤来解决问题为什么要面向对象:从编程的角度来说...
  • 类中的大多数数据,只能用到本类的方法进行处理,类通过一个简单的外部接口与外界发生关系,对象与对象之间通过消息进行通信。 举例: 2、java面向对象的特性有哪些? 答:三大特性:封装继承多态 封装 封装从字面...
  • Android对象序列化

    2017-05-11 17:51:02
    首先介绍下为什么需要序列化 ...在Android中序列化最常用的到的地方就是通过Intent进行组件之间的数据传递进程间通信,因为在Android中只有序列化后的对象才能通过这两种方式进行传递。序列化的
  • java 线程同步和通信

    2020-07-25 17:52:07
    线程同步是指多线程通过特定的设置(如互斥量,事件对象,临界区)来控制线程之间的执行顺序(即所谓的同步)也可以说是在线程之间通过同步建立起执行顺序的关系,如果没有同步,那线程之间是各自运行各自的!...
  • 类通过一个简单的外部接口与外界发生关系,对象与对象之间通过消息进行通信。程序流程由用户在使用中决定。面向对象的三大特性面向对象的三大特性就是封装,继承,多态封装所谓封装,也就是把客观事物封装成抽象的类,...
  • com对象有自己的属性方法,但这些都被com封装了起来,客户只有通过接口才能对com的方法进行调用,接口是com与外界通信,交互的唯一途径。 什么是接口 接口就是com 与外界通信的唯一途径。他的定义是com规范的...
  • 类通过一个简单的外部接口与外界发生关系,对象与对象之间通过消息进行通信。程序流程由用户在使用中决定,例如站在抽象的角度,人具有身高、体重、年龄、血型等一些特征,人会劳动、人都会直立行走、人都会吃饭等...
  • (7)消息通信:这一原则要求对象之间只能通过消息进行通信,而不允许在对象之外直接地存取对象内部的属性。通过消息进行通信是由于封装原则而引起的。在OOA中要求用消息连接表示出对象之间的动态联系。 (8)粒度...
  • 实际上,当我评估一个面向对象系统的质量时,所使用的方法之一就是要判断系统的设计者是否强调了对象之间的公共协同关系。在系统开发阶段强调这种机制的优势在于,它能使所生成的系统体系结构更加精巧、简洁易于...
  • 接口之利:在面向对象的js中,接口具有自我描述性,并能促进代码的重用,有助于稳定不通的类之间通信方式。 接口结构包含的信息说明了需要实现什么方法以及这些方法应该具有什么参数。类的定义明确地声明它们实现...
  • 非接触式通信技术之RFID

    千次阅读 2011-05-19 10:48:00
    什么是RFID技术? RFID射频识别是一种非接触式的自动识别技术,它通过射频信号... RF技术利用无线射频方式在阅读器射频卡之间进行非接触双向传输数据,已达到目标识别数据交换的目的。 最基本的RF系统由三部分组
  • Phonegap插件编写 Java面向对象方法

    千次阅读 2012-07-02 21:50:03
    上一篇博文中我转载了别人写的phonegap的编写方法,简单回顾一下: cordova中有Plugin这个类,编写的插件继承于这个类,其中有exec这个方法,根据第...js通过cordova的exec这个方法来实现jsjava之间通信。然后可以
  • 规定了计算机通过网络进行通信的方式 物理层:发送电信号,进行数据模式转换 数据链路层:定义数据分组方式 网络层:位于不同地理位置的网络中两个主机系统间提供链接路径选择 运输层:负责向两个主机中进程之间的通信...
  • [size=large] 1.什么是会话 、会话跟踪 ?为什么需要会话跟踪?...1.3 浏览器与服务器之间的通信是通过HTTP协议进行通信的,而HTTP协议是”无状态”的协议,它不能保存客户的信息,即一次响应完成之后连接...
  • Java序列化SerializableExternalizable

    千次阅读 2015-08-25 00:04:53
    什么是Java序列化?为什么出现Java序列化?怎样实现Java序列化?...两个进程之间进行通信时,需要传输各种信息,比如文本,图像,声音等等,这些信息是通过二进制流的形式进行传输的。 那么进程之间是不是也可以传递
  • vue虽然支持双向绑定,但是组件之间总归而言还是单项的,所以我们在这一片内容之中将会去简单的了解总结,我们最平常的vue组件之间通信通过什么样的方式来的。 父子组件通信。 父 --> 子:我们常常使用的...
  • 什么是COM与DCOMRMI

    2009-03-05 16:26:00
    COM(Component Object Model,组件式对象模型),是组件之间相互接口的...COM所建立的是一个软件模块与另一个软件模块之间的链接,而当这种链接建立之后,模块间就可以通过称之为“接口”的机制来进行通信。COM标准增

空空如也

空空如也

1 2 3 4 5 ... 13
收藏数 246
精华内容 98
关键字:

对象和对象之间通过什么进行通信