本文介绍了面向对象编程的三大核心概念：封装、继承和多态。详细讲解了如何通过封装提高程序的安全性和可维护性，继承如何帮助更好地建模现实世界，以及多态如何提升代码的灵活性和扩展性。
1. 封装
-
该露的露，该藏的藏
* 我们程序设计要追求***高内聚，低耦合***，高内聚就是类的内部数据操作细节自己完成，不允许外部的干涉；低耦合：仅暴露少量的方法给外部使用 -
封装（数据的隐藏）
* 通常，应禁止访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。 -
记住这句话就够了：属性私有，get/set
-
意义：
1. 提高程序的安全性，保护数据
2. 隐藏代码的实现细节
3. 统一接口
4. 系统可维护性增加了 -
注：
1. 快捷键：alt + insert : Getter and Setter -
代码：
package com.oop.demo03;
public class Student {
private String name; //名字 //与public对应，属性私有
private int id; //学号
private char sex; //性别
private int age; //年龄
//提供一些可以操作这些属性的方法
//提供一些public的get、set方法
//get：获得这个数据
public String getName(){
return this.name;
}
//set:给这个数据设置值
public void setName(String name){
this.name = name;
}
//alt + insert : Getter and Setter 快捷键
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age<0 || age >120){ //不合法年龄
this.age = 0;
}else{
this.age = age;
}
}
}
package com.oop.demo03;
public class Application {
public static void main(String[] args) {
Student s1 = new Student();
s1.getName();
s1.setName("kuangshen");
System.out.println(s1.getName());
s1.setAge(999); //不合法的
System.out.println(s1.getAge());
//通过get/set内部封装 规避这些问题
}
}
2.继承
-
继承的本质是堆某一批类的抽象，从而实现对现实世界更好的建模。
-
***extends***的意思是"扩展",子类是父类的扩展。
-
JAVA中类只有单继承，没有多继承.一个儿子只能有一个爸爸，一个爸爸可以有多个儿子。
-
继承是类和类之间的一种关系，初次之外，类和类之间的关系还有依赖，组合，聚合等
-
继承关系的两个类，一个为子类（派生类），一个为父类（基类），子类继承父类，使用关键字extends来表示
-
子类和父类之间，从意义上将应该具有"is a"的关系。
package com.oop.demo05;
//Person 人
public class Person {
public int money = 10_0000_0000; //JDK7的新特性，"_"分割数字
//修饰符
//public
//protected
//default
//private
// Person person; //组合关系
public void say(){
System.out.println("说了一句话");
}
}
package com.oop.demo05;
//Student is a Person 派生类 子类
//子类继承了父类，就会拥有父类的全部方法
//JAVA中，所有的类都直接或间接继承Object
public class Student extends Person{
// ctrl +H 查看继承关系树状结构
}
package com.oop.demo05;
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.say();
System.out.println(student.money);
}
}
-
object类
* JAVA中，所有的类都直接或间接继承Object -
super
* 代码
package com.oop.demo05;
//Person 人
public class Person {
public String name = "qinjiang";
public void print(){
System.out.println("Person");
}
//private 私有的可以被继承，但不能被直接问
public Person(){
System.out.println("Person的无参构造执行了");
}
}
package com.oop.demo05;
//Student is a Person 派生类 子类
//子类继承了父类，就会拥有父类的全部方法
//JAVA中，所有的类都直接或间接继承Object
public class Student extends Person{
// ctrl +H 查看
public String name = "kuangshen";
public void test(String name){
System.out.println(name);
System.out.println(this.name);
System.out.println(super.name);
}
public void print(){
System.out.println("Student");
}
public void test1(){
print();
this.print();
super.print();
}
//无参构造
public Student(){
//隐藏代码：调用了父类的无参构造
//super(); //调用了父类的构造器，必须要在子类构造器的第一行
System.out.println("Student无参执行了");
}
}
package com.oop.demo05;
public class Application {
public static void main(String[] args) {
Student student = new Student();
System.out.println("=====================");
student.test("秦疆");
System.out.println("===============================");
student.test1();
}
}
运行结果
Person的无参构造执行了
Student无参执行了
=====================
秦疆
kuangshen
qinjiang
===============================
Student
Student
Person
Process finished with exit code 0
* 注意点
* 1. super调用父类的构造方法，必须在构造方法的第一个
* 2. super必须只能出现在子类的方法或者构造方法中
* 3.super和this不能同时调用构造方法
* 4.super vs this
* 代表的对象不同
this：本身调用这个对象
super：代表父类对象的引用
* 前提
this：没有继承也可以使用
super：只能在继承条件才可以使用
* 构造方法
this()：本类的构造
super()：父类的构造
-
方法重写
* 代码
package com.oop.demo06;
public class B {
public void test(){
System.out.println("B=>test()");
}
}
package com.oop.demo06;
public class A extends B{
//Override 重写
@Override //注解：有功能的注释！
public void test() {
super.test();
}
}
package com.oop.demo06;
public class Application {
//静态的方法和非静态的方法区别很大！
//静态方法： //方法调用只和左边，定义的数据类型有关
//非静态：重写
public static void main(String[] args) {
//方法调用只和左边，定义的数据类型有关
A a = new A();
a.test(); //A
//父类的调用指向了子类
B b = new A(); //子类重写了父类的方法
b.test(); //B
}
}
运行结果
A=>test()
A=>test()
* 总结 ： 重写需要有继承关系，子类重写父类的方法
* 1. 方法名必须相同
* 2. 参数列表必须相同
* 3. 修饰符：范围可以扩大，但不能缩小 ，不能用public
public >Protected >Default >private
* 4. 抛出的异常：范围可以被缩小，但不能扩大
ClassNotFoundException --> Exception(大)
* 5.子类的方法和父类必须要一致，方法体不同！
* 6. 为什么要重写：
1. 父类的功能，子类不一定需要，或者不一定满足
2. Alt + Insert ： override;
3.多态
-
动态编译：类型：可扩展性
-
即同一方法可以根据发送对象的不同而采取多种不同的行为方式。
-
一个对象的实际类型是确定的，但可以指向对象的引用类型有很多。
-
多态存在的条件
* 有继承关系 * 子类重写父类的方法 * 父类引用指向子类对象 -
注意：多态是方法的多态，属性没有多态性
-
代码
package com.oop.demo07;
public class Person {
public void run(){
System.out.println("run");
}
}
package com.oop.demo07;
public class Student extends Person{
@Override
public void run() {
System.out.println("son");
}
public void eat(){
System.out.println("eat");
}
}
package com.oop.demo07;
public class Application {
public static void main(String[] args) {
//一个对象的实际类型是确定的
// new Student();
//new Person();
//可以指向的引用类型就不确定了：父类的引用指向子类
//Student 能调用的方法都是自己的或者继承父类的
Student s1 = new Student();
//Person 父类型 可以指向子类，但是不能调用子类独有的方法
Person s2 = new Student();
Object s3 = new Student();
//对象能执行哪些方法，主要是看对象左边的类型，和右边关系不大
s2.run();
s1.run(); //子类重写了父类的方法，执行子类的方法
s1.eat();
/*
多态注意事项：
1.多态是方法的多态，属性没有多态
2.父类和子类，有联系 类型转换异常！ ClassCastException！
3.存在条件：继承关系，方法需要重写，父类引用指向子类对象！Father f1 = new Son();
1.static 方法，属于类，它不属于实例
2.final 常量；
3.private 方法
这三类无法重写，无法实现多态
*/
}
}
- instanceof (类型转换) 引用类型 判断一个对象是什么类型
- 7.1 instanceof
package com.oop.demo07;
public abstract class Application1 {
public static void main(String[] args) {
//System.out.println(x instanceof y); //能不能编译通过看x和y是否存在父子关系，结果true还得false看x指向的实际类型是否为y的子类型
Object object = new Student();
//Object --> String
//Object --> Person -->Student
//Object --> Person -->Teacher
System.out.println(object instanceof Object); //true
System.out.println(object instanceof Person); //true
System.out.println(object instanceof Student); //true
System.out.println(object instanceof String); //false
System.out.println(object instanceof Teacher); //false
System.out.println("==============================");
Person person = new Student();
System.out.println(person instanceof Object); //true
System.out.println(person instanceof Person); //true
System.out.println(person instanceof Student); //true
//System.out.println(person instanceof String); //编译报错
System.out.println(person instanceof Teacher); //false
System.out.println("============================");
Student student = new Student();
System.out.println(student instanceof Object); //true
System.out.println(student instanceof Person); //true
System.out.println(student instanceof Student); //true
//System.out.println(student instanceof String); //编译报错
//System.out.println(student instanceof Teacher); //编译报错
}
}
- 7.2 类型转换
- 父类引用指向子类的对象
- 把子类转换为父类 ，向上转型 自动转换
- 把父类转换为子类，向下转型，强专辑转换
- 方便方法的调用，减少重复的代码！
package com.oop.demo07;
public class Application3 {
public static void main(String[] args) {
//类型之间的转换： 父 子
//高 --》 低 强制转换
Person obj = new Student();
//obj.go(); //子类student特有的go方法无法执行
//将obj这个对象转换为student类型就可以使用Student类型的方法了
//(Student)obj; //alt + enter
Student obj1 = (Student) obj; //强制转换
obj1.go();
//低 --》 高 自动转换
Student student = new Student();
Person person =student; //自动转换
((Student)person).go(); //强制转换为子类 并执行子类的go方法
}
}
扫一扫
398
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
