关闭

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

60人阅读 评论(0) 收藏 举报
分类:

  ——- 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 classinterface区别
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]);
}
}
}
0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:235次
    • 积分:40
    • 等级:
    • 排名:千里之外
    • 原创:4篇
    • 转载:0篇
    • 译文:0篇
    • 评论:0条
    文章分类
    文章存档