Java-面向对象编程
面向对象
面向对象是Java核心的内容部分，在学习的过程中首先需要掌握各种知识点，利用知识点进行程序的设计。面向对象的运用是一个漫长的过程，关系到程序设计的各个方面，不仅仅是编写代码部分。
面向对象的相关内容是比较抽象的，掌握的难度上会有所增加。
三大特征
-
封装：核心思想就是**“隐藏细节”、“数据安全”**，将对象不需要让外界访问的成员变量和方法私有化，只提供符合开发者意愿的公有方法来访问这些数据和逻辑，保证了数据的安全和程序的稳定。所有的内容对外部不可见。
-
继承：子类可以继承父类的属性和方法，并对其进行拓展。将其他的功能继承下来继续发展 。
-
多态：同一种类型的对象执行同一个方法时可以表现出不同的行为特征。通过继承的上下转型、接口的回调以及方法的重写和重载可以实现多态。方法的重载本身就是一个多态性的体现。
三大思想
面向对象思想从概念上讲分为以下三种：OOA、OOD、OOP
-
OOA：面向对象分析（Object Oriented Analysis）
-
OOD：面向对象设计（Object Oriented Design）
-
OOP：面向对象程序（Object Oriented Programming ）
举例：
Scanner sc = new Scanner(System.in);
分析：
1、Scanner 就是Java中的一个class类。
2、new 关键字的含义。 ----new其实就是在堆内存中开辟空间创建对象。
3、Scanner(System.in); ---- 是啥？
答：调用Scanner类的构造，创建出sc这个对象。System.in仅仅是提供的一个参数而已！
4、通过调用sc对象中的各种方法来扫描控制台不同类型的数据。
类的定义
类的定义
在Java语言中，class类是最为基本的单元。
类：其实就是针对某一类事物的抽象描述，是一个模板。
类的设计语法、
| 类的修饰符 | 使用的对象 |
|---|---|
| public(公开的) | 类，接口，变量，方法（使用最广） |
| private（私有的） | 变量，方法，注意：不能修饰类（外部类） |
| default （默认的） | 类，接口，变量，方法 |
| protected（受保护的） | 变量，方法，注意：不能修饰类（外部类） |
类的修饰符 class 类名{
}
说明：
1、类的修饰符：public（缺省） 、abstract 、 final
2、class：是定义类的关键字；
3、类名：符合标识符的定义规范（首字母大写，多个单词合并则每个单词的首字母大写【参考源码】）；
4、{ } ： 类的主体部分，称为“类体”；
从以上的语法分析中，我们可以看出，设计一个类的外壳的时候，我们只需要关注各种修饰符即可。
public 、 缺省（不写） ： 属于权限修饰符；
public class MyClass{
}
说明：MyClass这个类可以在一个Java项目中的任意的位置进行使用；
class MyClass{
}
说明：MyClass这个类只能是在同一个包package下可以进行使用；
在项目开发中，可以适当的借助于不同的权限修饰符，来针对我们的类进行隔离。
abstract 、 final ：属于具有特殊含义的修饰符；
abstract : 修饰一个类的时候，表示这个类是一个“抽象类”。
final ：修饰一个类的时候，表示这个类是不允许被继承的(不允许作为父类)。
源码中的String类就是这样设计的: 源码 public final class String
注意！
abstract 和 final 是不能同时搭配使用的；
在Java语言中，有一个永恒成立的等式：
java类 = 属性 + 方法
换言之： 类 是由属性 和 方法所构成的 ，属性和方法都是定义在类的类体之中 。
类中的属性
属性：其实指的就是类中的成员变量（全局变量），是针对事物外部特征的描述；
全局变量分为2类：
a-----静态变量；
b-----实例变量；
属性的定义语法
修饰符 [static] 数据类型 属性名称 [= 值];
属性的修饰符有哪些？
public ：公共的；
缺省 ： 同一个包下可以进行访问;
protected : 具有2层含义：
a、同一个包下可以进行访问；
b、具有继承关系的可以进行访问（不关系包的位置）；
private ：只能在本类中进行使用，跨类则不能访问；
----------------------------------------------------------
static ： 修饰属性表示这是一个静态的变量；
final ： 表示一个常量，必须要手动赋值；
transient ： 修饰属性防止属性被序列化（后续讲解）；
volatile ： 属性同步的约定（涉及到Java多线程）；
属性的访问
属性就是对象的外部特征的描述，我们在使用的过程中：
如果是静态的属性： 【类名.属性】名称 进行访问；
如果是实例的属性： 创建对象 ， 再通过【对象.属性】进行访问；
类中的方法
方法：也称为“函数”，就是针对事物的功能进行的描述（表示能够干什么事情）。
方法从静态性与否的角度进行分类：
a、静态方法
b、实例方法
方法的定义语法
修饰符 [static] void|数据类型 方法名称(参数列表.....){
//方法体;
[return 值;]
}
方法的修饰符有哪些？
public ：公共的；
缺省 ： 同一个包下可以进行访问;
protected : 具有2层含义：
a、同一个包下可以进行访问；
b、具有继承关系的可以进行访问（不关系包的位置）；
private ：只能在本类中进行使用，跨类则不能访问；
-------------------------------------------------------------
static : 修饰的方法为静态方法；
final ：修饰的方法为最终版本的方法，这种方法是不能被重写的；
synchronized ： 修饰的方法为线程同步（后续讲解）；
abstract ： 抽象方法（抽象类的时候进行讲解）；
native ： 本地方法（这种方法是没有方法体的，内部使用的是非Java语言实现的，更多的是C和C++以文件的形式来实
现的）；
方法的调用
方法的分类（从静态与非静态的角度分）： 静态方法 和 非静态方法；
静态方法： 【类名.方法名称】进行调用；
实例方法： 创建对象， 再【对象.方法名称】进行调用；
方法的分类（有无返回值的角度分）：有返回值 和 无返回值；
有返回值 ： 数据类型 变量 = 调用方法()；
无返回值 ： 调用方法()；
方法的分类（有无参数列表角度分）：有参数 和 无参数；
有参数的方法： 调用方法(实际值1，实际值2，....);
无参数的方法： 调用方法();
区分静态和非静态
加载时机不同
- 静态
- 一个类中的静态成员会在类加载的时候，首先进行初始化（创建并产生默认值）；
- 非静态
- 一个类中的实例成员会在创建类的对象的时候，才进行初始化；
生命周期不同
- 静态
- 静态的成员在类加载的时候创建，类被删除的时候销毁，声明周期较长；
- 非静态
- 实例成员在创建对象的时候初始化，对象销毁的时候一起销毁，相对较短；
共享性不同
- 静态
- 静态的成员是被这个类的对所有的对象共享的；
- 非静态
- 实例的成员是被每个对象独立的拥有；
访问方式不同
- 静态
- 静态的就是通过【类名.进行访问】；
- 非静态
- 实例成员必须要创建对象，再通过【对象.进行访问】;
过渡！
我们为何要使用Java作者开发出来的那些类？
答：因为这些类中包含了我们所需要的一些功能，我们可以不用编写Java程序代码而直接使用。
Java内部提供的所有的类，是不能完全满足我们的现实需求的，所以我们就需要自己定义出新的类。那么定义新的类的目
标是什么呢？
答：如何使用这个类？需要创建类的对象来进行使用内部的属性和方法。
结论：定义类不是目的，最终是为了使用类中的属性 和 方法。
对象的定义
对象的定义
class类是具有抽象性的，是对某一类事物的描述，它是一个基础也是一个前提条件，也可以把它视为一个“模板”。
我们基于这个“模板”所产生出来的一个一个具体的东西，就称为“对象”。
对象是客观存在的一个一个的个体，是看得见摸得着的客观事物。
类：是抽象描述每一类事物------模板；
对象：是类的具体化，客观存在的实体-----具体化；
类的具体化
针对已经存在的某个类，如何将其进行具体化呢？也就是如何创建出具体的对象呢？
我们使用的是类中的【构造方法】来实现的；
class类-------【构造方法】--------对象
什么是构造方法
构造方法也是属于方法，就是在类中使用类的名称作为方法的名称，并且永远都是如此。而且是没有所谓的返回值的约定（连void都没有），因为构造方法不做别的事情，就是生成对象的。
public class Student{
//构造方法
public Student(){
}
}
构造方法的特点
构造方法是特殊的方法，存在如下的几个特点：
1、构造方法的名称永远和类的名称是一致的；
2、构造方法永远是没有返回值的约定的，连void都没有；
3、一个类中可以同时存在多个构造方法，参数上会存在差别，不同的构造表达了不同的初始化程度；
public class Student {
//属性
public String name;
public int age;
public char sex;
//无参数的构造方法
public Student(){
}
//带有1个参数的构造方法
public Student(String name){
//打印的name是局部变量中的name的值
//局部变量和全局变量重名的时候，遵循的是就近原则
//System.out.println(name); // “刘德华” 而不是 null
this.name=name;
//当成员变量和局部变量重名的时候，我们使用的是this关键字来进行区分的
//this代表的是当前类（Student）的对象
}
//带有3个参数的构造方法
public Student(String name,int age,char sex){
this.name=name;
this.age = age;
this.sex = sex;
}
}
Test.java
public class Test {
public static void main(String[] args) {
/*
//创建1个学生对象
Student stu1 = new Student();
//属性都是默认值
System.out.println(stu1.name);//null
System.out.println(stu1.age);//0
System.out.println(stu1.sex);//空白字符
*/
/*
Student stu2 = new Student("刘德华");
*/
//使用同一个构造，创建多个对象
Student stu3 = new Student("张学友",30,'男');
System.out.println(stu3.name);
System.out.println(stu3.age);
System.out.println(stu3.sex);
Student stu4 = new Student("张三丰",40,'男');
System.out.println(stu4.name);
System.out.println(stu4.age);
System.out.println(stu4.sex);
}
}
说明！
1、调用构造创建对象的时候，使用的是new关键字；
2、选择使用不同的构造方法来创建对象，表达的是对当前这个对象不同程度的初始化；
4、我们调用构造方法的时候，使用的是 new 关键字；
5、当我们的一个类中没有手动定义构造的时候，系统会默认一个不带参数的构造，一旦出现手动定义的构造，系统就不再
默认了。
6、一个类中同时存在的多个构造方法，就是构成了最为典型的“方法的重载”；
方法的重载
- 方法名相同；
- 方法的参数不同（参数类型不同，参数的个数不同，参数的顺序不同）：满足这三个条件至少一条即可认为参数的方法参数不同，
/**
* MyBean类中定义几个方法来实现某些功能
*
* 演示方法的重载(MyBean类中的4个方法就构成了方法的重载)
*/
public class MyBean{
public double area(double a,double b){
double c = a*b/2;
System.out.println("三角形的面积"+c);
return c;
}
public static void area(int a,int b){
System.out.println("长方形的面积"+a*b);
}
public static double area(int r,double pi){
double b = pi*r*r;
System.out.println("圆的面积"+b);
return b;
}
public static void area(int a,int b,int c){
System.out.println("梯形的面积"+(a+b)*c/2);
}
}
public class DemoMathMain {
public static void main(String[] args) {
Student.area(16,18);
double d = Math.PI;
Student.area(9,d);
Student.area(16,15,4);
Student student = new Student();
student.area(1.2,3.4);
}
}
注意：
声明为final的方法不能被重载，
声明为static的方法不能被重载，但能够再次声明
方法重载的优势
在功能确定的情况下，最大化满足外界灵活多变的需求。 比如：Arrays.sort(各种类型的数组);
附加内容：可变参数的使用
//任意的多个整数之和，咋办？---使用数组定义
/*
* public int getSum(int[] is){
int sum = 0 ;
if(is!=null&&is.length>0){
for(int value:is){
sum+=value;
}
}
return sum;
}
*/
//使用可变参数来定义方法----可变参数
public int getSum(int... is){
//在定义可变参数的时候，在参数列表中最多只能有1个，并且只能在列表的末端
int sum = 0 ;
if(is!=null&&is.length>0){
for(int value:is){
sum+=value;
}
}
return sum;
}
在方法进行调用的时候的差异对比：
//首先需要将数据保存数组中
int[] is = {1,2,3,4,5,6};
//才能使用这个方法来进行求和
int sum = mb.getSum(is);
//使用可变参数后，的调用情况如下
int sum = mb.getSum(1,2,3,4,5,6,7,8,9,10); //直接给出数据，不用在数组中进行封装,简单方
构造方法的作用
1、基于类创建出对象；
2、基于创建的这个对象进行不同程度的初始化；
this关键字
this关键字永远表示的是 当前这个类的对象 的指代, 它是一个变量 ；
public class User {
public String name;
public int age;
public String address;
//自定义一个方法
public void method1(){
//通过user1.method1调用方法的时候，this指代的user1这个对象
this.name = "admin";
//通过user2.method1调用方法的时候，this指代的user2这个对象
//总结：
//不管是user1 还是 user2对象，都是属于User这个类的对象；
}
...............
}
UserTest.java
public class UserTest {
public static void main(String[] args) {
User user1 = new User();
user1.method1();
User user2 = new User();
user2.method1();
}
}
注意！
this关键字的使用场景：
1、用于在同一个类中进行重名的 局部变量 和 成员变量 的区分；
2、在同一个类中，this可以用于在【非静态的方法中】进行方法的互调；
【this关键字是无法使用在静态的方法或者语句块中的】
3、在同一个类中，this可以进行构造的互调，并且只能是在第一行的位置；
类中的代码块
代码块：其实可以理解为一个没有名字的方法，也就是说属于“方法”的范畴。
在Java的类中，代码块可以分为2种形式：
-
静态代码块
- 为类中的静态成员做提前的准备和初始化工作
-
实例代码块
- 为类中的实例成员做提前的准备和初始化工作
package com.it.www.oop1;
public class User {
//main方法是程序执行的入口----JVM来控制的
//在main方法执行之前需要有哪些动作？----- 类的加载的过程
public static void main(String[] args) {
new User();
}
//静态代码块-------1、自动执行的 2、何时被自动执行的? (执行的比较早)
static{
System.out.println("----static-----");
}
//实例代码块-------1、自动执行 2、在创建User类的对象的时候执行的
{
System.out.println("----instance----");
}
}
提示！
不管是静态代码块还是实例代码块，都是属于方法。
完整的一个类的加载顺序
package com.it.www.oop1;
public class User {
private static int age = 30;
private String name = "name";
public User(){
System.out.println("----User----");
}
//main方法是程序执行的入口----JVM来控制的
//在main方法执行之前需要有哪些动作？----- 类的加载的过程
public static void main(String[] args) {
new User();
}
//静态代码块-------1、自动执行的 2、何时被自动执行的
static{
System.out.println("----static-----");
}
//实例代码块-------1、自动执行 2、在创建User类的对象的时候执行的
{
System.out.println("----instance----");
}
}
总结：
1、在类被加载的过程中，所有的静态成员都被创建和初始化了。
2、在创建对象的过程中，才会针对所有的实例成员进行创建和初始化。
3、针对任意的成员变量，都会存在一个创建 （系统初始化值） + 初始化（手动赋值）。
继承关系
继承的基本概念
继承是面向对象的三大特征之一，继承可以降低代码的冗余性，提高代码的效率，通过继承，子类获得父类的**成员变量，方法。**一个子类如何继承父类的字段和方法。
继承：是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例和方法，或子类从父类继承方法种，使得子类具有父类相同行为。
**继承的作用：**通过继承可以快速的创建一个类，实现代码的重用，提高程序的可维护性，节省大量时间，创建新类的时间，提高开发效率和开发质量，
在Java种通过extends关键字可以申明一个类是从另外一个类继承而来的，
继承定义语法
继承机制的实现，就是在类的后面使用extends关键字来进行定义：
public class Student extends Person{
.......................
}
public class Teacher extends Person{
}
Student类：是子类；
Person类：是父类（基类）；
注意！
在Java语言中【类与类之间】的继承，只能支持【单继承】。
继承案例
Person.java
package com.it.www.oop2;
/**
* 父类(基类)----继承了Object类
*/
public class Person {
public String name;
public int age;
public char sex;
public void sleep(){
System.out.println("人睡觉!");
}
public void eat(){
System.out.println("人吃饭!");
}
}
Student.java
package com.it.www.oop2;
/**
* 子类-----继承的是Person类
*/
public class Student extends Person{
//通过继承来进行了替代
/*public String name;
public int age;
public char sex;
public void sleep(){
System.out.println("人睡觉!");
}
public void eat(){
System.out.println("人吃饭!");
}*/
//以下的属于学生特有的属性 和 方法
public int sNo;//学号
public void study(){
System.out.println("学生学习!");
}
}
Student_Test.java
package test;
import com.it.www.oop2.Student;
public class Student_Test {
public static void main(String[] args) {
//创建一个学生对象
Student student = new Student();
//使用的是父类Person中继承过来的属性和方法
student.name="小花";
student.sex='女';
student.age = 25;
student.eat();
student.sleep();
//使用的是Student自身特有的属性和方法
student.sNo = 1001;
student.study();
}
}
备注！
在继承的过程中，并不是将父类中所有的属性和方法都能同时继承过来，取决于各种不同的修饰符的规则。
在继承的使用中，可以适当的使用不同的修饰符针对属性和方法进行保留。
在使用继承的过程中，需要注意的事项：
1、extends的实现，一定是依赖父子之间的构造方法的。
2、子类的构造中通过super来调用了父类中相应的构造方法来进行初始化（不能不对应，否则继承不成立）。
3、super就是用于在子类的构造中调用父类的构造，只能在是子类的构造方法的第一行，所以和this实现构造互调的时
候，不能搭配使用。
super关键字
super关键字的使用场景
1、用于父子之间的构造方法中，实现构造的调用。
2、在父子类之间可以通过super来区分重名的属性 和 方法。
3、语法特点：super只能是使用在非静态的方法或者语句块中。
4、super关键字必须要写
方法的重写
方法重写的定义
-
继承关系中（方法名相同，参数列表相同，返回数据类型）称为“方法的重写”
-
方法的重写也讲为：“方法的覆写”、“方法的改写”。
方法重写案例
Demo.java（父类）
public class Demo {
int age ;
String name ;
String sex;
void test(){
System.out.println("张三");
System.out.println("18");
System.out.println("nan");
}
}
DemoSon.java（子类）
public class DemeSon extends Demo{
void test(){
super.age=89;
super.name = "张三";
super.sex="男";
super.test();
}
}
Demo1.java(测试类)
public class Demo1{
public static void main(String[] args) {
DemoSon1 demeSon = new DemoSon1();
demeSon.test();
}
}
附加知识点！
User.java
package com.it.www.bean;
public class User {
public String name;
public int age;
public User() {
super();
}
public User(String name, int age) {
super();
this.name = name;
this.age = age;
}
//重写了Object类中的toString方法
public String toString() {
return "User [name=" + name + ", age=" + age + "]";
}
}
UserTest.java
package test;
import com.it.www.bean.User;
public class UserTest {
public static void main(String[] args) {
User user = new User("admin",30);
//打印输出(地址)----默认的调用的是toString方法
System.out.println(user); //com.it.www.bean.User@15db9742
//重写toString方法后的结果:User [name=admin, age=30]
}
}
需求：
User 对象 user1===== [name=“admin”,age=30]
User对象 user2===== [name=“admin”,age=30]
user1 和 user2 是两个不同的对象，但是数据信息又是相同的。我们想比较出2个对象中的数据是否相同？
答：重写类中的equals方法，实现的是内容信息的比较即可。
//重写父类的equals方法-----实现内容信息的比较
public boolean equals(Object obj) {
if(this==obj){
return true;
}
if(obj instanceof User){
User user = (User)obj;
//this.name中的equals方法，就是String类中的equals方法，作者已经重写过了，实现的内容的比较
if(this.name.equals(user.name)&&this.age==user.age){
return true;
}
}
return false;
}
注意！
Object 类中的equals方法实现的是对象的地址的比较。
String类中的equals方法已经重写过了，实现的是内容信息的比较。
将来自定义的类中的equals方法比较的是什么？取决于自己是否进行重写。
重写和重载的区别
重写是发生在继承关系中的，
方法名相同，参数列表相同，返回数据类型形同
同一个类中，
方法名相同
参数不同（数量不同，顺序不同，数据类型不同）
总结
- 父类中的属性定义为私有，子类不能继承其父类中的private成员，如果我们子类想要访问父类成员可以写为public和不写，protected，
- 子类继承父类之后，其成员修饰符必须大于或者等于父类中的修饰符，不可将其降低修饰符的访问权限，
- 方法的重写一定是在父子类继承关系中产生的
- 子类无法访问父类中的静态（static）成员
- 子类重写父类中的方法，（方法名必须和父类中的相同，方法中的参数一致，返回的数据类型一致）
- super关键字：可以在子类中通过super来调用父类中的被重写的方法和访问父类中成员；
多态
概念
多态是面向对象中最重要的特征之一，指同一个事物在不同场景下有着不同的形式。同一个对象在不同时刻，代表的对象不一样，指的是对象的多种形态。
可以把不同的子类对象都当作父类来看，进而屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，统一调用标准。
特点
- 多态的前提是：
- 继承
- 要有方法的重写
- 父类引用指向子类对象：Demo demo = new DemoSon();
- 多态中，编译看左边，运行看右边。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RoeLvEPj-1677669224022)(面向对象.assets/image-20220808150342073.png)]
多态案例
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zKUoyW0A-1677669224024)(面向对象.assets/image-20221026101303918.png)]
父类
/**
* 多态的前提是：继承+重写
* 创建父类
*/
public class Demo {
public void eat(){
System.out.println("水");
}
}
子类1
/**
* 创建子类
*/
public class DemoExtendsSon1 extends Demo{
//重写父类中的eat方法
public void eat() {
System.out.println("0°一下----");
}
//延展子类中的方法
public void jump(){
System.out.println("冰");
}
}
子类2
public class DemoExtendsSon2 extends Demo{
//添加父类中的方法，进行重写
public void eat() {
System.out.println("0°以上------");
}
//延展子类方法，
public void run(){
System.out.println("水");
}
}
子类3
public class DemoExtendsSon3 extends Demo{
//重写父类中的方法
public void eat() {
System.out.println("100°以上--------");
}
//子类方法延展
public void du(){
System.out.println("气");
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jhjHTXTO-1677669224024)(面向对象.assets/image-20220808152501438.png)]
getter，setter方法
package com.sin.demoExtends;
public class DemoCar {
//汽车品牌
private String name;
private String color="五彩斑斓的黑";//汽车颜色
private double money;//价格
private int id;//汽车id
public void start(){
System.out.println("父类--这个车可以开"+color);
}
public void stop(){
System.out.println("父类--这个车可以停");
}
public String getName(){//获取汽车名称
System.out.println(name);
return name;//返回汽车名称
}
public void setName(String name){//设置汽车名称
this.name = name;//将参数name赋值给属性
}
public String getColor(){//获取汽车颜色
System.out.println(color);
return color;
}
public void setColor(String color){//
this.color=color;
}
public double getMoney() {
return money;
}
public void setMoney(double money) {
this.money = money;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
}
子类1
package com.sin.demoExtends;
public class DemoCarExtendsSon1 extends DemoCar{
//重写父类方法
public void start() {
System.out.println("这个开的很快");
}
}
子类2
package com.sin.demoExtends;
public class DemoCarExtendsSon2 extends DemoCar{
//重写父类方法
public void stop() {
System.out.println("这个车刹车灵");
}
//延展子类方法
public void swim(){
System.out.println("他的安全性高，有安全带");
}
}
测试
public class TestDemoCar {
public static void main(String[] args) {
//实例化子类
DemoCarExtendsSon1 demoCarExtendsSon1 = new DemoCarExtendsSon1();
demoCarExtendsSon1.setName("劳斯莱斯");
demoCarExtendsSon1.getName();
demoCarExtendsSon1.setColor("黑色");
demoCarExtendsSon1.getColor();
demoCarExtendsSon1.setId(12138);
System.out.println(demoCarExtendsSon1.getId());
demoCarExtendsSon1.setMoney(10000000.23);
System.out.println(demoCarExtendsSon1.getMoney());
demoCarExtendsSon1.start();
DemoCarExtendsSon2 demoCarExtendsSon2 = new DemoCarExtendsSon2();
demoCarExtendsSon2.stop();
demoCarExtendsSon2.swim();
}
}
多态的好处
1，多态可以让我们不同关心某个对象到底具体是什么类型，就可以使用该对象的某些方法
2，提高了程序的可扩展性，可维护性
多态的使用
前提：多态的对象是将自己看作父类类型
- 成员变量：使用的是父类的
- 成员的方法：由于存在重写现象，所以使用的是子类的
- 静态的成员：随着子类调用父类加载而加载
抽象类
抽象类的基本概述
普通类是一个完善的功能类，可以直接产生实例对象，并且普通类中有构造方法，普通方法，static方法，变量和常量等，而抽象类是指在普通类的结构里面增加了抽象方法的组成部分
抽象类是无法实例化的，
什么叫抽象方法：在所有的普通方法上面都会有“{}”，这表示方法体，有方法体的方法一定可以被对象直接调用，而抽象方法，是指没有方法体的方法 ，同时抽象方法还必须使用关键字abstract关键字来申明；
拥有抽象方法的类就是抽象类，抽象类要使用abstract关键字声明；
抽象类的使用
抽象方法的语法格式:
修饰符 abstract void/数据类型 方法名称(参数列表...);
抽象的方法（父类）
/**
* 抽象类
* 1,可以写普通方法，
* 2，可以写抽象方法
* 3,可以写变量
* 4,可以写常量
* 5,不可以写静态抽象方法，
* 6,可以写构造方法
*7,可以写静态方法
*/
public abstract class DemoAbstatis01 {
public void test(){
System.out.println("helloword");
}
public abstract void test1();
/**
* 抽象方法，计算圆周长
*/
public abstract void getPerimeter();
/**
* 抽象方法，
* 获取圆的面积
*/
public abstract void getArea();
}
继承抽象方法的子类
public class DemoAbstractSon1 extends DemoAbstatis01{
@Override
public void test1() {
System.out.println("我继承了我爸爸的抽象方法");
}
/**
* 抽象的父类方法中强制实现的方法
* 计算周长
*/
@Override
public void getPerimeter() {
double r = 2.0;
System.out.println("圆的周长"+Math.PI*2*r);
}
/**
* 抽象的父类方法中强制实现的方法
* 计算圆的面积
*/
@Override
public void getArea() {
double r = 19.28;
System.out.println("圆的面积"+Math.PI*r*r);
}
}
测试类
public class DemoMain {
public static void main(String[] args) {
DemoAbstractSon1 demoAbstractSon1 = new DemoAbstractSon1();
demoAbstractSon1.test1();
demoAbstractSon1.test();
demoAbstractSon1.getPerimeter();
demoAbstractSon1.getArea();
}
}
抽象类的使用原则：
- 抽象类的修饰符，必须为public/protected，也可以不用写，默认为public，不能写为private，
- 抽象类不能被直接实例化，可以通过子类采用向上转型的方式进行实例化，（使用父类实例化子类）
- 抽象类必须有子类，可以有多个子类继承，使用extends继承，一个子类只能继承一个父类。
- 子类在继承抽象父类的时候必须覆写抽象父类中的抽象方法，（如果不覆写父类中的抽象方法，则将类写为抽象类）
- 子类继承抽象父类的时候，抽象方法必须被覆写，普通方法可以选择性覆写。
向上转型
//抽象类---------------------------------------------------------------
/**
* 自定义的抽象类
*/
public abstract class A {
public void test(){//普通方法
System.out.println("这是抽象类中的普通方法");
}
public abstract void test1();
}
//子类继承抽象父类---------------------------------------------------------------
/**
* B类是抽象类的子类，是一个普通类
*/
public class B extends A{
@Override
public void test1() {
System.out.println("helloword");
}
}
//测试类---------------------------------------------------------------
public class DemoMain {
public static void main(String[] args) {
//向上转型（父类实例化子类）
A c = new B();
c.test();
c.test1();
}
}
抽象类也是一种复合引用类型。
类 可以继承 类
抽象类 可以继承 类
类 可以继承 抽象类
抽象类 可以继承 抽象类
练习
父类
public abstract class DemoAbstract02 {
/**
* 长方形面积
* @param a 长
* @param b 宽
* @return 长方形面积a*b
*/
public abstract double area(double a,double b);
/**
* 三角形面积
* @param a 底
* @param b 高
* @return 面积 a*b/2
*/
public abstract double area(double a,int b);
/**
* 梯形面积
* @param a 上底
* @param b 下底
* @param c 高
* @return 体形面积 (a+b)*c/2
*/
public abstract double area (double a,double b , double c);
/**
* 三角形周长
* @param a 边长
* @param b 边长
* @param c 边长
* @return 三角形走场：a+b+c
*/
public abstract double perimeter(double a,double b,double c);
/**
* 长方形周长
* @param a 长
* @param b 宽
* @return （a+b）*2
*/
public abstract double perimeter( double a, double b);
/**
* 正方形
* @param a 边长
* @return a*4
*/
public abstract double perimeter( double a);
}
子类
public class DemoAbstractSon2 extends DemoAbstract02{
/**
* 长方形面积
* @param a 长
* @param b 宽
* @return
*/
@Override
public double area(double a, double b) {
double c=a*b;
return c;
}
/**
* 三角形面积
* @param a 底
* @param b 高
* @return
*/
@Override
public double area(double a, int b) {
double c= a*b/2;
return c;
}
/**
* 梯形面积
* @param a 上底
* @param b 下底
* @param c 高
* @return
*/
@Override
public double area(double a, double b, double c) {
double e = (a+b)*c/2;
return e;
}
/**
* 三角形周长
* @param a 边长
* @param b 边长
* @param c 边长
* @return
*/
@Override
public double perimeter(double a, double b, double c) {
double d = a+b+c;
if (a==b && b==c){
System.out.println("是等边三角形");
}else if (a==b || a==c || c==b){
System.out.println("这是等腰三角形");
}
return d;
}
/**
* 长方形周长
* @param a 长
* @param b 宽
* @return
*/
@Override
public double perimeter(double a, double b) {
double c = (a+b)*2;
return c;
}
/**
* 正方形周长
* @param a 边长
* @return
*/
@Override
public double perimeter(double a) {
double c = a*4;
return c;
}
}
测试类
public class DemoMain {
public static void main(String[] args) {
DemoAbstract02 demo = new DemoAbstractSon2();
double c = demo.area(12.3,36.5);
System.out.println("长方形面积"+c+"cm²");
System.out.println("三角形面积"+demo.area(6.3,3)+"cm²");
double a = demo.area(3.3,6.6,9.9);
System.out.println("梯形面积"+a+"cm²");
System.out.println("------------------------------------------------------------------");
double a1 = demo.perimeter(9.9);
System.out.println("正方形周长"+a1);
}
}
接口
接口基本概念
官方解释：Java接口就是以系列方法的声明，
接口可以理解为特殊的类，里面全是全局变量，公开的抽象方法，所组成，接口解决的问题Java无法使用多继承的一种手段。一个接口只有方法的特征没有方法的具体实现。或者我们可以直接把接口理解为全部都为抽象类，接口中必须都为抽象方法。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-p39Hmeuu-1677669224025)(面向对象.assets/image-20220810141526292.png)]
接口的特点
- 接口中全是抽象方法，全局变量，
- 接口指明了一个类必须要做什么，和不能做什么，
接口的定义语法
public|缺省 interface 接口名称{
//定义常量：
//public static final 数据类型 常量名称 = 值;
//抽象方法:
//public abstract void/数据类型 方法名称(参数列表...);
}
注意！
接口是没有构造方法的，更不能创建对象。只是定义一种规则和规范。
package com.it.www.oop1;
/**
* 介绍接口的语法格式
* @author Administrator
*
*/
public interface InterfaceA {
public static final String NAME="admin";
//在接口中定义常量的格式为：public static final
//如果我们在定义的时候存在相应的省略，默认的也是 public static final
public static String NAME1="admin";
public String NAME2="admin";
//所以我们通常在开发的过程中，为了相应的简化写法，一般是这样做的。
String NAME3="admin";
//抽象方法:默认的修饰符是 public abstract
public abstract void method1(String name);
//通常在开发中为了简化，可以这样写:
void method2(String name);
}
接口使用
InterfaceB.java
package com.it.www.oop1;
public interface InterfaceB {
//分页单位为 5
int PAGE_SIZE = 5;
int getPageSize();
int getPageData();
}
MyClass.java 实现类
package com.it.www.oop1;
/**
* MyClass是一个类，这是实现InterfaceB这个接口的一个实现类。
* @author Administrator
*/
public class MyClass implements InterfaceB {
public int getPageSize() {
//可以使用 this.PAGE_SIZE来进行使用，说明PAGE_SIZE已经是MyClass类中的常量了，所以，接口有这么一个规定
//只要是这个接口的实现类，都可以毫无条件的共享接口中的全部常量。
return this.PAGE_SIZE;
}
public int getPageData() {
return 0;
}
}
注意！
1、定义接口使用的是interface关键字；
2、接口中只有常量和抽象方法2部分；
3、实现类来实现接口使用的是implements关键字；
4、实现类一旦实现了某个接口，就可以毫无条件的共享接口中的所有常量；
InterfaceC.java
package com.it.www.oop1;
public interface InterfaceC {
String NAME = "刘德华";
String getName();
int getAge();
}
MyClass.java
package com.it.www.oop1;
/**
* MyClass是一个类，这是实现InterfaceB这个接口的一个实现类。
* @author Administrator
*/
public class MyClass implements InterfaceB , InterfaceC{
public int getPageSize() {
//可以使用 this.PAGE_SIZE来进行使用，说明PAGE_SIZE已经是MyClass类中的常量了，所以，接口有这么一个规定
//只要是这个接口的实现类，都可以毫无条件的共享接口中的全部常量。
return this.PAGE_SIZE;
}
public int getPageData() {
return 100;
}
public String getName() {
return this.NAME;
}
public int getAge() {
return 30;
}
}
提示！
同一个类可以同时实现多个接口，多个接口之间使用【，】号进行分隔；
InterfaceD.java
package com.it.www.oop1;
/**
* 接口之间也是可以继承的，并且可以支持多重继承。
* @author Administrator
*/
public interface InterfaceD extends InterfaceB,InterfaceC {
void method01();
void method02();
}
MyClass1.java
package com.it.www.oop1;
/**
* 实现类中需要实现的方法就包含了IntefaceB 、 C 、 D中的所有的抽象方法 和 共享了所有的接口中的所有常量
* @author Administrator
*/
public class MyClass1 implements InterfaceD {
public int getPageSize() {
// TODO Auto-generated method stub
return 0;
}
public int getPageData() {
// TODO Auto-generated method stub
return 0;
}
public String getName() {
// TODO Auto-generated method stub
return null;
}
public int getAge() {
// TODO Auto-generated method stub
return 0;
}
public void method01() {
// TODO Auto-generated method stub
}
public void method02() {
// TODO Auto-generated method stub
}
}
提示！
1、接口之间是可以继承的，并且可以支持多重继承；
2、独立的接口就是某一类独立的操作，不同的接口可以同时作用（implements）在需要的类上；
3、弥补了Java中类只支持单继承的局限性；
上机任务
任务1：
编写一个接口：描述USB的功能。
service 方法；
实现类1：U盘。
连接接口，实现数据的传输
实现类2：USB电风扇。
连接接口，接通电源，启动风扇
/**
* usb的服务
*/
public interface USBService {
public void useTxt();
}
/**
* 实现类1，
*/
public class USBServiceImpl implements USBService{
@Override
public void useTxt() {
System.out.println("连接接口，实现数据的传输");
}
}
/**
* 实现类2
*/
public class USBServiceImpl2 implements USBService {
@Override
public void useTxt() {
System.out.println("连接接口，接通电源，启动风扇");
}
}
/**
* 测试类
*/
public class TestMain {
public static void main(String[] args) {
USBServiceImpl service = new USBServiceImpl();
service.useTxt();
USBServiceImpl2 service1 = new USBServiceImpl2();
service1.useTxt();
}
}
方法2：-------------------------------------------------------------------
/**
* usb的服务
*/
public interface USBService {
/**
* 常量，功能1
*/
public final String U_DISK = "连接接口，实现数据的传输";
/**
* 常量，功能2
*/
public final String ELECTRIC_FAN="连接接口，接通电源，启动风扇";
/**
* 描述usb的功能
*/
public void useTxt();
}
/**
* 实现类1，
*/
public class USBServiceImpl implements USBService{
@Override
public void useTxt() {
System.out.println(U_DISK);
}
}
/**
* 实现类2
*/
public class USBServiceImpl2 implements USBService {
@Override
public void useTxt() {
System.out.println(ELECTRIC_FAN);
}
}
任务2：
实现一个防盗门的功能：
门： 开门 、 关门的功能；
锁： 开锁 、关锁的功能；
防盗门 ---- 是门 ----- 锁
请问如何进行设计？
附加一个门铃（响，咔嚓拍照，进行存储）
如何进行设计？
接口的特点
1、定义的时候使用的是interface关键字；
2、接口就是用于负责定义功能（规范 或 标准）；
3、接口中是没有构造方法的；
4、接口都是通过实现类使用implements 来进行实现的；
5、接口中只有常量 和 抽象方法；
6、接口之间是可以进行继承的，并且可以支持多重继承；
7、接口重点在于一种设计中的使用（主要是针对模块 、 系统）之间来进行衔接的；
抽象类和接口的区别
抽象类与接口在语法上的区别
1.抽象类里可以有构造方法，而接口内不能有构造方法。
2.抽象类中可以有普通成员变量，而接口中不能有普通成员变量。
3.抽象类中可以包含非抽象的普通方法，而接口中所有的方法必须是抽象的，不
能有非抽象的普通方法。
4.抽象类中的抽象方法的访问类型可以是public ，protected和默认类型，但接
口中的抽象方法只能是public类型的，并且默认即为public abstract类型。
5.抽象类中可以包含静态方法，接口内不能包含静态方法。
6.抽象类和接口中都可以包含静态成员，抽象类中的静态成员变量的访问类
型可以任意，但接口中定义的变量只能是public static final类型，并且默认为
public static final类型。
7.一个类可以实现多个接口，但只能继承一个抽象类。
8.抽象类和接口所反映出的设计理念不同。其实abstract class表示的是“is-a”
继承关系，interface表示的是“like-a”关系。
两者在应用上的区别
接口更多的是在系统框架设计方法发挥作用，主要定义模块或者系统之间的通信，而抽象类主要在代码实现方面发挥作
用，可以实现代码的重用。
面向接口编程模式
com.it.www.dao : 定义数据库操作的接口包；
com.it.www.daoi : 定义数据库操作的接口的实现包；
com.it.www.service : 定义项目业务操作的接口包；
com.it.www.servicei : 定义业务操作的实现包；
PersonDao.java 接口
package com.it.www.system;
public interface PersonDao {
void savePerson();
void queryPersons();
}
PersonDaoImple.java实现类
package com.it.www.system;
public class PersonDaoImple implements PersonDao {
//实现的是接口中的方法
public void savePerson() {
System.out.println("---save Person----");
}
public void queryPersons() {
System.out.println("----query persons----");
}
//自己这个类的方法
public void myMthod01(){
System.out.println("----customer 1-----");
}
public void myMthod02(){
System.out.println("----customer 2-----");
}
}
Test.java
package com.it.www.system;
public class Test {
public static void main(String[] args) {
//使用 实现类的类型 创建 实现类的对象
PersonDaoImple personDaoImple = new PersonDaoImple();
personDaoImple.savePerson();
personDaoImple.queryPersons();
personDaoImple.myMthod01();
personDaoImple.myMthod02();
//使用面向接口编程模式
//使用接口的类型 接收 实现类的对象
PersonDao personDao = new PersonDaoImple();
//是PersonDao的类型，就只能调用出PersonDao中定义过的方法。
personDao.queryPersons();
personDao.savePerson();
//实现类PersonDaoImple中的自己的方法丢了。被接口给过滤了，所以，接口永远对外提供的功能都只是接口中定义过的功能。
}
}
提示！
更多的基于接口的分层结构和面向接口的编程模式，见： day05_09 项目中；
封装
- 封装：（数据的隐藏）,通常，应该禁止直接方法一个对象中的数据，而是通过操作接口来访问，成为信息隐藏
public class User {
//名字
private String name;
//性别
private String sax;
//年龄
private int age;
public User(){
}
public User(String name,String sax,int age){
this.name = name;
this.sax = sax;
this.age = age;
}
public void test(String name, String sax, int age){
this.name=name;
System.out.println(name);
this.sax = sax;
System.out.println(sax);
this.age = age;
System.out.println(age);
}
public String getName() {//获取对象数据
return name;
}
public void setName(String name) {//设置对象数据
this.name = name;
}
public String getSax() {
return sax;
}
public void setSax(String sax) {
this.sax = sax;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
package com.sin.pojo;
public class UserMain {
public static void main(String[] args) {
User user = new User();
user.setName("张三");
user.setAge(18);
user.setSax("男");
System.out.println(user.getName());
System.out.println(user.getAge());
System.out.println(user.getSax());
User user1 = new User("李四","女",29);
System.out.println();
System.out.println(user1.getSax());
System.out.println(user1.getName());
System.out.println(user.getAge());
user.test("王五","男",89);
}
}
当一个类中的变量别private（私有）只能在当前类下访问，他无法在主程序中直接调用，需要其他的一些方法调用
怎么对类中私有的变量进行操作？
- get : 获取对象中的值
- set : 设置对象的值
- 构造方法，普通方法，
为什么封装
- 提高程序的安全性，保护数据
- 隐藏代码的实现细节
- 统一接口
- 提高系统的可维护性
内部类
内部类的基本知识
内部类：就是定义在一个类的内部的类。内部类就是专门负责独立的描述某一类事物，而这一类事物仅仅只是在当前这个所
在类的范围内进行使用。在类中的任意位置需要提供局部性的服务，就可以使用内部类来实现。
问题1：
可以定义在一个指定的类内部的哪些位置？
答：任意位置（直接在类体中、方法中、代码块中、语句块中）。
问题2：
为什么要使用内部类?
答：就是为了在一个类的内部的任意的位置提供局部性的服务。
内部类
- 成员内部类
- 局域内部类
- 匿名内部类
- 静态内部类
成员内部类
成员内部类，是最普通的内部类，它的定义为位于另一个类的内部，
public class Demo {
public static void main(String[] args) {
Demo demoA = new Demo();
Demo.DemoA demoA1 = demoA.new DemoA();
}
public class DemoA{
public DemoA(){
System.out.println("我是内部类");
}
}
}
局域内部类
局部内部类使用比较少,其声明在一个方法体中，在局部内部类里面可以访问外部类中的对象的所有访问权限的字段，而外部类不能访问局部内部类的中定义的字段。
public class Demo {
private String name1 = "zhangsan";
public static void main(String[] args) {
Demo demo = new Demo();
demo.test1();
}
public void test1(){
//局部类，-->基于普通方法之的class
class A{
private String name;
public A(){//A类的无参构造方法
System.out.println(name1);
System.out.println("我是局部变量");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
//创建对象的目的是：让Java虚拟机识别到A类的对象
A a = new A();
a.setName("王五");
System.out.println(a.getName());
}
}
匿名内部类
匿名内部类有很多种形式，其中最常见的一种形式为方法参数中新建一个接口对象/类对象，并且实现这个接口声明，类中原有的方法：
接口匿名内部类
public class Demo {
public static void main(String[] args) {
Demo demo = new Demo();
demo.DemoTest();
}
//自定义接口
public interface Test{
//抽象方法
public void test1();
public String testName(String name);
}
private void DemoTest() {
//在这个过程中会创建一个匿名内部类对象
//这个匿名内部类实现Test接口中方法并重写test1
Test test = new Test(){
String name;
@Override
public void test1() {
System.out.println("我是匿名内部类");
}
@Override
public String testName(String name) {
this.name=name;
return name;
}
};
//对象调取方法
test.test1();
System.out.println(test.testName("我在测试匿名内部类"));
}
}
抽象匿名内部类
public class Demo {
public static void main(String[] args) {
Demo demo = new Demo();
demo.test1();
}
//自定义抽象类
public abstract class Test{
//抽象方法
public abstract String test(String name);
public void test1(){
System.out.println("这是匿名内部类中的普通方法");
}
}
public void test1(){
Test test = new Test(){
String name;
@Override
public String test(String name) {
this.name = name;
return name;
}
};
test.test1();
System.out.println(test.test("这是抽象类的匿名内部类"));
System.out.println("_______________");
}
}
在方法中new一个接口/抽象类，并实现接口/抽象类中的抽象方法，在这过程中其实会创建一个匿名内部类实现这个接口/抽象类，并重写接口/抽象类中的方法。
静态内部类
一个类的静态成员独立于这个类的任何一个对象存在，只要在具有访问权限的地方，我们就直接可以类.方法名的形式来访问这个静态成员。静态内部类也可以作为外部类的静态成员而存在，创建一个类的静态内部类对象不需要依赖外部类对象，可以直接类名.方法名
public class Demo {
public static void main(String[] args) {
Demo1.test();
}
//自定义静态内部类
static class Demo1{
public Demo1(){
}
public static void test(){
String name = "这是";
String name1 = "静态";
String name2 = "内部类";
System.out.println(name+name1+name2);
}
}
}
上机任务：
以上我们使用针对User对象数组进行了自定义的排序处理，使用的是Comparetor接口，其实还存在另一个比较器的接口，同样可以实现在Arrays.sort中进行排序处理（自己查阅一下完成）。
标准JavaBean规范
JavaBean的定义：就是一个class类。
标准的JavaBean的定义：其实就是在JavaBean的基础上设置了一些规则和规范。
1、所有的属性都是private修饰的；
2、所有的属性的名称的首字母一定是小写的；
3、所有的属性都会对应一个公共的set（赋值） 和 get（取值）方法；
4、一般会添加上一个无参数的构造和一个全部带参数的构造；
注意！
以后我们会学习到Java的反射机制，反射机制中都会遵循标准JavaBean的规范来进行处理。
package com.it.www.entity;
public class User {
private String name;
private String address;
private int age;
private char sex;
public User() {
super();
}
public User(String name, String address, int age, char sex) {
super();
this.name = name;
this.address = address;
this.age = age;
this.sex = sex;
}
//get方法是有返回值的，返回类型就是属性的类型，是没有参数的
//get+属性名称的首字母大写+后面的所有的字符保持不变
public String getName() {
return name;
}
//属性： Name
//set方法名称： setName
//根据set方法名称还原属性名称
//Name------name
//set方法是赋值的，参数的类型就是属性的类型，是没有返回值的
public void setName(String name) {
this.name = name;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
}