|
|
文章目录
类和对象
首先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) } }
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.非访问修饰符
分为静态变量和静态方法
- 静态变量：
static 关键字用来声明 独立于对象 的静态变量。无论一个类实例化多少对象，它的静态变量只有一份拷贝，也就是说被该类 所有对象共享 ， 静态变量也被称为 类变量 。可以直接通过类名调用。
- 静态方法：
static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。
具体可以看下图：
（工具类：帮助我们做一些事情，但是不具体描述任何事物的类
特点：类名知名见意；私有化构造方法）
最后说一下static的注意事项
而main函数的修饰符static，其实也是一样的道理
- 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
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(); } }
抽象类和抽象方法
- 抽象方法：将共性的行为（方法）抽取到父类之后，由于每一个子类执行的内容是不一样，所以，在父类中不能确定具体的方法体。该方法就可以定义为抽象方法。
- 抽象类：一个类中没有包含足够的信息来描绘一个具体的对象。如果一个类中 存在抽象方法 ，那么该类 就必须声明为抽象类 。
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); } @Override public 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 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
- 一个类只能继承一个抽象类，而一个类却可以实现多个接口。
|
|
发表于 2023-6-23 17:21:54