黑马程序员——JAVA类和对象

　　——- android培训、java培训、期待与您交流！ ———-

类和对象

1.方法

1. 实例方法
2. 类方法。加载类时加载该方法，并一直存在于内存中的方法区。不需要实例化即可调用。
3. 构造方法。实例化类时自动调用。

构造方法访问修饰符为public，如果为private，本类才可访问，即私有化对象。对实例进行封装，保证实例的安全性。

public Test{
private Test(){}//私有化对象
private static Test instance;
public static Test getInstance(){
if(instance=null){
instance=new Test();
return instance;
}
return instance;
}
}

修饰符对应的作用域

作用域	类	同包	子类	其他
public	ok	ok	ok	ok
protected	ok	ok	ok
default	ok	ok
private	ok

文本格式化

DecimalFormat f= new DecimalFormat("#00.00");
double num=111.11;
System.out.println(f.format(num));

---

2.面向对象的基本特征：

1. 封装。
2. 继承。
3. 多态。
4. 抽象。

abstract class 和interface区别
abstract class可有自己的数据成员，也可以由非abstract的成员方法，并赋与默认行为。interface内部方法全是abstract方法。

static：

1. 修饰成员变量。static类变量和类的信息一起存储在方法区。
2. 修饰成员方法。由于static在调用时没有具体的对象，所以static方法不能对非static成员（对象成员）进行访问。
3. static块：类的代码块，在类加载期间执行一次。用来加载静态资源。

final:

1. 变量不可改变，方法不可覆盖，类不可继承。
2. final方法可以被继承，private变量和方法不能被继承。
3. final类不可被继承，但是内部的属性值可改变。
4. static final 1.声明的时候实例化。2.静态代码块实例化。

匿名代码块：在对象实例化之前被执行。
static匿名代码块：类加载被执行，在static方法之前。

---

3.继承

• 类与类之间满足”is-a“的关系。可以减少重复代码编写。
• 继承某个类后具备该类的属性和方法，但受到访问修饰符的限制。
• 在创建一个子类对象时，会先创造一个父类对象。子类继承了父类private方法和变量，但是不可访问。
• 继承后，对象创建顺序：先父类对象，再子类对象。
• 当父类没有空构造方法时，子类必须在自己构造方法中先手动调用父类有参构造方法。

public class Father {
    private String name;
    private Father(){
        System.out.println("父类对象被创建");
    }
    public Father(String s){
        System.out.println("父类对象被创建"+s);

    }
}


public class Son extends Father {

    public Son(String s){
        super(s);//
    }
    public static void main(String[] args) {
        Son son=new Son("time");
            }
}

栈内存：
堆内存：

JUNIT @Test测试无参无返回值方法 stackoverflowerror栈溢出

super:
- 调用父类的实例方法，一般用于子类方法重写中，调用父类被重写方法。
- 调用父类的构造方法，一般用于子类构造方法中，调用父类带参构造方法。

重写，子类对父类方法重写和覆盖。方法与父类全部相同。只有访问修饰符访问范围可以增大。
方法重载，方法名相同，方法参数不同。作用：减小代码编写，增强程序可扩展性。

如果不想父类被创建，可以在类前面加上abstract关键字，抽象类无法实例化，只能实例化其子类。
在抽象类中，可以写抽象方法。

父类的引用指向子类的对象。编译时f以为是父类的引用（编译时对象没有生成），在运行时则指向子类的对象。父类的引用无法直接调用子类的方法。如果要调用，只能选择强制类型转换。（编译时确定了父类成员变量的，所以father.num指向父类的成员。任何成员变量访问操作都将由编译器解析，因此不是多态的。而this.method()是动态绑定，运行时绑定子类）
多态中，成员变量特点：无论编译和运行，都参照引用变量所属的类。
Father f=new Son();
父类实例依赖于子类的实例化

抽象方法使用abstract修饰，没有方法体。只存在抽象类和接口中

Father father=new Son();
多态：同一个引用类型不同的实例执行相同方法时，操作不同，结果不同。
多态前提：类与类之间要么继承要么实现。
多态的弊端：提高了扩展性，只能使用父类引用访问父类的成员。
开闭原则：对扩展开放，对修改关闭。

实现多态：先继承，再重写方法。编写方法时，用父类作为参数。调用方法时，传入子类的对象。

new是在堆内存中生成一个容器，实体用于封装数据，数据都有默认初始化值。
静态代码块给类初始化，非静态代码块给对象初始化。构造函数给对应对象初始化。

模版方法

一部分代码给子类复写。提高扩展性和复用性。

abstract class AbstractSort {
/**
* 将数组array由小到大排序
* @param array
*/
protected abstract void sort(int[] array); //不确定部分子类实现
//部分确定
public (final) void showSortResult(int[] array){
this.sort(array);
System.out.print("排序结果：");
for (int i = 0; i < array.length; i++){
System.out.printf("%3s", array[i]);
}
}
}