首页 > 文章 > Java > Java基础之类和对象、单例模式、继承

Java基础之类和对象、单例模式、继承

巴扎黑原创: 2017-06-26 11:29:32991浏览

Java类和对象

一般的类只能是public或者default的，若是public的，类名必须和文件名一样。一般在一个文件只写一个类，故这个类一般是加上public。

内部类还可以是private和protected，一般私有化（private），因为只有当前这个类才需要。这样只有它的外部类可以直接访问。所以里面的数据也无所谓是public还是private或者default的。

public class Out {private int d = 10;public int add() {      // 外部类不能直接访问内部类的数据，除非new出内部类对象,如下  // Out.In abc = new Out().new In();a = 3; // falseb = 5; // false}  // 内部类private class In {private int a = 100;int b;public int c;public void add() {
            System.out.println(d); // true, 内部类却可以直接访问外部类的数据}
    }public static void main(String[] args) {
        Out bb = new Out();
        Out.In abc = new Out().new In();
        bb.d = 20; // 本类可以直接访问private，一般不这样，而是写个set函数，搭配get函数System.out.println(aa.a); // 100System.out.println(bb.d); // 被修改为20}
}

匿名对象

new Abc().run(); // 调用一次后这个对象就销毁new Abc().run(); // 这是另外一个Abc对象了

关于private
private变量：封装数据，只给用户看方法。例如private String name不能随修改，但是提供setName()、getName()方法可调用，实现数据的封装，更安全。
private方法：不用用户调用的函数，完成一些内部实现的细节，就可以定义成private。例如选择排序算法写成一个方法，里面有交换两个数据的过程，封装成函数。这个函数不需给用户操作（用户只需用一个sort()就行），这个swap()就定义成private的。

单例设计模式

可以保证一个类在内存中的对象唯一性，需对过个程序使用同一配置信息对象时，就需要保证对象的唯一性，这时就需要单例。

工具类中，未用到（访问）对象成员数据，则可不用创建对象。为了防止创建对象，可以将构造函数定义为private。

如何保证对象的唯一性？

不允许其他程序用new创建该类对象，构造函数设为private
在该类创建一个唯一的类实例
对外提供一个方法使其他程序可以获取到这个唯一对象

单例设计步骤

私有化（private）该类的构造函数
通过new在本类汇总穿件一个本类对象
定义一个puiblic方法，将2中创建的对象返回

饿汉模式

// 饿汉式--不管用不用得到，先new出一个再说public class SingleDemo {// private不能将这个实例暴露出去，只能通过getInstance()获取，另为何是static？private static SingleDemo s = new SingleDemo();private SingleDemo() {}// 供外界调用来获取这个对象public static SingleDemo getInstance() {return s;
    }  // 只有本类中可以new对象并调用addpublic void add() {
        System.out.println("danli");
    }public static void main(String[] args) {      // 本类可以newSingleDemo a = new SingleDemo();
        a.add();
    }
}public class Test {public static void main(String[] args) {      // fasle, 其他类中若用到这个单例，不能newSingleDemo aa = new SingleDemo();      // true  SingleDemo aa = SingleDemo.getInstance();
    }
}

懒汉模式

// 另外一种单例设计模式--懒汉模式--用到了才new，延时加载public class SingleDemo {// 先设为空private static SingleDemo s;private SingleDemo() {}// 供外界调用来获取这个对象public static SingleDemo getInstance() {      if (s == null)
        s = new SingleDemo();return s;
    }

Q：为何成员变量是static，方法也是static？

A：因为在其他类中，不允许new出新对象，故不能调用getInstance()，如果我们设成静态方法，就可以通过Single.getInstance()来获取而无需new对象，又静态方法里的数据也必须是static的。故这个SingleDemo对象也必须是static的。

Q：饿汉模式和懒汉模式的区别？
A：懒汉模式是延时加载的，用到了才new；在多线程时不能保证对象的唯一性，是线程不安全的。饿汉模式是随着类的加载，就new出这个对象，不管用不用得上，是线程安全的。

继承

Java一般是单继承，不能直接多继承 --> 因为多个父类可能有相同的成员，调用会导致二义性。

但是可以多层继承，如 A --> B -->Ｃ--> D，可以表示A继承自B，而B继承自C，以此类推。

本类成员和局部变量之间用this区分
子类、父类的成员同名时用super区分
派生类也不能访问基类的private成员，但是确实是继承过来了，只是不能访问而已，可以调用父类的set、get函数来操作子类的private成员，对父类没影响。
若成员是protected等权限更高的，则不用set、get就可直接访问该成员。
父类与子类的该成员是相互独立的，子类改变它自己的成员，父类保持原样。

package Chap1;public class Fu {  // 父类的成员是私有的，子类继承过去了也不能直接访问
  private int age;private String name;public Fu(int age, String name) {this.age = age;this.name = name;
    }public int getAge() {return age;
    }public void setAge(int age) {this.age = age;
    }public String getName() {return name;
    }public void setName(String name) {this.name = name;
    }
}class Zi extends Fu {  // 特有的job，父不能访问private String job;Zi(int age, String name, String job) {super(age, name);this.job = job;
    }public String getJob() {return job;
    }  public static void main(String[] args) {
        Zi aa = new Zi(23, "Zi","Study");
        Fu bb = new Fu(55, "Fu");      // 改变子类不会影响父类aa.setAge(24);
        aa.setName("zi");      // zi 24 Study  // Fu 55System.out.println(aa.getName()+" "+aa.getAge() + " " + aa.getJob());
        System.out.println(bb.getName()+" "+bb.getAge());

    }
}

子类隐式执行super()，new一个子对象时，先调用父类的构造函数，再执行子类的构造函数。
默认的构造函数是无参的，有参数的构造函数会覆盖无参的。这时候需要显式使用super(args)，且必须放在第一行，若不显式写super，则执行默认的super()，即无参的父类构造函数。

class Fu {  // 构造函数
  Fu() {
    System.out.println("father");
  }  // 带参的构造函数
   public Fu(int age, String name) {this.age = age;this.name = name;
    }
}class Zi extends Fu {  
  Zi() {private String job;// super() 会打印“father”// 无参数时是默认构造器，这句super()可以不写。父类的构造函数默认执行，先执行// 
  }  
  Zi(int age, String name, String job) {// 若不写，会默认调用无参的super()打印fathersuper(age, name);this.job = job;
    }
}

类是public，构造函数也是public的。他们的修饰符是对应的。

一个对象的实例化过程

Person p = new Person();

JVM读取Person.class文件，加载进内存；若有父类，会先加载父类。
在堆内存中开辟空间，分配地址。
在对象空间中，对对象的属性进行默认初始化，如int age = 0; String name = null;
显示初始化，如private int age = 9。若是子类，则会先调用父类的构造器。
（子）类的构造函数进行特定的初始化。如下程序中age变成100。
初始化后，将地址传递给引用变量。Person p <-- new Person();

package Test;// 先打印9// 再打印100public class Demo {private int age = 9;
    {
        System.out.println(age);
    }Demo(int age) {this.age = age;
    }public static void main(String[] args) {
        Demo aa = new Demo(100);
        System.out.println(aa.age);
    }
}

以上是Java基础之类和对象、单例模式、继承的详细内容。更多信息请关注PHP中文网其他相关文章！

声明：

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系admin@php.cn

上一篇：Java字符串进阶下一篇：Java基础——继承

查看更多