（1）类与对象
面向对象的概念：在程序中使用对象来映射现实中的事物，使用对象的关系来描述事物之间的联系，
这种思想就是面向对象。
面向对象的特征：1.封装性，将对象的属性和行为封装起来，是面向对象的核心思想。
2.继承性，主要描述类与类之间的关系，通过继承，可以在无须重新编写原有类的
情况下，对原有类的功能进行扩展。
3.多态性，在程序中允许出现重名现象。
类的定义：是对某一类事物的抽象描述。
对象：用于表现现实中该类事物的个体，是类的实例。
在java中，定义在类中的变量被称为成员变量，定义在方法中的变量被称为局部变量。
成员变量和局部变量的区别:
A：在类中的位置：成员变量--类中方法外。 局部变量--在方法定义中或方法声明上。
B：在内存中的位置：成员变量--堆内存。 局部变量--在栈内存。
C：生命周期不同：成员变量：随着对象的创建而存在，随着对象的消失而消失。
局部变量：随着方法的调用而存在，随着方法调用完毕而消失。
D：初始化值不同：成员变量：有默认初始化值。
局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。
注意事项：局部变量名称可以和成员变量名称一样，在方法中使用的时候采用的是就近原则。
不同的方法中，不能访问另一个类中的变量，只能调用方法。
对象的创建：格式 类名 对象名称=new 类名（）；
使用：使用成员变量 对象名.变量名
使用成员方法 对象名.方法名（）；
注：null是一种特殊的常量，当一个变量的值为null时，则表示该变量不指向任何一个对象。
匿名对象：就是没有名字的对象---- new.类名();
匿名对象的应用场景：A：用于调用方法，仅仅只调用一次的时候，调用多次时不适合。
匿名对象调用完毕就是垃圾，回收。
B：匿名对象可以作为实际参数传递。
类的封装是指在定义一个类时，将类中的属性私有化，即使用private关键字来修饰，私有属性只能
在它所在类中被访问，为了能让外界访问私有属性，需要提供一些使用public修饰的公有
方法，其中包括用于获取属性值的getXxx()方法和设置属性值的setXxx()方法。
（2）构造方法
构造方法满足的三个条件：1.方法名和类名相同。
2.在方法名的前面没有返回值类型的声明。
3.在方法中不能使用return语句返回一个值。
在一个类中除了可以定义一个无参的构造方法，还可以定义有参的构造方法，实现对属性的赋值。
注意事项：1.如果在一个类中没有定义构造方法，系统会自动为这个类创建一个默认的构造方法，
这个默认的构造方法没有参数，在其方法体中没有任何代码，即什么也不做。
2.一旦一个类中定义了构造方法，系统就不再提供默认的构造方法了。为了避免程序中
出现错误，在一个类中如果定义了有参的构造方法，最好再定义一个无参的构造方法。
（3）this关键字
this：1.用于在方法中访问对象的其他成员，通过this关键字可以明确的去访一个类的成员变量，解决
与局部变量名称冲突问题。
2.还可以通过this关键字调用成员方法。
3.可以在一个构造方法中使用“this（[参数1，参数2...]）”的形式来调用其它的构造方法。
在使用this调用构造方法时，需要注意的内容：
A：只能在构造方法中使用this调用其它的构造方法，不能在成员方法中使用。
B：在构造方法中，使用this调用构造方法的语句必须位于第一位，且只能出现一次。
C：不能在一个类的两个构造方法中使用this互相调用。
（4）垃圾回收
除了通过java虚拟机进行自动垃圾回收，也可以通过调用System.gc()方法来通知java虚拟机立即进行
垃圾回收，当一个对象在内存中被释放时它的finalize（）方法会被自动调用。
（5）static关键字
static的特点：A：随着类的加载而加载。
B：优先于对象存在。
C：被类的所有对象共享。
D：可以通过类名调用。
静态变量：使用static关键字来修饰成员变量，该变量被称作静态变量，静态变量被所有实例共享，
可以使用“类名.变量名”的形式来访问。
注意：static关键字只能用于修饰成员变量，不能用于修饰局部变量，否则编译会出错。
静态变量与成员变量的区别：
A：所属不同，静态变量属于类，所以也称为类变量，成员变量属于对象，称为实例对象。
B：内存中位置不同，静态变量存储于方法区的静态区。成员变量存储于堆内存。
C：内存中出现时间不同，静态变量随类的加载而加载，随类的消失而消失。
成员变量随对象的创建而存在，随着对象的消失而消失。
D：调用不同，静态变量可通过类名调用，也可通过对象调用，成员变量只能通过对象调用。
静态方法：使用static关键字修饰的方法为静态方法，静态方法可以使用“类名.方法名”访问。
静态方法不需要创建对象就可以调用。
注意：在静态方法中是没有this关键字的，静态是随着类的加载而加载，this是随着对象的创建
存在，静态比对象先存在。
静态代码块：在java类中，使用一对大括号包围起来的若干行代码被称为一个代码块，用static
关键字修饰的代码块称为静态代码块。
注意：当类被加载时，静态代码块会执行，由于类只加载一次，因此静态代码块只执行一次。
作用：一般用于对类的初始化。
局部代码块：在方法中出现，限定变量生命周期，调用完就释放。
构造代码块：在类的成员位置，每次调用构造方法执行前，都会先执行构造代码块。
作用：可以把多个构造方法中的共同代码放在一起，对对象进行初始化。
注意：静态代码块仅执行一次，构造代码块每次调用构造方法都执行。
单例模式
（6）内部类
内部类概述：在一个类的内部定义类，这样的类称为内部类。
成员内部类：A：内部类可以在外部类中被使用，内部类可以访问外部类的所有成员。
B：想通过外部类去访问内部类，则需要通过外部类对象去创建内部类对象。
格式：外部类名.内部类名 变量名=new 外部类名（).new 内部类名（）；
注意：内部类被声明为私有时，外界将无法访问。
静态内部类：创建静态内部类对象格式：外部类名.内部类名 变量名=new 外部类名（).内部类名（）；
注意：A：在静态内部类中只能访问外部类的静态成员，非静态成员需要创建对象调用。
B：在静态内部类中可以定义静态的成员，而在非静态的内部类中不允许定义静态成员。
方法内部类：是指在成员方法中定义的类，它只能在当前方法中被使用。
方法内部类也可以访问外部类的成员变量。
（7）类的继承
继承的概述：多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无须再
定义这些属性和行为，只要继承那个类即可。通过extends关键字可以实现类与类的继承。
继承的好处：A：提高了代码的复用性，多个类相同的成员可以放到同一个类中。
B：提高了代码的维护性，如果功能的代码需要修改，修改一处即可。
C：让类与类之间产生关系，是多态的前提。也是弊端，类的耦合性变强。
继承的特点：A：只支持单继承，不允许多重继承，也就是说一个类只能有一个直接父类。
B：多个类可以继承一个父类。
C：多层继承是可以的，即一个类的父类可以再去继承另外的父类。
继承的注意事项：A：子类只能继承父类所有非私有的成员。
B：子类不能继承父类的构造方法，但是可以通过super关键字去访问。
C：不要为了部分功能而去继承。
继承中成员变量的关系：子类中的成员变量和父类中的成员变量名称一样时，则在子类方法中访问一个
变量的查找顺序（就近原则）。
重写父类方法：在继承关系中，子类会自动继承父类中定义的方法，但有时在子类中需要对继承的方法
进行一些修改，即对父类方法进行修改。
注意：在子类中重写的方法需要和父类被重写的方法具有相同的方法名，参数列表以及返回值类型。
子类重写父类方法时，不能使用比父类中被重写的方法更严格的访问权限。
方法重写和方法重载的区别：方法重载能改变返回值类型，因为它和返回值无关，而方法重写不能。
super关键字：当子类重写父类的方法后，子类对象将无法访问父类被重写的方法，java中提供了super
关键字用于访问父类的成员。
A：使用super关键字调用父类的成员变量和成员方法。
格式：super.成员变量；
super.成员方法（[参数1，参数2...]）；
B：使用super关键字调用父类的构造方法。
格式：super([参数1，参数2...])；
注意：通过super调用父类构造方法的代码必须位于子类构造方法的第一行，并且只能出现一次。
继承中构造方法的关系：子类中所有的构造方法默认都会访问父类中空参数的构造方法，子类每一个构造
方法的第一条语句默认都是：super（）。
原因：因为子类会继承父类中的数据，可能还会使用父类的数据，所以，子类初始化前，
一定要先完成父类数据的初始化。
如果父类中没有给出无参构造方法，而给出了带参构造方法，此时系统不会再默认给出构造方法，那么
子类的构造方法无法进行，因为父类在子类初始化前要先完成数据的初始化。
注意：子类构造方法执行前默认先执行父类的无参构造方法。
解决方法：A：在父类中加一个无参构造方法。
B：通过使用super关键字去显示的调用父类的带参构造方法。
C：子类通过this去调用本类的其他构造方法，但子类中一定要有一个去访问了父类的构
造方法，否则父类数据就没有初始化。
注意事项：this（）或者super（）必须出现在第一条语句上，如果不是放在第一条语句上，就可能
对父类的数据进行了多次初始化，所以必须放在第一条语句上。
（8）final关键字
被final修饰的类，变量和方法具有以下特征：A：final修饰的类不能被继承。
B：final修饰的方法不能被子类重写。
C：final修饰的变量是常量，只能赋值一次，不能改变。
注意：使用final关键字修饰成员变量时，虚拟机不会对其进行初始化，因此使用final修饰成员变
量时，需要在定义变量的同时赋予一个初始值，否则会编译出错。
final修饰局部变量的问题：修饰基本类型时：基本类型的值不能改变。
修饰引用类型时：引用类型的地址值不能发生改变，但是对象的堆内存的
值是可以改变的。
final修饰变量的初始化时机：A：被final修饰的变量只能赋值一次。
注意：final int num；不是赋值，不影响后面第一次赋值。
B：在构造方法完毕前赋值（针对非静态的常量）。
（9） 多态：同一个对象（事物），在不同时刻体现出来的不同状态。
多态的前提：A：要有继承关系。
B：要有方法重写。
C：要有父类引用指向子类对象。例：Animal a=new Cat()；
多态中成员访问特定：A：成员变量：编译看左边，运行看左边。
B：构造方法：创建子类对象的时候，访问父类的构造方法，
对父类的数据进行初始化。
C：成员方法：编译看左边，运行看右边，由于成员方法存在方法重写。
D：静态方法：编译看左边，运行看左边，由于静态和类相关算不上重写。
多态的好处：A：提高了代码的维护性（继承保证）。
B：提高代码的扩展性（由多态保证）。
多态的弊端：不能使用子类的特有功能。
解决方法：A：创建子类对象调用方法即可（可以，但很多时候不合理，太占内存了）。
B：把父类的引用强制转换为子类的引用（向下转型）。
对象间的转型问题：向上转型：Fu f=new zi()；--子类引用指向子类对象。
向下转型：zi z=(zi)f；--要求该f能够转换为zi,父类引用转为子类对象。
（10）抽象类和接口
抽象类的概述：把一个不是具体的功能称为抽象的功能，而一个类中如果有抽象的功能，该类必须是抽象类。
抽象类的特点：A：抽象类和抽象方法必须用abstract关键字修饰。
B：抽象类中不一定有抽象方法，但是有抽象方法的类必须定义为抽象类。
C：抽象类不能实例化，因为它不是具体的，抽象类有构造方法但是不能实例化，
构造方法的作用是，用于子类访问父类数据的初始化。
D：抽象的子类如果不想重写抽象方法，该子类是一个抽象类，如果重写所有的抽象方法
这个时候子类是一个具体类。
抽象类的实例化其实是靠具体的子类实现的，是多态的方式。
抽象类的成员特点：成员变量：既可以是变量，也可以是常量。
构造方法：用于子类访问父类数据的初始化。
成员方法：既可以是抽象的，也可以是非抽象的。
注：一个类如果没有抽象方法，可以定义为抽象类。作用是为了不让创建对象。
abstract不能和哪些关键字共存：A：与private冲突，因为私有的不能被继承，而抽象是为了抽象。
B：与final冲突，最终的不能被重写。
C：static无意义，静态方法可以通过类名调用，但抽象方法没有方法体。
接口的特点：A：接口用关键字interface表示，格式：interface 借口名{ }；
B：类实现接口用implements表示，格式：class类名 implements 接口名{ }；
C：接口不能实例化，要按照多态的方式来实例化。
D：接口的子类可以是抽象类（意义不大）也可以是具体类（可以实例化）。
接口成员特点：成员变量：只能是常量，并且是静态的。有默认修饰符public static final。
构造方法：接口没有构造方法，因为接口主要是扩展功能的，而没有具体存在。
成员方法：只能是抽象方法，接口方法不能带有主体。默认修饰符public abstract。
类与类的关系：继承关系，只能单继承，可以多层继承。
类与接口的关系：实现关系，可以单实现也可以多实现，还可以在继承一个类的同时实现多个接口。
接口与接口的关系：继承关系，可以单继承也可以多继承。
抽象类和接口的区别：抽象类：成员变量：可以是变量，也可以是常量。
构造方法：有。
成员方法：可以抽象，也可以非抽象。
接口：成员变量：只可以常量。
构造方法：有。
成员方法：只可以抽象。
形式参数为引用类型：类：需要的是该类的对象。
抽象类：当一个具体类中形式参数为抽象类，需要的是该抽象类的子类对象。
接口类：当一个具体类中形式参数为接口类，需要的是该接口的实现类对象。
返回值类型为引用类型：类：返回的是该类的对象。
抽象类：返回的是该抽象类的子类对象。
接口类：返回的是该接口的实现类对象。
（11）访问控制
访问控制级别由小到大：private（类访问级别）-default（包访问基本）-protected（子类访问级别）-piblic
扫一扫
25万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
