java面向对象

1.面向对象时一种思想，将功能封装进对象，强调具备了功能的对象

2.面向对象3大特性：封装、继承、多态。找对象，建立对象，使用对象，维护对象之间的关系

3.类和对象的关系：类就是对现实生活中事物的描述，是对具体的抽象

对象是这类事物实实在在的个体，具体对象是对应java在堆内存中用new建立的实体

属性对应类中的变量，行为对应类中的函数（方法），共同成为类中的成员（成员变量，成员方法）

使用对象的方式：对象.对象成员

Car c = new Car(); c是一个类类型变量，类类型变量指向对象

4.成员变量和局部变量

作用范围不同：成员变量作用于整个类中；局部变量作用于函数中，或语句中；

内存位置不同：成员变量在堆内存中，因对象存在而存在；局部变量在栈内存中。

5. 匿名对象： new 类名().方法; 如 new Car.run();

使用方式：当对对象只使用一次时，可以用匿名对象。使用完变垃圾

可以将匿名对象作为实际参数进行传递

6.封装 Encapsulation 隐藏对象的属性和实现细节，仅对外提供公共访问方式

好处：将变化隔离便于使用提高重用性提高安全性、

封装原则：将不需要对外提供的内容都隐藏；将属性封装，对外提供公共方法对其访问；

7. 构造函数

特点：函数名与类名相同不用定义返回值类型不可以写return语句

对象一建立，就会调用对应的构造函数。构造函数用于给对象初始化

当一个类没有定义构造函数时，系统会默认给该类加入一个空参数的构造函数。

当在类中定义了构造函数时，默认的构造函数就没有了。；多个构造函数是以重载的形式存在的

构造函数与一般函数对比：构造函数在对象一建立就运行，给对象初始化；一般函数是对象调用才执行，给对象添加功能

　　　　　　　　　　　　一个对象建立，构造函数只运行一次；一般函数可以被对象调用多次

8：构造代码块　　　{ ................... }

作用：给对象进行初始化对象一建立就运行，而且优先于构造函数执行

区别：构造代码块是给所有对象进行统一初始化；构造函数是给对应函数进行初始化

9. this 代表它所在函数所属对象的引用（哪个对象调用函数，this代表哪个对象）

10. static 是一个修饰符，用于修饰成员变量，成员函数

当成员被静态修饰后，多了一个调用方式，除了被对象调用，还可以被类名直接调用。类名.静态成员 Person.country

特点：1.随着类的加载而加载随着类的消失而消失，生命周期长（普通成员变量随对象创建而存在，称为实例变量）

2.优先于对象存在 3.被所有对象共享 4可以被类名所调用

实例变量与类变量区别：

1. 类变量被放在内存的共享区，也称为方法区、数据区；实例变量随着对象的建立而存在于堆内存中

2.类变量生命周期最长，随着类的消失而消失；实例变量生命周期随着对象的消失而消失

静态的使用注意事项：静态方法只能访问静态成员；静态方法中不可以定义this super 关键字，因为它优先于对象存在；主函数是静态的

11. 主函数是一个特殊的函数，作为程序的入口，可以被jvm调用

public 代表该函数访问权限最大

static 代表主函数随着的类的加载已经存在

　　main 不是关键字，是一个特殊的单词，可以被jvm识别

参数是字符串类型的数组

　　主函数是固定格式的，变量名args可以随意写，原名arguments

jvm在调用主函数时，传入的是 new String[0]

12. 什么时候定义静态变量？当对象中出现共享数据时

　　什么时候定义静态方法？当功能内部没有访问到非静态数据时

用静态方法组成的工具类，可以强制让该类不能创建对象，可以通过将构造函数私有化完成。

13. 帮助文档的制作 javadoc。 java的说明书通过文档注释来完成

/**

　　这是一个xxx工具类

　　@author 小米

　　@version V1

/**

　　@param abc

　　@return 　　

　　写文档的类必须是public 或 protected 修饰的

一个类中的默认构造函数，其权限和所属类是一致的

14. 静态代码块随着类的加载而执行，只执行一次。用于给类初始化，优先于其他成分执行

　　static { .............　　｝

15. 对象的初始化过程：

　　1. 先找到class文件，加载到内存中

　　2.先初始类中的static变量，再执行类中的static代码块

　　3.在堆内存中开辟空间，给对象分配内存地址

　　4.在堆内存中建立对象的特有属性，并进行默认初始化

　　5. 对属性进行显示初始化各种赋值

　　6.对对象进行构造代码块初始化

　　7.对对象进行对应的构造函数初始化

　　8.将对象的内存地址赋给栈内存的变量

//阿里笔试题
public class StaticTest {
    public static int k=0;
    public static StaticTest s1=new StaticTest("s1");
    public static StaticTest s2=new StaticTest("s2");
    public static int i=print("i");
    public static int n=99;
    public int j=print("j");
     
    {
        print("构造块");
    }
     
    static
    {
        print("静态块");
    }
     
    public static int print(String s)
    {
        System.out.println(++k+":"+s+"	i="+i+"	n="+n);
        ++n;
        return ++i;
    }
     
    public StaticTest(String s)
    {
        System.out.println(++k+":"+s+"	i="+i+"	n="+n);
        ++i;
        ++n;
    }
 
    public static void main(String[] args) {
        new StaticTest("init");
    }
}


输出结果：
1:j    i=0    n=0
2:构造块    i=1    n=1
3:s1    i=2    n=2
4:j    i=3    n=3
5:构造块    i=4    n=4
6:s2    i=5    n=5
7:i    i=6    n=6
8:静态块    i=7    n=99
9:j    i=8    n=100
10:构造块    i=9    n=101
11:init    i=10    n=102

16. 设计模式一共有23种解决某一类问题最行之有效的方法

　　单例设计模式：解决一共类在内存中只存在一共对象

　　懒汉式: 方法被调用时，对象才初始化。 Single 类进内存，对象还没存在，只有调用了get方法时，才建立对象

　　饿汉式：Single类一进内存，就已经创建好了对象

class Single  //饿汉式
{
    private Single(){}
    private static Single s = new Single();
    public static Single getInstance()
    {
        return s;
    }
}

class Single    //懒汉式
{
    private Single(){}
    private static Single s = null;
    public static Single getInstance()
    {
        if(s==null)
            s = new Single();
        return s;
    }
}

17. 继承：提高了代码的复用性

　　　　　让类与类之间产生了关系，从而有了多态的特性

　　类与类之间有所属关系时，才可以继承。

　　java只支持单继承，多继承容易带来安全隐患，当多个父类中定义了相同功能，功能内容不同时，子类对象不确定运行哪一个

　　java保留了这种机制，并用另一种体现形式来表示，叫多实现。

　　java支持多层继承。

18.子父类出现后，类成员的特点

　　1.变量如果子类中出现了非私有的同名成员变量，子类要访问本来中的变量，有this; 访问父类中的变量，用 super。 this代表本来对象的引用， super代表父类对象的引用

2.函数当子类出现和父类一模一样的函数时，子类对象调用该函数，会运行子类的函数，父类的函数会被覆盖（重写）

　　　　　　覆盖的特点：子类覆盖父类，必须保证子类的成员权限大于对应的父类权限，否则编译失败；静态只能覆盖静态

　　　　　　重载只看同名函数的参数列表，重写：子父类函数要完全一样

19.子父类中构造函数的特点：

　　子类的实例化过程

　　子类的所有的构造函数，默认都会访问父类中空参数的构造函数。

　　因为子类每一个构造函数的第一行都有一句隐式的super(); 当父类中没有空参数构造函数时，子类必须手动通过super形式指定要访问父类中的构造函数

　　子类的构造函数第一行也可以指定this语句访问本类中的构造函数，子类中只有会有一个构造函数访问父类中的构造函数

20.final 关键字

　　1.可以修饰类、函数、变量

　　2.被final修饰的类不可以被继承。继承有个弊端：破坏了封装性

　　3.被final修饰的方法不可以被重写

　　4.被final修饰的变量是一个常量，只能赋值一次。既可以修饰成员变量，又可以修饰局部变量

　　　　应用：描述事物时，一些数据的值是固定的，为了增强阅读性，给这些值起名，用final修饰。作为常量，书写规范所有字母大写，单词间下划线连接

　　public static final double PI = 3.14;

　　5.内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量

21.抽象类的特点：

　　1.抽象方法一定在抽象类中 2.抽象方法和抽象类都必须被abstract修饰 3.抽象类不可以用new创建对象

　　4.抽象类中的方法要被使用，必须由子类复写其所有的抽象方法后建立子类对象使用。如果子类只重写了部分抽象方法，那么该子类还是抽象类

　　abstract int power();

　　抽象类不可以实例化。

　　抽象类中可以不定义抽象方法，作用是不让建立对象

22. 模板方法：在定义功能时，功能的一部分时确定的，但有一部分是不确定的，确定的部分在使用不确定的部分，那么这时就就将不确定的部分暴露出去，

　　由该类的子类完成。

23. 接口 interface 是一个特殊的抽象类，当抽象类中的方法都是抽象的，那么该类可以通过接口的形式表示

　　接口中成员修饰符是固定的

　　成员常量： public static final

　　成员方法： public abstract

　　接口不可以创建对象，需要被子类实现。子类对接口中的抽象方法全部覆盖之后，才可以实例化。 implements

　　接口可以被类多实现， java中一个类只能继承一个类，但可以同时实现多个接口

　　接口与接口之间可以有继承关系

24. 多态：某一类事物的多种存在形态

　　多态的体现：父类的引用指向了自己的子类对象；父类的引用接受自己的子类对象（形参）

　　多态的好处：大大提高了程序的扩展性

　　多态的前提：必须是类与类之间有关系：继承、或实现；存在覆盖

　　多态的弊端：提高了扩展性，但是只能使用父类的引用访问父类中的成员

　　当父类引用指向了自己的子类对象，可以强制将该引用转换成子类类型。

　　关键字 instanceof ：对象名 instanceof 类名用于判断该对象是否属于该类

　　多态中成员函数的特点：

　　在编译时期：参阅引用型变量所属类中是否有调用的方法。如果有，编译通过

　　在运行时期：参阅对象所属的类中是否有调用的方法。

　　**多态中成员变量、静态成员函数的特点：无论编译运行，都会指向引用型变量所属的类

class Fu
{
    public static void say()
    {
        System.out.println("父类");
    }

}

class Zi extends Fu 
{
    
    public static void say()
    {
        System.out.println("子类");
    }
}


class Demo
{
    public static void main(String[] args)
    {
        Fu f = new Zi();
        f.say();
    }
}

//结果是打印 父类

25. object 类是类层次结构的根类。该类中定义的方法是所有对象都具备的功能。

　　public boolean equals(object obj) 判断2个对象是否相等

public boolean equals(object obj)
{
        if(!(obj instanceof  Demo))
               return false;
       Demo d = (Demo) obj;                   
       return this.num == d.num;
}

　　pubic String toString()

相关推荐