android（java）知识累积

1、android 控件的 visibility 属性

android 控件的 visibility 属性有 3 个值：visible，invisible，gone。

visible：设置控件可见；

invisible：设置控件不可见；界面保留了 view 控件的占位空间；

gone：设置控件隐藏；界面不保留 view 控件的占位空间。

 

2、java/python 格式化输出

%nd 输出的整型宽度至少为 n 位，右对齐，不足 n 位用空格填充；%5d即宽度至少为5位，宽度大于5则按照实际宽度输出；

%0nd 输出的整型宽度至少为 n 位，右对齐，不足 n 位用0 填充；%05d 即宽度至少为 5 位，宽度大于 5 按照实际宽度输出；

3、成员变量，成员方法定义

4、java 访问控制修饰符

friendly访问特性被称为 包访问特性。

 

5、java-Cloneable 接口。（为什么要重写 clone(),深拷贝和浅拷贝）

1）某个类若调用 clone(),首先需要实现 Cloneable 接口。这相当于类对象支持 clone()的标识；

2）如果在没有实现 Cloneable 接口的类实例上调用 Object 的 clone()方法，会导致抛出 CloneNotSupportedException;

3）Object 的 clone()方法是一个受保护的方法，实现此接口的类应该使用公共方法重写 Object的 clone()方法。

【为什么要用public 重写 clone()方法，目标类继承树的顶端都是 Object 类，也是可以访问 clone()方法的呀~】

1、因为Object 的 clone()方法是一个受保护（protected）的方法，如果不重写，在不同包下，别的类即使用目标类的对象也不能访问目标类继承的 clone()方法，只能在目标类内使用，局限性很大，所以一般都会进行重写，并扩大成 public 范围；

2、Object.clone()只是提供了浅层拷贝，对于基本类型的字段，可以成功克隆，但对于引用类型，只是复制了对象的引用关系，但没有创建新的对象。所以含有引用类型的字段要“定制”完成深度克隆。

【何为深拷贝，何为浅拷贝】

java 中有两种数据类型（基本数据类型和类的实例对象这个引用数据类型）。用“=”赋值操作时候，对于基本数据类型，是拷贝值；对于引用数据类型，赋值的只是对象的引用，将原对象的引用传递过去，实际还是指向的同一个对象。

浅拷贝：拷贝对象的时候，只对基本数据类型进行了拷贝，而对引用类型进行引用的传递，没有真正创建一个新的对象。则认为是浅拷贝。

深拷贝：拷贝对象的时候，对基本数据类型进行了拷贝，对引用类型进行拷贝的时候，创建了一个新的对象，并且复制了其内的成员变量。则认为是深拷贝。

代码说明：同一个包下，有两个类：Person 类和Book 类，Book 类中有一个 Person 类的成员变量。代码分别实现浅拷贝和深拷贝。

Person 类代码：

package com.company;

public class Person implements Cloneable{
    String name;
    int age;

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

    }

    public void setName(String name){
        this.name = name;
    }

    public void setAge(int age){
        this.age = age;
    }

    public String getName(){
        return this.name ;
    }

    public int getAge(){
        return this.age ;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

Book 类代码：

package com.company;

public class Book implements Cloneable {
    //Book 类的成员变量，其中包含一个 Person类的 author 变量。
    String bookname;
    double price;
    Person author;

    public Book(String bn,double price,Person author){
        bookname = bn;
        this.price =  price;
        this.author = author;
    }

    //浅拷贝实现
//    @Override
//    public Object clone(){
//        Book b = null;
//        try{
//            b =  (Book) super.clone();
//        } catch (CloneNotSupportedException e){
//            e.printStackTrace();
//        }
//        return b;
//    }
    //深拷贝实现
    @Override
    public Object clone(){
            Book b = null;
            try{
                //调用 object 类对象的 clone()方法，返回一个 Object 类型的需要克隆的对象。
                b =  (Book)super.clone();
                //将Person 对象进行拷贝，Person 类也实现了 Clonable 接口
                b.author = (Person)this.author.clone();
            } catch (CloneNotSupportedException e){
                e.printStackTrace();
            }
            return b;
    }


    public static void main(String[] args) {
        Person p = new Person("Dream",34);
        Book book1 = new Book("java开发",30.00,p);
        //需要进行强制类型转换，clone()方法返回对象类型为 Object
        Book book2 = (Book) book1.clone();
        book2.price = 44.00;
        book2.author.setAge(45);
        book2.author.setName("Fish");
        book2.bookname = "android 开发";
        System.out.println("age= "+book1.author.getAge()+ " name= " + book1.bookname + "    price= "+book1.price);
        System.out.println();
        System.out.println("age= "+book2.author.getAge()+ " name= " + book2.bookname + "    price= "+book2.price);

    }
}

 

敲一遍代码并运行，一切明了。

 

参考地址：

https://www.cnblogs.com/plokmju/p/7357205.html
https://blog.csdn.net/qq_28929579/article/details/53965316

https://www.jianshu.com/p/8c74edbb46c0