目录
一、面向对象
1、概念
(1)什么叫面向对象?
面向对象主要是把事物给对象化,这个对象含有其属性和行为。面向对象编程更贴近实际生活的思想。总体来说面向对象的底层还是面向过程,把面向过程抽象成类,然后封装,方便使用就是面向对象。
简单举个例子:把大象装入冰箱。
这里需要三步:
第一步,打开冰箱。
第二部,把大象装入冰箱。
第三步,关上冰箱。
而面向对象是什么呢?就是我们把这三步,封装成三个方法,抽象为一个类,将其封装起来,通过这个类所映射的一个实例,也就是对象,来调用这三个方法,这就是面向对象的思想。
(2)类与对象
a、类是什么?
类是抽象的概念集合,表示的是一个共性的产物,类之中定义的是属性和行为(方法);
b、对象是什么?
对象是一种个性的表示,表示一个独立的个体,每个对象拥有自己独立的属性,依靠属性来区分不同对象。
它们之间简单来说就是一句话:类是对象的模板,对象是类的实例。
二、封装
1、概念
即隐藏对象的属性和实现细节,仅对外公开接口,控制在程序中属性的读和修改的访问级别;将抽象得到的数据和行为(或功能)相结合,形成一个有机的整体,也就是将数据与操作数据的源代码进行有机的结合,形成“类”,其中数据和函数都是类的成员。”
如果上面那段化话不好理解,这里可以比喻成一句话:
我的东西你可以用,但得通过我说的方法来拿。
2、代码讲解
如果上面那段话还不好懂,下面开始看代码:
1、首先我们创建一个类,这里拿学生类进行举例。
class Student{
String name;
int age;
}
注意,这里我们没有给Student类得属性加上任何限制,然后我们在测试类里面进行调用。
public class Test {
public static void main(String[] args) {
Student student = new Student();
String s = student.name;
}
}
调用没有任何问题,接下来我们进行对成员属性的封装。
public class Test {
public static void main(String[] args) {
Student student = new Student();
String s = student.name; // 这里实际上是报错了,因为是私有属性,所以不可以直接访问
}
}
class Student{
private String name;
private int age;
}
那么如何解决这个问题呢?很简单,就像上面的那句话,给一个对外的接口,让其能访问到这个属性
public class Test {
public static void main(String[] args) {
Student student = new Student();
String s = student.getName();
}
}
class Student{
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
就这样,我们同get方法就可以访问其私有属性。
3、封装的好处
1、提高了数据的安全性
别人不能够通过 变量名.属性名 的方式来修改某个私有的成员属性。
2、操作变得更加简单
封装后,多个调用者在使用的时候,只需调用方法即可。
3、实现了隐藏
实现过程对调用者是不可见的,调用者只需调用方法即可,不知道具体实现过程
4、封装的弊端
如果没有好的注释和API,封装反有时候会取得一个适得其反的作用。所以大家当程序员一定要会好好写注释。
5、权限修饰符
三、继承
1、概念
首先,我们理解下什么是继承,就像字面意思一样,继承别人的东西,被继承的是父对象,继承的是子对象;也可以用如下的一个图进行理解:
在Java中,被继承的类我们称之为父类,也叫基类;继承的类叫子类,也称为派生类或超类;继承是面向对象最显著的一个特性。继承是从已有的类中派生出新的类,新的类能吸收已有类的数据属性和行为,并能扩展新的能力。
在Java之中,如果要实现继承的关系,可以使用如下的语法:
class 子类 extends 父类{}
2、代码讲解
a、成员变量继承
public class Test {
public static void main(String[] args) {
Animal animal = new Animal();
Cat cat = new Cat();
System.out.println(cat.age); // 结果为10
}
}
class Animal{
int age = 10;
}
class Cat extends Animal{
}
b、成员方法的继承
public class Test {
public static void main(String[] args) {
Animal animal = new Animal();
Cat cat = new Cat();
cat.say(); // 运行结果:动物会叫
}
}
class Animal{
public void say(){
System.out.println("动物会叫");
}
}
class Cat extends Animal{
}
这只是简单讲解了如何继承父类成员属性,实际上的继承还涉及了很多细节的地方,比如方法的重写,还有成员属性的访问提点,super关键字等;下面开始一一讲解。
3、方法的重写
什么叫做重写?重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变,核心重写!
其他不多说,上代码!!!
public class Test {
public static void main(String[] args) {
Animal animal = new Animal();
Cat cat = new Cat();
cat.say(); // 运行结果:喵喵喵
}
}
class Animal{
public void say(){
System.out.println("动物会叫");
}
}
class Cat extends Animal{
@Override
public void say() {
System.out.println("喵喵喵");
}
}
注:不是所有场景都适合重写父类方法,也不是所有父类方法都可以重写。
这里要注意几点:
A:父类中的私有方法不能被重写
B:子类重写父类方法时,访问权限不能更低
C:父类静态方法,子类也必须通过静态方法进行重写
4、成员属性访问特点
5、super关键字
super关键字的用法如下:
(1)super可以用来引用直接父类的实例变量。
(2)super可以用来调用直接父类方法。
(3)super()可以用于调用直接父类构造函数。
看不懂文字?老样子,上代码!!!
public class Test {
public static void main(String[] args) {
Animal animal = new Animal();
Cat cat = new Cat();
animal.getAge(); // 打印结果为10
cat.getAge(); // 打印结果为10
cat.getAge1();
}
}
class Animal{
int age = 10;
public Animal(){}
public void getAge(){
System.out.println(age);
}
}
class Cat extends Animal{
int age = 12;
public void getAge(){
System.out.println(super.age); // 引用了父类的实例变量
}
public void getAge1(){
super.getAge(); // 调用了直接父类方法
}
public Cat() { // 调用父类构造方法
super();
}
}
四、多态
1、概念
在Java中,多态性的意思是作为面向对象的程序设计语言最核心的特征,表示一个对象有着多重特征,可以在特定的情况下表现出不同的状态,从而对应着不同的属性和方法; 但体现多态的前提是,要有继承关系,有方法的重写,还有父类对象引用指向子类对象。
代码上的实现就是这样一个意思:
public class Test {
public static void main(String[] args) {
Animal animal = new Cat();
animal.say(); // 喵喵喵
}
}
class Animal{
public void say(){
System.out.println("动物会叫");
}
}
class Cat extends Animal{
@Override
public void say() {
System.out.println("喵喵喵");
}
}
意思就是我们创建了一个animal对象,实际上它只知道动物会叫,当animal这个对象作为cat这种生物的时候,它的叫声就是喵喵喵,这就是多态性,它体现的是在不同情况下的状态。
2、访问特点
记住这一句话:编译看左,执行看右
public class Test {
public static void main(String[] args) {
Animal animal = new Cat();
animal.getAge(); // 运行结果:20
}
}
class Animal{
int age = 10;
public void getAge(){
System.out.println(age);
}
}
class Cat extends Animal{
int age = 20;
@Override
public void getAge() {
System.out.println(age);
}
}
3、多态的利弊
好处:提高程序扩展性
坏处:不能访问子类特有的成员
4、多态的转型
文本描述起来可能不好理解,还是老样子,上代码!!!
向上转型(父类引用指向子类对象)
public class Test {
public static void main(String[] args) {
Animal animal = new Cat(); // 向上转型
}
}
class Animal{}
class Cat extends Animal{}
向下转型(父类引用转为子类对象)
public class Test {
public static void main(String[] args) {
Animal animal = new Cat();
Cat cat = (Cat)animal; // 向下转型
}
}
class Animal{}
class Cat extends Animal{}