2018-08-09 工作日志

Java 数组 访问权限修饰符 内部类 继承

1. 二维数组

1.1 初始化

//静态初始化
//指定了值，就不能在【】中指定大小
int[][] dyadicArray2=new int[][]{{1,2,3},{3,2,1},{1}};
//动态初始化
int[][] dyadicArray=new int[3][4];
dyadicArray[0]=generateRandomNum(0, 10, 4);
dyadicArray[1]=generateRandomNum(0, 10, 4);
dyadicArray[2]=generateRandomNum(0, 10, 4);
String[][] dyadicStringArray=new String[3][4];
dyadicStringArray[0]=generateRandomNumber(0,10,4);
dyadicStringArray[1]=generateRandomNumber(0,10,4);
dyadicStringArray[2]=generateRandomNumber(0,10,4);
//Console.log(dyadicArray);
//Console.log(dyadicStringArray);
int[][] dyadicArray3=new int[3][];

1.2 遍历

//遍历二维数组
System.out.println("遍历二维数组");
ergodic(dyadicArray);
ergodic(dyadicArray2);
ergodic(dyadicStringArray);
。。。。
public static void ergodic(int[][] darray){
    for (int[] i:darray){
        for (int j:i){System.out.print(j);}
        System.out.print(",");
    }
    System.out.println();
}
public static void ergodic(String[][] darray){
    for (String[] i:darray){
        for (String j:i){System.out.print(j);}
        System.out.print(",");
    }
    System.out.println();
}

1.3 数组的复制

• 基本类型：
  
  • 一维数组

    /*
     * @Author 黄昭鸿
     * @Description 使用System.arraycopy复制数组
     * @Date 18-8-9 上午9:54
     * @Param []
     * @Return void
     **/
    public static void copyDyadicArray(){
        int[] a={88,99,77,1,2,3,4,5,6,7,8,9,0,6,9};
        int[] b={1,1,1,1,1,1,1,1,1,1};
        //对于一维基本数据类型数组来说，System.arraycopy这种复制属性值传递，修改副本不会影响原来的值
        //源数组，源数组起始位置，目标数组，目的数组放置的起始位置，复制的长度
        System.arraycopy(a,1,b,1,a.length-6);
        //对于二维或者一维数组中存放的是对象时，System.arraycopy复制结果是一维的引用变量传递给副本的一维数组，修改副本时，会影响原来的数组
        for (int i:b){System.out.print(i+".");}
    }

• 引用类型：
  
  • 的
  • s

//二维数组常用方法

2. 对象数组

kkkk

3. 内部类

/*
 * @Description 内部类InternalClassDemo
 * @Date 18-8-9 上午10:24
 **/
public class InternalClassDemo{
    public static void main(String[] args)  {
        new OutterClass();
        //必须通过外部类对象创建成员内部类的对象
        OutterClass.MemberInternalClass memberInternalClass=new OutterClass().new MemberInternalClass();
        //方式二
        OutterClass.MemberInternalClass memberInternalClass1=new OutterClass().getMICInstance();
        memberInternalClass.showInfo();
        memberInternalClass1.showInfo();
        //静态内部类不能使用外部类的非static成员变量或者方法
        new OutterClass.StaticInternalClass();
    }
}
class OutterClass {
    //构造方法
    public OutterClass() {
        //在外部类中，如果要访问成员内部类的成员，必须先创建一个成员内部类的对象，再通过指向这个对象的引用来访问
        new MemberInternalClass().showInfo();
    }
    //成员方法
    public void showInfo(){
        System.out.println("外部类");
        //局部内部类
        class LocalInternalClass{
            public LocalInternalClass() {
            }
        }
    }
    public static void staticMethod(){
        System.out.println("外部类的静态方法");
    }
    public MemberInternalClass getMICInstance(){
        return new MemberInternalClass();
    }
    //成员内部类
    class MemberInternalClass{
        public MemberInternalClass() {}
        //同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问的是成员内部类的成员
        public void showInfo(){
            System.out.println("成员内部类");
            OutterClass.this.showInfo();
        }
    }
    //静态内部类
    static class StaticInternalClass{
        public StaticInternalClass() {
            //静态内部类不能使用外部类的非static成员变量或者方法
            staticMethod();
        }
    }
    //AnonymousInnerClass匿名内部类
}

4. 四种访问权限修饰符

private、default(缺省不写)、protected、public
private和protected不能修饰接口

4.1 对类属性和方法的访问：

注意：
在同包内，类中 protected 或 default 修饰的属性或方法可以被其对象外部访问，可以被子类继承。protected 或 default 的访问级别与 public 相同。
在异包内,，类中 protected 修饰的属性或方法不可以被其对象外部访问，可以被子类继承（同其他语言相同）。类中 default 修饰的属性或方法不可以被其对象外部访问，不可以被子类继承，此时 default 如同 private。

4.2 方法的继承规则：

父类中声明为 public 的方法在子类中也必须为 public。
父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private。
父类中声明为 private 的方法，不能够被继承。

4.3 对于类：

public 或default(缺省不写)，内部类可以private、protected

5. 封装Encapsulation

一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法。

5.1 封装的优点

1. 良好的封装能够减少耦合。
2. 类内部的结构可以自由修改。
3. 可以对成员变量进行更精确的控制。
4. 隐藏信息，实现细节。

5.2 实现Java封装的步骤

1. 修改属性的可见性来限制对属性的访问（一般限制为private）
2. 对每个值属性提供对外的公共方法访问（通常为getter和setter）

Kingdom.java

package com.nl.sx809.JavaAccessModifiers;
/*域(Domain)、界（Kingdom）、门（Phylum）、纲（Class）、目（Order）、科（Family）、属（Genus）、种（Species）*/
interface Domain {
    public String vitalsigns();
    public void showInfo();
}
class Phylum extends Kingdom {
    protected String name="门";
}
class ClassT extends Phylum {
    public void changeName(){
        //此处将覆盖父类的name属性
        this.name="而非国际化女同胞拍马屁年龄在客户处副本";
    }
}
class Order extends ClassT {}
class Family extends Order {}
class Genus extends Family {}
class Species extends Genus {}
public class Kingdom implements Domain  {
    /*
    * 方法的继承规则：
    * 父类中声明为 public 的方法在子类中也必须为 public。
    * 父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private。
    * 父类中声明为 private 的方法，不能够被继承。
    * */
    protected String name="界";
    protected String signs="activity";
    public Kingdom() {}
    @Override
    public String vitalsigns() {
        return signs;
    }
    @Override
    public void showInfo() {
        System.out.println("I am "+vitalsigns()+",my name is "+name);
    }
    //getter、setter
    public void setSigns(String signs) {
        this.signs = signs;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

AccessModifiersDemo.java

package com.nl.sx809.JavaAccessModifiers;
/*
 * Description:四种访问权限修饰符
 * `private`、default(缺省不写)、`protected`、`public`
 * private和protected不能修饰接口
 * 详见笔记https://www.zybuluo.com/nextleaf/note/1243720
 * @author 黄昭鸿
 * @date 2018/8/9 17:50
 * @param
 * @return
 */
public class AccessModifiersDemo {
    public static void main(String[] args){
        Domain kingdom=new Kingdom();
        Kingdom phylum1=new Phylum();
        Kingdom phylum2=new Phylum2();
        Phylum classT1=new ClassT();
        ClassT order1=new Order();
        Order family1=new Family();
        Family genus1=new Genus();
        Genus species1=new Species();
        kingdom.showInfo();
        //属性没有多态性，其值取决于引用值
        //此处仍打印"界"
        System.out.println(phylum1.name);
        //通过构造方法覆盖属性值
        phylum2.showInfo();
        //方法具有多态性，可以借助继承的方法覆盖属性值
        classT1.setName("ClassTdemo");
        classT1.showInfo();
        order1.setName("OrderDemo");
        order1.showInfo();
        family1.setName("FamilyDemo");
        family1.showInfo();
        genus1.setName("GenusDemo");
        genus1.showInfo();
        species1.setName("SpeciesDemo");
        species1.showInfo();
    }
}