疯狂java


您现在的位置: 疯狂软件 >> 新闻资讯 >> 正文

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


 

 
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; // false
        b = 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); // 100
        System.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对象并调用add
    public void add() {
        System.out.println("danli");
    }
    public static void main(String[] args) {
      // 本类可以new
        SingleDemo a = new SingleDemo();
        a.add();
    }
}
 
public class Test {
    public static void main(String[] args) {
      // fasle, 其他类中若用到这个单例,不能new
        SingleDemo 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 -->C--> 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 55
        System.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()打印father
        super(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
// 再打印100
 
public 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);
    }
}