20189200余超 2018-2019-2 移动平台应用开发实践第二周做业

时间 2019-12-14

标签移动平台应用开发实践第二栏目无线繁體版

原文原文链接

2018-2019-2 移动平台应用开发实践第二周做业

实验部分，在linux中用git命令将代码传到码云上

成功上传的截图
前端
码云上的截图
java
遇到以下的问题
linux
解决方法
我发如今进行第一步git clone命令时候，没有用到我码云的https地址，而且在此地址的基础上cd一个后面部分的文件夹；好比个人码云https的地址为https://gitee.com/yuchao20189220/over_20189220java.git，因此以下图所示
git
遇到问题
运行一下"statistics.sh"脚本的时候，发现：
编程
解决方法
app
"statistics.sh"脚本运行结果图
函数

看书部分

首先，对象的建立：类名对象名=new 类名();也许大多数学习java的都会写，可是理解方面是这样的，new一个类名，就会获得一个对象，而这个对象的类型就是这个类名的类型好比说：Car car=new Car();就是经过new一个Car类名，获得car这个对象，而这个对象就是Car类型的。
类必须先定义才能使用。类是建立对象的模板，建立对象也叫类的实例化。package com.cnblogs;//定义包的格式，关键词package包的名字最规范的格式是域名的反写，好比com.什么

public class People {//class关键字，定义类的关键字，People是类的名称
    
    public String name;//类的属性
    public String sex;
    public int age;   

　//类的方法　
    public void sleep(){
        System.out.println("人疲倦的时候喜欢睡觉觉");
    }
    
    public void eat(){
        System.out.println("人饥饿的时候喜欢吃饭饭");
    }
    public static void main(String[] args) {//主函数
        People p=new People();//对象的实例化
        p.eat();//调用类的方法
        p.sleep();
    }

}

3：构造方法,构造方法的名称必须与类的名称相同，而且没有返回值。每一个类都有构造方法。若是没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认的构造方法。

public class People {
    
    public String name;
    public String sex;
    public int age;
    
    public People(){//默认的构造方法，初始化对象的时候调用默认构造方法
        System.out.println("类默认的构造方法,不含参数");
    }
    public People(String name){//含参的构造方法
        System.out.println("含参的构造方法");
    }
    public void sleep(){
        System.out.println("人疲倦的时候喜欢睡觉觉");
    }
    
    public void eat(){
        System.out.println("人饥饿的时候喜欢吃饭饭");
    }
    public static void main(String[] args) {
        People p=new People();
        p.eat();
        p.sleep();
    }
    
}

Java 经过修饰符来控制类、属性和方法的访问权限和其余功能，一般放在语句的最前端。权限(访问)修饰符关键字包含：public ,private ,protected，另一个就是默认的;public:对全部类可见，包含本类，同包其余类或者子类，其余包的类或者子类。protected:对本类可见，对同包其余类或者子类可见，对其余包的类或者子类不能够见。private:只对本类可见，对同包其余类或者子类不可见，对其余包的类或者子类不能够见。默认：则是对同一包内可见。实例以下：

package com.cnblogs;

public class Men {
    
    public String name;//共有属性
    private int age;//私有属性
    protected String sex;//受保护的属性
    int a=10;//默认的
}

变量的做用域，包含所有变量和局部变量举例以下:

package com.cnblogs;

public class Men {
    //所有变量，在整个做用域均可以使用
    public String name;//共有属性
    private int age;//私有属性
    protected String sex;//受保护的属性
    int a=10;
    public static void main(String[] args) {
        //定义的i是局部变量，只能够在for循环这个局部内进行使用
        for(int i=0;i<10;i++){
            System.out.println("局部变量，在能够在局部进行使用"+i);
        }
    }
    
}

this 关键字用来表示当前对象自己，或当前类的一个实例，经过 this 能够调用本对象的全部方法和属性。成员变量与方法内部的变量重名时，但愿在方法内部调用成员变量，怎么办呢？这时候只能使用this。做为方法名来初始化对象，也就是至关于调用本类的其它构造方法，它必须做为构造方法的第一句。做为参数传递，须要在某些彻底分离的类中调用一个方法，并将当前对象的一个引用做为参数传递时。

package com.cnblogs;

public class Dog {
    
    int a=21;
    int b=12;
    
    public Dog(){//this关键字做为方法名来初始化对象
        this(23,43);
    }
    
    public Dog(int a, int b) {
        // TODO Auto-generated constructor stub
        this.a=a;
        this.b=b;
        System.out.println(a+" "+b);
    }

    public void add(){//经过this关键字能够调用类的属性和方法
        int c=this.a+this.b;
        System.out.println(c);
    }
    
    public void setA(int a){//使用this关键字区分同名变量
        this.a=a;
    }
    public int getA(){
        return a;
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Dog d=new Dog();
        d.add();
        
        d.setA(44);
        int dd=d.getA();
        System.out.println(dd);
    }

}

JAVA中方法的重载（构造方法也能够重载）即方法的名字相同，而方法的参数类型，个数，顺序不一样即为方法的重载注意1：声明为final的方法不能够重载，声明为static的方法不能被重载，可是可以被再次声明。注意2：仅仅是返回值类型不一样，不能构成方法的重载

package com.cnblogs;

public class Cat {
    
    public void cat(){
        System.out.println("方法的重载");
    }
    public void cat(int a,int b){
        System.out.println("方法的重载，方法中参数的个数");
    }
    public void cat(String c,int d){
        System.out.println("方法的重载，方法中参数的类型不一样");
    }
    public void  cat(int e,String f){
        System.out.println("方法的重载，方法中参数顺序不一样");
    }
    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
    }

}

包装类（Wrapper Classes），拆箱和装箱.基本类型和对应的包装类能够相互装换：由基本类型向对应的包装类转换称为装箱，例如把double包装成 Double 类的对象；包装类向对应的基本类型转换称为拆箱，例如把 Integer 类的对象从新简化为 int。

package com.cnblogs;

public class Sun {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int a=32;
        Integer i=new Integer(a);
        System.out.println("手动进行装箱"+i);
        
        int a2=i.intValue();//此方法的做用是以int值返回此Integer对象
        System.out.println("手动进行拆箱"+a2);

　　　int a4=54;
        Integer i4=a4;//自动装箱
        System.out.println("自动进行装箱"+i4);
    }

}

接口和抽象类

对于面向对象编程来讲，抽象是它的一大特征之一。在Java中，能够经过两种形式来体现OOP的抽象：接口和抽象类。学习

在了解抽象类以前，先来了解一下抽象方法。抽象方法是一种特殊的方法：它只有声明，而没有具体的实现。抽象方法的声明格式为：

abstract void fun();

抽象方法必须用abstract关键字进行修饰。若是一个类含有抽象方法，则称这个类为抽象类，抽象类必须在类前用abstract关键字修饰。由于抽象类中含有无具体实现的方法，因此不能用抽象类建立对象。从这里能够看出，抽象类就是为了继承而存在的，若是你定义了一个抽象类，却不去继承它，那么等于白白建立了这个抽象类，由于你不能用它来作任何事情。对于一个父类，若是它的某个方法在父类中实现出来没有任何意义，必须根据子类的实际需求来进行不一样的实现，那么就能够将这个方法声明为abstract方法，此时这个类也就成为abstract类了。
包含抽象方法的类称为抽象类，但并不意味着抽象类中只能有抽象方法，它和普通类同样，一样能够拥有成员变量和普通的成员方法。注意，抽象类和普通类的主要有三点区别：
1）抽象方法必须为public或者protected（由于若是为private，则不能被子类继承，子类便没法实现该方法），缺省状况下默认为public。
2）抽象类不能用来建立对象；
3）若是一个类继承于一个抽象类，则子类必须实现父类的抽象方法。若是子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。在其余方面，抽象类和普通的类并无区别。
接口，英文称做interface，在软件工程中，接口泛指供别人调用的方法或者函数。从这里，咱们能够体会到Java语言设计者的初衷，它是对行为的抽象。在Java中，定一个接口的形式以下：

[public] interface InterfaceName {`
}

接口中能够含有变量和方法。可是要注意，接口中的变量会被隐式地指定为public static final变量（而且只能是public static final变量，用private修饰会报编译错误），而方法会被隐式地指定为public abstract方法且只能是public abstract方法（用其余关键字，好比private、protected、static、 final等会报编译错误），而且接口中全部的方法不能有具体的实现，也就是说，接口中的方法必须都是抽象方法。从这里能够隐约看出接口和抽象类的区别，接口是一种极度抽象的类型，它比抽象类更加“抽象”，而且通常状况下不在接口中定义变量。this
抽象类和接口的区别
1.语法层面上的区别设计

　　1）抽象类能够提供成员方法的实现细节，而接口中只能存在public abstract 方法；

　　2）抽象类中的成员变量能够是各类类型的，而接口中的成员变量只能是public static final类型的；

　　3）接口中不能含有静态代码块以及静态方法，而抽象类能够有静态代码块和静态方法；

　　4）一个类只能继承一个抽象类，而一个类却能够实现多个接口。

2.设计层面上的区别

　　1）抽象类是对一种事物的抽象，即对类抽象，而接口是对行为的抽象。抽象类是对整个类总体进行抽象，包括属性、行为，可是接口倒是对类局部（行为）进行抽象。举个简单的例子，飞机和鸟是不一样类的事物，可是它们都有一个共性，就是都会飞。那么在设计的时候，能够将飞机设计为一个类Airplane，将鸟设计为一个类Bird，可是不能将飞行这个特性也设计为类，所以它只是一个行为特性，并非对一类事物的抽象描述。此时能够将飞行设计为一个接口Fly，包含方法fly( )，而后Airplane和Bird分别根据本身的须要实现Fly这个接口。而后至于有不一样种类的飞机，好比战斗机、民用飞机等直接继承Airplane便可，对于鸟也是相似的，不一样种类的鸟直接继承Bird类便可。从这里能够看出，继承是一个 "是否是"的关系，而接口实现则是 "有没有"的关系。若是一个类继承了某个抽象类，则子类一定是抽象类的种类，而接口实现则是有没有、具有不具有的关系，好比鸟是否能飞（或者是否具有飞行这个特色），能飞行则能够实现这个接口，不能飞行就不实现这个接口。

　　2）设计层面不一样，抽象类做为不少子类的父类，它是一种模板式设计。而接口是一种行为规范，它是一种辐射式设计。什么是模板式设计？最简单例子，你们都用过ppt里面的模板，若是用模板A设计了ppt B和ppt C，ppt B和ppt C公共的部分就是模板A了，若是它们的公共部分须要改动，则只须要改动模板A就能够了，不须要从新对ppt B和ppt C进行改动。而辐射式设计，好比某个电梯都装了某种报警器，一旦要更新报警器，就必须所有更新。也就是说对于抽象类，若是须要添加新的方法，能够直接在抽象类中添加具体的实现，子类能够不进行变动；而对于接口则不行，若是接口进行了变动，则全部实现这个接口的类都必须进行相应的改动。

多态

定义，多态指容许不一样类的对象对同一消息作出响应。即同一消息能够根据发送对象的不一样而采用多种不一样的行为方式。（发送消息就是函数调用）。
实现多态的技术称为：动态绑定（dynamic binding），是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。
现实中，关于多态的例子不胜枚举。比方说按下 F1 键这个动做，若是当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；若是当前在 Word 下弹出的就是 Word 帮助；在 Windows 下弹出的就是 Windows 帮助和支持。同一个事件发生在不一样的对象上会产生不一样的结果。
多态存在的三个必要条件1、要有继承；2、要有重写；3、父类引用指向子类对象。
Java中多态的分类：
在java中，多态大体能够分为如下几种状况：

1)person为父类，student为子类。那么：person p=new student()；

2)fliable为接口，bird为实现接口的类，那么：fliable f=new bird()；

3)fliable为抽象类，bird为继承fliable的类，那么：fliablef=new bird()；

多态时须要说明p声明为父类的引用，但他实际为子类引用。可是他只能调用父类中的方法。若是子类中的方法覆盖了父类方法，那么将调用父类方法（虚方法调用）。接口多态也是一样的，也许你会问，若是f要调用本身的方法，那岂不是出错了？其实这里也是方法的覆盖，由于实现接口的子类确定会实现接口中的方法，因此此种状况下调用的是bird中的方法。可是若是bird有一个方法在接口中没有定义，那么f不能调用。