面向对象

1 使用继承来实现复用时,子类对象可以直接赋给父类变量,这个变量具有多态性。

2 构造器用于对类实例经行初始化操作,构造器支持重载,如果多个重载构造器里包含相同初始化代码,可以把他们放在普通初始化块中完成,初始化块总在构造器执行前被调用。还提供静态初始化块,用于对初始化类,在类初始化阶段被执行。

3 类被认为是自定义的数据类型,使用类定义变量。称为引用类型变量,所有类是引用数据类型。

4 Java提供private protected public 三个访问控制修饰符来实现良好封装。

5 static 修饰的静态成员不能访问没有static修饰的非静态成员。

6 field 用于定义类或类实例包含的状态数据,方法用于定义类或类实例的行为特征或功能实现,构造器用于构造类的实例。

7 field定义    【修饰符】 field类型  field名【=默认值】 修饰符可以省略,可以是public protected private static final, public protected private只能出现一个,可以和static final组合修饰field

8 method定义   【修饰符】修饰符可以省略,可以是public protected private static final, abstract, public protected private只能出现一个,final, abstract只能出现一个,可以和static 组合修饰method

9 构造器不能定义返回值类型,也不能使用void定义构造器没有返回值,否则编译时不会出错,把他当方法处理。构造器有隐式的返回值类型,就是当前类

10 Person p = new Person()  产生了p变量,和Person对象

11 对象this引用 , 总是指向调用该方法的对象,在构造器中引用正在初始化 的对象,在方法中引用调用该方法的对象。作用是让一个类的方法访问该类的另一个方法或field。如果没有对象,则不能访问类中的其他方法。大部分时,普通方法访问其他方法,field时无需使用this前缀,但如果方法中某个变量和field同名,但又要访问这个field变量,则用this前缀

 class Person {
     int age;
     String name;
     void jump() {
         
     }
     void run() {
         age = 10;
         this.age = 10;
         new Person().age = 10;
         
         jump();
         this.jump();
         new Person().jump();
     }
     
     public static void main(String[] args) {
        run() //
        age = 10 //
    }
 }
View Code
 class Person {
     int age;
     String name;
     void jump() {
         
     }
     void run() {
         int age = 10;
         this.age = 10;  // 用this
     }

 }
View Code

12 方法不能独立定义,只能在类体里定义,方法要么属于类本身(static), 要么属于类的对象。永远不能独立执行方法,必须使用类或对象做调用者。使用不同对象作为调用者调用一个普同方法,可能得到不同结果。

13 方法参数传递机制 :如果方法中包括形参的声明,调用方法时必须给形参指定参数值,调用方法时实际传给形参的参数值被称为实参,实参如何传入方法呢?值传递,将实际参数值的副本传入方法内,参数本身不会受影响。基本类型和引用类型都是值传递,

    static void swap(int a, int b) {
        int temp = b;
        b = a;
        a = b;
    }
    public static void main(String[] args) {
        int a = 9;
        int b = 10;
        System.out.println("a = " + a +  "  b = " + b);
        swap(a, b);
        System.out.println("a = " + a +  "  b = " + b);
    }
View Code

长度可变的形参只能处于形参列表的最后,方法中只能包含一个长度可变形参,长度可变形参可以传入多个参数,也可以传入一个数组。

    static void swap(String a, int... b) {
        for (int i : b) {
            System.out.println(i);
        }
    }
    public static void main(String[] args) {
        swap("a", 1,2,3);
        swap("a", new int[]{1,2,3});
    }
View Code

14 方法重载 

        同一个类里定义多个同名方法,只要形参列表不同就行,确定一个方法要3个要素1 调用者(方法的所属者,类,对象),方法名,形参列表。

方法重载要求两同一不同,同一个类中方法名相同,参数列表不同,和返回值,修饰符没关系。

可变参数方法重载,

public class My {
        
    static void swap(int... b) {
        System.out.println("参数可变");
    }
    static void swap(int b) {
        System.out.println(b);
    }
    public static void main(String[] args) {
        swap(1,2,3); // 执行1
        swap(new int[]{3});  // 执行1
        swap();  // 执行1
        swap(1);  // 执行2
        
    }
 }
View Code

成员变量:在类范围内定义 的变量,类成员变量从类的准备阶段开始存在,直到系统完全销毁这个类,类成员变量的作用域和类的生存范围相同,实例成员变量从实例被创建起开始存在,直到系统完全销毁实例。

局部变量有3种 1 形参,方法签名时定义的变量,方法内有效,2 方法局部变量:方法体内定义的变量,从变量定义的地方开始到方法结束有效,3代码块局部变量:从变量定义的地方开始到块结束有效,除形参外,必须为局部变量赋值才可以使用她。

一个类中不允许定义两个名字相同的局部变量或成员变量,但允许局部变量和成员变量同名,如果方法里的局部变量和成员变量同名,局部变量会覆盖成员变量,如果想使用成员变量可以使用this或类名

public class My {
    static int  a = 0;
    int b = 0;
    {
        int b = 9;
        System.out.println(this.b);
    }
    static void swap(int... b) {
        int a = 9;
        System.out.println(My.a);
    }
    static void swap(int b) {
        System.out.println(b);
    }
    public static void main(String[] args) {
        new My();    
    }
 }
View Code

在类的准备阶段,系统将会为类的类成员变量分配内存空间,并指定默认初始值。只存在一份。

在创建对象时,系统会为实例成员变量分配内存空间,并指定默认初始值。

 15 外部类可以使用public和包访问权限,private 和protected对外部类没有意义。

16 模块设计追求高内聚(尽可能把模块的内部数据,功能实现细节隐藏在模块内部独立完成,不允许外部直接干预)低耦合(仅暴露少量方法给外部使用)

17 Java引入包机制,提供类的多层命名空间,用于解决类的命名冲突,类文件管理问题。位于包中的每个类的完整类名应该是包名和类名的组合。需要2方面保证1 源文件使用package指定包名,2 class文件必须放在对应路径下。

inport   包名,类名(*)  导入静态方法或域  inport static 包名.类名.属性|方法(*)

18 方法重写  “两同两小一大” , 两同:方法名,参数列表相同,两小:子类方法返回值类型比父类更小或相等,声明抛出的异常比父类声明抛出异常更小或相等。一大:子类方法访问权限比父类更大或相等。覆盖和被覆盖方法要么都是类方法,要么都是实例方法。

class BaseClass {
    public static void test() {
        
    }
}

class SubClass extends BaseClass{
    public void test() {    // 错误  一个类方法,一个实例方法
        
    }
}
View Code

当子类覆盖父类方法后,子类对象无法访问父类中被覆盖方法,但可以在子类方法中调用父类中被覆盖方法(可是使用super实例方法,或父类类名,类方法,作为调用者调用父类中被覆盖方法)

如果父类方法private,该方法对子类隐藏,子类无法方法该方法,也无法重写该方法,如果子类中定义了一个与父类private方法具有相同方法名,形参列表,返回值类型方法,仍不是重写,只是子类中的一个新方法。

class BaseClass {
    private static void test() {
        
    }
}

class SubClass extends BaseClass{
    public void test() {    // 不是重写,不加static
        
    }
}
View Code

19 可以使用super调用从父类继承的方法或field。如果子类定义了和父类同名的field,则会发生子类field隐藏父类field的情况,可以使用super访问隐藏field

class BaseClass {
    public void a() {
        
    }
}

class SubClass extends BaseClass{
    public void test() {    // 不是重写,不加static
        super.a();
    }
}
View Code

如果子类中没有包含和父类同名field,子类实例方法中访问该field时,无需显示使用super或父类名作为调用者,如果在某个方法中访问名为a的field,但没有显示指定调用者,则查找a的顺序为  1 局部变量  2 当前类field  3 父类field     访问哪个实例变量由声明变量类型决定

public class My {
    public static void main(String[] args) {
        SubClass sb = new SubClass();
        System.out.println(sb.a);  //
        System.out.println(((BaseClass)sb).a);
    }
 }
class BaseClass {
    public int a = 0;
    
}

class SubClass extends BaseClass{
    private int a = 9;
}
View Code

20 Java引用变量有两个类型,一个是编译类型,一个是运行时类型。编译时类型由声明该变量时用的类型决定,运行时类型由实际赋给该变量的对象决定,如果编译类型和运行类型不一致,可能发生多态。

21 向上转型:把子类对象赋给父类引用变量,无需任何类型转换。

22 多态:相同类型的变量,调用同一个方法时呈现出多种不同行为特征。

23 引用变量强制类型转换:引用变量只能调用他编译时类型的方法,bu能调用它运行时类型方法,如果需要让变量调用运行时类型方法,需要把变量强制类型转换为运行时类型,引用类型之间的转换只能在具有继承关系的两个类型之间经行,否则就会编译错误。

public class My {
    public static void main(String[] args) {
        SubClass sb = new SubClass();
        Math m = (Math)sb;  // 无法转换,没有继承关系,编译出错
    }
 }
class BaseClass {
    
}

class SubClass extends BaseClass{
    private int a = 9;
}
View Code
public class My {
    public static void main(String[] args) {
        Object sb = new SubClass();
        Math m = (Math)sb;  // 将抛出classcastexceptio
    }
 }
class BaseClass {
    
}

class SubClass extends BaseClass{
    private int a = 9;
}
View Code

24 instanceof 运算符前一个操作数是一个引用类型变量,后一个操作数是一个类,判断前面的对象是否是后面的类或子类的实例。前面操作数的编译时类型要么与后面的类相同,要么具有继承关系,否则会编译错。

 public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String) anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                            return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }
View Code

25 初始化块,声明实例field指定的默认值都可以认为是对象的初始化块,他们的执行顺序与源程序的排列顺序相同

public class My {
    public static void main(String[] args) {
        System.out.println(new SubClass().a);  // 输出9
    }
 }

class SubClass{
    {
        a = 0;
    }
    int a = 9;
}
View Code

26 超类静态初始化块 , 父类静态初始化块,子类静态初始化块  超类初始化块,构造器。。。。

class Root {
    static {
        System.out.println("root static");
    }
    {
        System.out.println("root not static");
    }
    Root() {
        System.out.println("root construct");
    }
}

class Mid extends Root {
    static {
        System.out.println("Mid static");
    }
    {
        System.out.println("Mid not static");
    }
    Mid() {
        super();
        System.out.println("Mid construct");
    }
}

class Leaf extends Mid {
    static {
        System.out.println("Leaf static");
    }
    {
        System.out.println("Leaf not static");
    }
    Leaf() {
        super(); // 默认调用
        System.out.println("Leaf construct");
    }
}

root static
Mid static
Leaf static
root not static
root construct
Mid not static
Mid construct
Leaf not static
Leaf construct

 

posted on 2017-09-15 20:06  wheleetcode  阅读(176)  评论(0编辑  收藏  举报