类和对象

首先3个问题：

1. 创建一个类

创建一个学生类，成员变量是姓名和年龄，然后定义构造方法，以及setXxx方法和getXxx方法，分别来赋值和获取。

public class Student {// 定义成员变量private String name;private int age;// 空参构造函数public Student(){}// 有参构造函数public Student(String name,int age){this.name = name;this.age = age;}/*// 针对每一个私有化变量，都要提供get和set方法// set方法：给成员变量赋值// get方法：对外提供成员变量的值*/// 给成员变量name进行赋值public void setName(String name){this.name = name;}// 对外提供name属性的值public String getName(){return this.name;}// 给成员变量age进行赋值public void setAge(int age) {this.age = age;}// 对外提供age属性的值public int getAge() {return age;}
}

举的例子其实就是个标准的javabean类（javabean类：用来描述一类事物的类，不需要写main方法，IDEA中快捷键是Alt+Insert）

2. 创建一个对象

public class StudentTest{public static void main(String[] args){// 创建一个Student类对象Student std1 = new Student();//创建一个带参数的Student类对象Student std2 = new Student("zangsan",23);}
}

3. 访问变量和方法

public class StudentTest{public static void main(String[] args){// 创建一个Student类对象Student std = new Student();std.setName("lisi");std.setAge(24);String name = std.getName();int age = std.getAge();System.out.println(”姓名：“+name+” “+”年龄：“+age)}
}

4. some tips

（1）构造方法
以三个问题回顾一下构造方法：

Q	A
构造方法的作用?	创造对象的时候，由虚拟机自动调用，给成员变量进行初始化的
构造方法有几种?	无参构造方法：初始化的对象时，成员变量的数据均采用默认值。 有参构造方法：在初始化对象的时候，同时可以为对象进行赋值。
构造方法的注意事项?	（1）任何类定义出来，默认就自带了无参数构造器 （2）定义了有参构造器，无参数构造器就没有了 （3）建议在任何时候都手动写上空参和带全部参数的构造方法

（2）this关键字
可以区分成员变量和局部变量，与python中的self相似；

代表方法调用者的地址。

this的内存原理如下：

（3）private关键字

• private关键字是一个权限修饰符，可以修饰成员（成员变量和成员方法）；
• 被private修饰的成员只能在本类中才能访问；
• 针对private修饰的成员变量，如果需要被其他类使用，提供相应操作，如：提供setXxx(参数)方法**，用于给成员变量赋值，方法用public修饰；提供getXxx()方法，用于获取成员变量的值，方法用public修饰。

封装

面向对象三大特性：封装，继承，多态。

原则：对象代表什么，就得封装对应的数据，并提供数据对应的行为

如何实现封装？

• 修改属性的可见性，在属性的前面添加修饰符 (private)
• 对每个值属性提供对外的公共方法访问，如创建 getter/setter（取值和赋值）方法，用于对私有属性的访问
• 在 getter/setter 方法里加入属性的控制语句，例如我们可以加一个判断语句，对于非法输入给予否定

修饰符

1. 访问控制修饰符

在实际中，一般只用private 和 public，按照 成员变量私有，方法公开的原则

2. 非访问修饰符

（1）static

分为静态变量和静态方法

• 静态变量：
  static 关键字用来声明独立于对象的静态变量。无论一个类实例化多少对象，它的静态变量只有一份拷贝，也就是说被该类所有对象共享， 静态变量也被称为类变量。可以直接通过类名调用。

• 静态方法：
  static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。

具体可以看下图：

（工具类：帮助我们做一些事情，但是不具体描述任何事物的类
特点：类名知名见意；私有化构造方法）

最后说一下static的注意事项

而main函数的修饰符static，其实也是一样的道理

（2）final

• final 修饰方法：表明该方法是最终方法，不能被重写；
• final 修饰类：表明该类是最终类，不能被继承；
• final 修饰变量：即常量，只能被赋值一次。

注意：

• final修饰的变量是基本类型：那么变量存储的数据值不能发生改变。
• final修饰的变量是引用类型：那么变量存储的地址值不能发生改变，对象内部的可以改变。

继承

关键词：extend

class 父类 {}class 子类 extends 父类 {}

1. 继承的类型

（1）多重继承（直接父类，间接父类）

代码：

class B extends A{}class C extends B{}

（2）不同类继承同一个类（一个父亲可以有多个儿子）

代码：

class B extends A{}class C extends A{}

（3）多继承不支持，即一个类继承两个类不支持（一个儿子不能有两个爸爸）

总结一下：

• Java只能单继承：一个类只能继承自一个直接父类（每个类只有一个爸爸）。
• Java不支持多继承、但是支持多重继承（爷父子三代）。
• Java中所有的类都直接或者间接继承于Object类。（所有类都有爸爸）

2. 继承的特性

（1）子类拥有父类非 private 的属性、方法。

（2）子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。

（3）子类可以用自己的方式实现父类的方法。

子类能继承父类的哪些内容？

注意：

（1）private的私有变量虽然可以继承，但是子类不能使用

（2）虚方法表：父类会将“经常用的方法”放入虚方法表中，并且这些方法是非private，非static，非final的。然后子类继承后，会在父类基础上添加自己类的虚方法。

3. 继承中的访问特点：

this调用：就近原则 ；super调用：直接找父类

(1）成员变量：就近原则
先在局部位置找——本类成员位置找——父类成员位置找，逐级往上。

如果子类父类中出现不重名的成员变量，这时的访问是没有影响的

子父类中出现了同名的成员变量时，子类会优先访问自己对象中的成员变量

（2）成员方法：与成员变量类似，也是就近原则

（3）构造方法：

• 子类不能继承父类的构造方法，但是可以通过super调用
• 子类构造方法的第一行，有一个默认的super();
• 默认先访问父类中无参的构造方法，再执行自己。
• 如果想要访问父类有参构造，必须手动书写。

eg：

// 创建一个Person类
class Person()
{private String id;private String name;public Person(String id,String name){this.id = id;this.name = name;}
}
// 创建一个Student类，继承自Person类
class Student extends Person()
{private String gender;public Student(String id,String name,String gender){super(id,name);this.gender = gender;}
}

4. super&this

super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。

this关键字：指向自己的引用。

具体地：

super 关键字在子类内部使用，代表父类对象。

• 访问父类的属性 super.属性名。
• 访问父类的方法 super.bark()。
• 子类构造方法需要调用父类的构造方法时

5. 重写（Override）&重载（Overload）

重写（Override）：
是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！

重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。

特点：
（1）重写方法的名称、形参列表必须与父类中的一致。

（2）子类重写父类方法时，访问权限子类必须大于等于父类

（3）子类重写父类方法时，返回值类型子类必须小于等于父类

（4）建议:重写的方法尽量和父类保持一致。

（5）只有被添加到虚方法表中（前面说的三个非）的方法才能被重写

重载(overload)
在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。

每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。最常用的地方就是构造器的重载。

• 被重载的方法必须改变参数列表(参数个数或类型不一样)；
• 被重载的方法可以改变返回类型；
• 被重载的方法可以改变访问修饰符；

总结一句话：

重写是父类与子类之间多态性的一种表现，重载可以理解成一个类多态的具体表现形式。

多态

同一个事件发生在不同的对象上会产生不同的结果（或者说是同类型的对象，表现出的不同形态）

1. 三个前提条件

• 有继承/实现关系
• 有父类引用指向子类对象，Fu fu = new Zi()
• 有方法重写

通俗地讲，多态就是只通过父类就能够引用不同的子类

2. 多态中调用成员变量的特点

调用成员变量：编译看左边，运行也看左边

• 编译看左边: javac编译代码的时候，会看左边的父类中有没有这个变量，如果有，编译成功，如果没有编译失败。
• 运行也看左边: java运行代码的时候，实际获取的就是左边父类中成员变量的值

调用成员方法：编译看左边，运行看右边

• 编译看左边:javac编译代码的时候，会看左边的父类中有没有这个方法，如果有，编译成功，如果没有编译失败。
• 运行看右边: java运行代码的时候，实际上运行的是子类中的方法。

简单理解一下：

Animal a = new Dog();// 现在 a 去调用变量和方法，a 是 Animal 类型的，所以会默认从 Animal 类中找

成员变量:在子类的对象中，会把父类的成员变量也继承下来；
成员方法：如果子类对方法进行了重写，那么在虚方法表中会把父类的方法进行覆盖。

即成员方法有重写，但成员变量没有，所以两者的访问不一样。

3. 多态的优缺点

好处：

（1）右边对象可以解耦，便于拓展和维护

Animal a = new Dog();
a.eat(); // 业务逻辑发生改变时，后续代码无需改变

（2）使用父类型作为参数，可以接收所有子类对象，体现多态的拓展性和便利性

弊端

（1）不能调用子类的独有方法

如果需要调用该怎么办？

引用数据类型的类型转换——向下转型

Animal a = new Dog();
Dog d = (Dog) a;

这样转换成了真正的子类类型，从而可以调用子类的独有功能。（转换类型与真实对象类型不一致会报错）

所以更多时候，可以加一个判断语句：instanceof

public static void show(Animal a)
{a.eat();// 类型判断if (a instanceof Cat)  {  // 猫做的事情 Cat c = (Cat)a;c.catMouse();} else if (a instanceof Dog) { // 狗做的事情 Dog c = (Dog)a;c.lookHouse();}
}

抽象类和抽象方法

1. 含义

• 抽象方法：将共性的行为（方法）抽取到父类之后，由于每一个子类执行的内容是不一样，所以，在父类中不能确定具体的方法体。该方法就可以定义为抽象方法。

• 抽象类：一个类中没有包含足够的信息来描绘一个具体的对象。如果一个类中存在抽象方法，那么该类就必须声明为抽象类。

2. 定义格式——abstract

抽象方法只包含一个方法名，而没有方法体，方法名后面直接跟一个分号，而不是花括号；

抽象类同样也用 abstract 修饰

//抽象方法
public abstract 返回值类型 方法名（参数列表）;//抽象类
public abstract class 类名{}

3. 特性

• 抽象类不能实例化，所以抽象类必须被继承
• 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类，可以有构造方法
• 抽象类的子类：要么重写抽象类中的所有抽象方法 ；要么是抽象类

4. 举个栗子

// 父类,抽象类
abstract class Employee {private String id;private String name;public Employee() {}public Employee(String id, String name) {this.id = id;this.name = name;}// 抽象方法必须要放在抽象类中public abstract void work();
}// 定义一个子类继承抽象类
class Manager extends Employee {public Manager() {}public Manager(String id, String name) {super(id, name);}@Override 重写父类的抽象方法public void work() {System.out.println("管理其他人");}
}// 定义一个子类继承抽象类
class Cook extends Employee {public Cook() {}public Cook(String id, String name) {super(id, name);}@Overridepublic void work() {System.out.println("厨师炒菜多加点盐...");}
}

接口

1. 什么是接口

首先为什么要有接口？

从下图可以看出，动物类按照之前讲的，可以定义为抽象类，里面有“吃饭喝水”抽象方法，这时下面的子类都需要重写这两个方法。但是，”游泳“方法只有“青蛙和狗类”可以重写，所以将其定义为一个接口。

什么是接口？

• 接口用于描述类所具有的功能，而不提供功能的实现。
• 接口中的方法是抽象方法（没有方法体）
• 接口中的方法体需要写在实现接口的类中，并且该类必须实现接口中所有抽象方法。（除非实现接口的类是抽象类）
• 接口不能实例化，没有构造函数

2. 如何定义和使用一个接口

定义一个接口——interface：

// 关键字：interface
public interface A{ }

使用(实现)一个接口——implements:

// 关键字：implements
public class C implements A{}

注：接口的继承：可以单继承，也可以多继承

单继承：

public interface Sports
{public void setHomeTeam(String name);
}
// 文件名: Football.java
public interface Football extends Sports
{public void homeTeamScored(int points);public void visitingTeamScored(int points);
}

此时当类实现Football接口时，需要实现它及它的父接口的所有方法,所以共需要实现2+1=3个方法

多继承：

public interface inter1
{public void method1();
}public interface inter2
{public void method2();
}public interface inter3 extends inter1,inter2
{public void method3();
}

那么，在类实现接口inter3的时候，需要重写所有抽象方法（1+1+1=3个）

3. 接口里成员的特点

• 成员变量：只能是常量，会被隐式的指定为 public static final 变量
• 成员方法：隐式抽象的,接口中的方法会被隐式的指定为 public abstract
• 构造方法：没有

注意：
JDK 1.8 以前：接口只能定义抽象方法
JDK 1.8 以后：接口中可以定义有方法体的方法；
JDK 1.9 以后：接口中可以定义私有方法

eg.

// 定义接口A，提供eat方法接口，抽象方法
public interface A{public abstract void eat();
}
// 定义接口 B，提供 sleep 方法接口，抽象方法
public interface B{public abstract void sleep();
}
//定义类 C 实现 A，B 方法的接口
public class C implements A,B{public void eat(){System.out.println("吃饭");}public void sleep(){System.out.println("睡觉");}
}

4. 接口与类的关系

类和接口的关系？

• 接口并不是类，类描述对象的属性和方法。接口则包含类要实现的方法。
• 类只能单继承不可以多继承，但接口可以多继承
• 接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。

抽象类与接口的区别？

• 抽象类中的方法可以有方法体，但是接口中的方法不行。
• 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
• 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
• 一个类只能继承一个抽象类，而一个类却可以实现多个接口。

内部类

内部类就是定义在一个类里面的类，里面的类可以理解成（寄生），外部类可以理解成（宿主）

public class People
{
// 内部类
public class Heart {
}
}

场景：当一个事物的内部，还有一个部分需要一个完整的结构进行描述时，就可以采用内部类（汽车类，发动机类作为内部类）

特点：

• 内部类通常可以方便访问外部类的成员，包括私有的成员。
• 内部类提供了更好的封装性，内部类本身就可以用private ，protectecd等修饰，封装性可以做更多控制

内部类一共有4种，在后面的学习中，主要涉及匿名内部类！

1. 静态内部类

2. 成员内部类

3. 局部内部类

4. 匿名内部类

（1）从基本概念出发

什么是匿名内部类？

• 隐藏了名字的内部类，可以写在成员位置，也可以写在局部位置
• 包含了 继承或者实现接口，方法重写，创建对象
• 整体就是一个类的子类对象或者接口的实现类对象

匿名内部类的作用？
方便创建子类对象，最终目的是为了简化代码编写

匿名内部类的格式？

new 类名或接口名（）{
重写方法
}；

Employee a = new Employee()
{ // 重写方法  public void work() {   }
};
a.work();

当方法的参数是接口或者类时，可以传递这个接口或类的实现类对象

（2）从实际场景出发

上面讲了那么多，可能比较枯燥，直接上代码来解释下：

e.g.1
在之前我们要实现一个接口一般这么做：

// 先定义一个接口
interface inter{public void eat();
}// 写一个类去实现接口inter
class A implements inter{@Overridepublic void eat() {System.out.println("正在调用eat方法");}
}// main方法中创建类A的对象，并调用方法
public static void main(String[] args) {A a = new A();a.eat();  // 正在调用eat方法}
}

如果我们只是想单纯的使用一次eat方法，不需要创建对象的话，就可以用匿名类

// 首先还是创建一个接口
interface inter{public void eat();
}public class AnonymousDemo
{public static void main(String[] args) {// 直接使用匿名内部类，调用eat方法new inter(){@Overridepublic void eat() {System.out.println("正在调用eat方法");}}.eat();}
}

e.g.2 ：对象是方法的参数

// 先定义一个接口
interface swimming()
{void swim();
}public static void main(String[] args) {Swimming s = new Swimming(){public void swim(){System.out.println("学生快乐的游泳");}};go(s);/* 可以直接写成go(new Swimming(){public void swim(){System.out.println("学生快乐的游泳");}};)*/public void go(Swimming s){s.swim(); }
}

参考链接：
1.https://www.bilibili.com/video/BV17F411T7Ao?p=131&share_source=copy_web&vd_source=fa075f0e5dab81ef7c98b9eb4c47d9a7
2. https://www.runoob.com/java/java-tutorial.html
3. https://blog.csdn.net/xueyukun1/article/details/121412738

Java SE（六）之面向对象（封装，继承，多态，接口）相关推荐

1. (十)Core Java 面向对象(封装,继承,多态,接口) -02 (96)

    目录 :        24 ). 面向对象(聚集关系) 25 ). 面向对象(子父类中变量的特点) 26 ). 面向对象(子父类中函数的特点-覆盖) 27 ).  面向对象(子父类中构造函数的特点 ...

2. 大数据笔记8—java基础篇4（面向对象-封装-继承-多态）

   面向对象 一.面向对象 1.面向过程 1.2.举例 1.3.总结 二.面向对象 1.简述 2.举例 3.思想特点 2.1.类的定义格式 2.1.1.简述 2.2.2.格式 2.3.3.示例 三.类的使 ...

3. 面向对象封装继承多态五大基本原则魔法方法反射

   目录 面向对象 三大基本特征 五大基本原则 魔法方法 反射 面向对象 什么是面向对象 使用模板的思想,将世界万事万物使用对象来表示一个类型 面向对象和面向过程的区别: 面向对象的不就是使用程序处理事情 ...

4. 猜丁壳（面向对象 封装 继承 多态）

   创建三个包: util包中的Constans是用来存储常量的: util包中的MyUtil是用来存储工具类的: service包中的Player定义玩家的共同属性及方法: service包中的Comp ...

5. c语言编程 菲薄拉,C语言设计模式-封装-继承-多态

   快过年了,手头的工作慢慢也就少了,所以,研究技术的时间就多了很多时间,前些天在CSDN一博客看到有大牛在讨论C的设计模式,正好看到了,我也有兴趣转发,修改,研究一下. 记得读大学的时候,老师就告诉我们 ...

6. Day55-每日一道Java面试题-Java 面向对象编程三大特性: 封装 继承 多态

   Java 面向对象编程三大特性: 封装 继承 多态 封装 封装把一个对象的属性私有化,同时提供一些可以被外界访问的属性的方法,如果属性不想被外界访问,我们大可不必提供方法给外界访问.但是如果一个类没有 ...

7. Java继承_Hachi君浅聊Java三大特性之 封装 继承 多态

   Hello,大家好~我是你们的Hachi君,一个来自某学院的资深java小白.最近利用暑假的时间,修得满腔java语言学习心得.今天小宇宙终于要爆发了,决定在知乎上来一场根本停不下来的Hachi君个人 ...

8. python 参数类型的多态_【Python】面向对象：类与对象\封装\继承\多态

   六.Python面向对象--类与对象\封装\继承\多态 1.什么是面向对象编程 1.1 程序设计的范式:程序可控,易于理解 1.2 抽象并建立对象模型 1.3 程序是不同对象相互调用的逻辑.每个对象在 ...

9. python多态的三种表现形式_python小结----面向对象的三大特征(封装,继承,多态)

   面向对象的三大特征: 封装,继承,多态 面向对象的编程思想核心:高类聚,低耦合–程序的设计模式范畴 封装 什么是封装: 在面向对象编程的思想中,对代码进行高度封装,封装又叫包装 封装就是指将数据或者函 ...

10. python--编写程序：实现乐手弹奏乐器，乐手可以弹奏不同的乐器而发出不同的声音------使用类的封装继承多态的问题/使用面向对象的思想，设计自定义类，描述出租车和家用轿车的信息

    编写程序:实现乐手弹奏乐器,乐手可以弹奏不同的乐器而发出不同的声音 ------使用类的封装继承多态的问题 class Instrumnet():#乐器类def make_sound(self):pa ...

最新文章

1. 详解单链表经典OJ题
2. Python文件操作中进行字符串替换（保存到新文件/当前文件）
3. DCT C语言 修改了c程序以及matlab的程序
4. 亚马逊团队在Interspeech 2020深度噪声抑制挑战赛中获得第一名
5. Kubernetes集群上的Apache Ignite和Spring第1部分：Spring Boot应用程序
6. qnap nas web php,如何在QNAP NAS上建立并使用 iSCSI Target
7. 程序员：我们都在为错误买单！
8. 【iOS QR Code】集成ZXingWidget（XCode Version 4.5.2，iOS 6.0 SDK）
9. 使用正则test方法遇到的问题
10. 过拟合 准确率大幅下降_梯度下降和过拟合和归一化
11. 计算机驱动打不开,驱动人生打不开怎么办
12. 学习笔记—bootstrap(2)
13. 我们的地盘，我们做主
14. Cobbler自动装机服务搭建步骤
15. 上市公司融资需要哪些条件
16. jQuery二维码生成
17. rosetta stone fatal application error: #1141错误 (罗塞塔石碑1141) 解决方法
18. Debian11安装搜狗输入法
19. Discuz论坛 创始人密码忘记解决办法！
20. 2021较全 腾讯云服务器安装宝塔面板建网站全过程（图文教程）

热门文章

1. 我认为没有产品能力的技术人，走不了太远 - 阿里云 MVP 刘远程专访
2. 饥荒mod制作教程--物品(食物)(农作物)--02
3. IPv6的黑洞路由何去何从
4. Esri首席大数据专家Mansour Raad：人工智能与大数据的结合，会为地理信息产业带来颠覆式变化
5. CUDA thrust
6. 鸿蒙系统hifi,Apple Music将迎来重大更新 HiFi无损音质即将上线？
7. 22 个免费的网页设计插图资源
8. JavaWeb-JSP的IDEA创建项目、配置tomcat、导入jar包及JavaBean连接数据库
9. 压力测试工具之FIO
10. 小程序城市按首字母排序（如同苹果手机通讯录一样得效果）