面向对象基础梳理

 

方法

1、封装一段特定的业务逻辑功能

2、尽可能的独立，一个方法只干一件事

3、可以反复调用多次

4、可以减少代码重复，有利于代码的维护和团队的协作

方法完成后：

1）若需要用到方法中的某个数据---------------------有返回值

2）若不需要用到方法中的某个数据-------------------无返回值（void）

System.out.println("Hello"); //换行输出 Arrays.sort(arr); // //数组排序 默认升序 System.arraycopy(a,1,a1,0,4); //数组复制 ----------------无返回值 double b = scan.nextDouble(); //接受用户输入的小数 double c = Math.random(); //计算随机数 int [] a1 = Arrays.copyOf(a,6); //数组复制 int a = scan.nextInt(); //接受用户输入的整数 ----------------有返回值

方法的定义：五个要素：修饰词、返回值类型、方法名、参数列表、方法体

 

方法的调用：

public static void main(String [] args){ //主方法

say();//调第一个方法

say("TZZ",28);//调第二个方法

int b=num(5,6)；

System.out.println(b); //调第四个方法

int m=5,n=6;

int c=num(5,6)；

System.out.println(c); //调第四个方法

}

public static void say(){ //无返回值无参

System.out.println("大家好，我是TZZ，我今年28岁了")

}

public static void sayHi(String name,int age){ // 无返回值有参

System.out.println("大家好，我是"+name+"，我今年"+age+"岁了")

}

public static double num(){ //有返回值无参

return(88.88);

}

public static int sum(int num1,int num2){ //有返回值有参

return(num1+num2);//也可以

int sum=num1+num2;

return(sum);//也可以

}

return：方法有返回值要跟return 值；return的作用是结束方法的执行；返回结果给调用方

 

0、方法的签名：方法名+参数列表

1、方法的重载 （Overload）

1）发生在一个类中，方法名称相同，参数列表不同，方法体不同

2）编译器在编译时根据方法的签名自动绑定调用的方法

2、构造方法

1）给成员变量赋初值，减少代码重复，在创建对象的时候

2）与类同名，没有返回值类型，无void

3）在创建（new）对象时被自动调用

4）若自己不写构造，则默认一个无参构造方法

若自己写了构造了，则不再默认提供了

5）构造方法可以重载

3、this

指代当前对象，哪个对象调用方法指的就是哪个对象

只能用在方法中，在方法中访问成员变量之前，默认都有个this.

当成员变量和局部变量同名时，this.不能省略

this的用法：

1）this.成员变量名---------访问成员变量

2）this.方法名（）----------调用方法（一般不用）

3）this（）------------------调用构造方法

 

继承

1）作用：代码复用

2）通过extends来实现继承

3）超类/父类：所有派生类所共有的属性和行为

派生类/子类：派生类特有的属性和行为

4）派生类继承超类后，派生类具有：派生类的+超类的

5）一个超类可以有多个派生类

一个派生类只能有一个超类--------单一继承

6）继承具有传递性

7）java规定：构造派生类之前必须先构造超类

在派生类的构造方法中，若没有调用超类的构造方法------则默认super()来调用超类的无参构造方法

在派生类的构造方法中，若调用了超类的构造方法---------则不再提供

class Student{ String name; int age; String address; int stuID; void eat(){} void sleep(){} void study(){} }	class Teacher{ String name; int age; String address; double salary; void eat(){} void sleep(){} void teach(){} }	class Teacher extends Person{ double salary; void teach(){} }   class Student extends Person{ int stuID; void study(){} }	class Person{ String name; int age; String address; void eat(){} void sleep(){} }
学生 类	教师 类	继承	人 类
派生类	派生类	继承	超类

super

指代当前对象的超类对象

super的用法：

1）super.成员变量名--------------------------访问超类的成员变量

2）super.方法名()-----------------------------访问超类的方法

3）super()--------------------------------------调用超类的构造方法

向上造型

1）超类型的引用指向派生类的对象

2）能点出来什么，看引用的类型

方法的重写（Override）：重新写，覆盖

1）发生在父子类中，方法名称相同，参数列表不同，方法体不同

2）重写方法被调用时，看对象的类型

重写和重载的区别---面试题

1）重写：发生在父子类中，方法名称相同，参数列表相同，方法体不同

运行期绑定 看对象的类型来调用

2）重载：发生在一个类中，方法名称相同，参数列表不同，方法体不同

编译期绑定 看引用的类型来绑定

package

1）作用：避免类名的冲突

2）包名可以有层次结构，同包中的类不能同名

3）类的全称：包名.类名

4）建议：包名所有字母都小写

import

同包中的类可以直接访问，不同包中的问题不能直接访问，想访问有两种方式：

1）先import声明类再直接使用类----建议

2）类的全称--------------------------太繁琐，不建议

访问控制修饰符

 

数据要加访问权限private-派生类/protected-超类，方法做成公开public

注意：

1）类的访问修饰符只能是public或默认的

2）类中成员的访问修饰符如上四种都可以

static：静态的

1）静态变量：

1、由static修饰的

2、属于类的，存储在方法区中，只有1份

3、常常通过类名点来访问

4、何时用：所有对象所共享的数据（图片、音频、视频等）

2）静态方法：

1、由static修饰的

2、属于类的，存储在方法区中，只有1份

3、常常通过类名点来访问

4、静态方法没有隐式this传递，所以在静态方法中不能直接访问实例成员

5、何时用：方法的操作仅与参数相关而与对象无关

3）静态块：

1、属于类的，在类被加载期间自动执行，类只被加载一次，所以静态块只执行一次

2、何时用：常常用于加载/初始化静态资源（图片、音频、视频等）

实例变量和静态变量

实例变量：没有static修饰的，属于对象的，存储在堆中

有几个对象就有几份

静态变量：由static修饰，属于类的，存储在方法区中

只有1份

内存管理

由JVM来管理的

1）堆：存储new出来的对象（包括实例变量）

垃圾：没有任何引用指向的对象

垃圾回收器（GC）不定时到内存中清扫垃圾，回收过程是透明的（看不到的），不一定发现垃圾就立刻回收

调用System.gc()可以建议JVM尽快调度GC来回收

内存泄漏：不再使用的对象还没有被及时的回收

建议：对象不再使用时应及时将引用设置为null

实例变量的生命周期：从对象在堆中创建开始到对象从堆中被回收结束

2）栈：存储正在调用中的方法中的局部变量（包括方法参数）

调用方法时会为该方法在栈中分配一块对应的栈帧，栈帧中存储局部变量（包括方法参数）

当方法调用结束时，栈帧被清除，局部变量一并失效

局部变量的生命周期：调用方法时存储在栈中，方法结束时与栈帧一并被清除

3）方法区：存储.class字节码文件（包括方法、静态变量）

方法只有一份，通过this来区分具体的调用对象

成员变量和局部变量的区别：

static final常量

1）必须声明的同时初始化

    比如 puiblic static final double PI = 3.141592653

2）类名点来访问、不能被改变

3）建议：常量名所有字母都大写，多个单词之前用_分隔

4）编译器在编译时将常量直接替换为具体的值，效率高

5）何时用：该数据永远不变，并且经常使用

抽象方法

1）由abstract修饰

2）只有方法的定义，没有具体的实现，连{}都没有

      比如public abstract step();

抽象类

1）由abstract修饰

2）包含抽象方法的类必须是抽象类

3）抽象类不能被实例化

4）抽象类是需要被继承的，派生类需重写抽象类中的所有抽象方法，否则也需声明为抽象类，但是这样做没有意义

5）抽象类的意义：

封装共有的属性和行为

为所有派生类提供统一的类型

可以包含抽象方法，为所有派生类提供统一的入口

设计规则

1）将所有派生类共有的属性和行为，抽到超类中----------抽共性

2）派生类的行为都一样，设计为普通方法

派生类的行为都不一样，设计为抽象方法

3）将部分派生类所共有的行为，抽到接口中

符合既是也是原则时，需使用接口

接口是对继承单根性的扩展---------实现多继承

成员内部类

1）类中套类，外面的称为Outer外部类，里面的称为Inner内部类

2）内部类通常只服务于外部类，对外不具备可见性

3）内部类对象通常是在外部类中创建的

4）内部类中可以直接访问外部类的成员（包括私有的）

内部类中有个隐式的引用指向了创建它的外部类对象 eg：外部类名.this

class Aoo{

class Boo{

}

}

匿名内部类

1）若想创建一个类（派生类）的对象，并且对象只创建一个，此时该类不必命名，称为匿名内部类

2）在jdk1.8之前，匿名内部类中若想访问外面的变量，该变量必须是final的

//匿名内部类
public class NstInnerClassDemo {
public static void main(String[] args) {
//1)创建了Coo的一个派生类，这个派生类没有名字
//2)为该派生类创建了一个对象，名为o1
//3)大括号中为派生类的类体，如果超类里有抽象方法，大括号里要有重写的操作
Coo o1=new Coo() {

};

Doo o3=new Doo(){
void show() {
System.out.println("showshow");
}
};
o3.show();
}
}

abstract class Doo{
abstract void show();
}

abstract class Coo{

}

常见面试题：问：内部类有独立的.class吗？答：有

接口

1）是一种数据类型（引用类型）

2）由interface定义

eg

interface inter{

}

3）只能包含常量和抽象方法

eg

interface inter{

int NUM=5； //默认含有public static final

void show(); //默认含有public abstract

}

4)接口不能被实例化 （不能new对象）

5）接口是需要被实现的，实现类/派生类

必须重新所有抽象方法

6）一个类可以实现多个接口，用逗号分隔

若又继承又实现时，应先继承后实现 eg : class Aoo extends inter1 implements inter2{}

7）接口可以继承多个接口 eg：interface inter extends inter1,inter2{}

多态

1）多态的意义：

1.同一类型的引用指向不同对象时，有不同的实现

-------行为的多态：cut()、run()、step().......

2.同一个对象被造型为不同的类型时，有不同的功能

--------对象的多态：我、你、水

2）向上造型/自动类型转换：

1.超类型的引用指向派生类的对象

2.能造型成为的类型有：超类+所实现的接口

3.能点出来什么，看引用的类型

3）强制类型转换，成功的条件只有如下两种：

1.引用所指向的对象，就是该类型

2.引用所指向的对象，实现了该接口或继承了该类

4）强转时若不符合如上两个条件，则发生ClassCastException类型转换异常

建议在强转之前先通过instanceof来判断引用的对象是否是该类型

面向对象三大特征---常见面试题

1、封装

1）类：封装的是对象的属性和行为

2）方法：封装一段特定的业务逻辑功能实现

3）访问控制修饰符：封装的是具体的访问权限

2、继承

1）作用：代码复用

2）超类：所有派生类所共有的属性和行为

接口：部分派生类所特有的属性和行为

派生类：派生类所特有的属性和行为

3）单一继承、多接口实现、传递性

3、多态

1）意义：

行为的多态（所有抽象方法都是多态的）

对象的多态（所有对象都是多态的）

2）向上造型、强制类型转换、instanceof判断

3）多态的表现形式

重写：根据对象的不同来表现多态

重载：根据参数的不同来表现多态