8.2 Java面向对象之面向对象的三大特征

最新推荐文章于 2024-08-12 16:47:32 发布
最新推荐文章于 2024-08-12 16:47:32 发布
阅读量204 收藏
点赞数
分类专栏： 1.JAVA学习 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43445382/article/details/122116292
版权

4.1 封装

  • 该露的露，该藏的藏
    • 我们程序设计要追求“高内聚，低耦合”。
    • 高内聚：类的内部数据操作细节自己完成，不允许外部干涉;
    • 低耦合：仅暴露少量的方法给外部使用。
  • 封装（数据的隐藏)
    • 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
  • 记住这句话就够了:属性私有，get/set
package com.lanseyutou.oop.Demo04;

//类   private:私有
public class Student {

    //属性私有
    private String name;//名字
    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 选择  setter/getter/setter and getter
    public void setId(int id) {
        this.id = id;
    }

    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 = age;
        }else{
            this.age = 3;
        }

    }

}

package com.lanseyutou.oop.Demo04;

public class Application {

/*
1.提高程序安全性，保护数据
2.隐藏代码的实现细节
3.统一接口
4.系统可维护性增加了
 */

    public static void main(String[] args) {
        Student s1 = new Student();

        s1.setName("蓝色芋头");
        System.out.println(s1.getName());

        s1.setAge(123);//年龄不合法
        System.out.println(s1.getAge());

        s1.setAge(70);
        System.out.println(s1.getAge());
    }
}

4.2 继承

  • 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
  • extends的意思是“扩展”。子类是父类的扩展。
//person  人  父类
public class Person {
}

//Student is  Person   子类
//子类继承了父类，就会拥有父类的全部方法（public）
public class Student extends Person {
}

//Teacher is Person   子类
public class Teacher extends Person {
}
  • JAVA中类只有单继承，没有多继承!
  • 继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。
  • 继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。
  • 子类和父类之间,从意义上讲应该具有"is a"的关系.

4.2.1 object类

  • 在java中所有的类，都默认直接或间接的继承object类（Ctrl+H）(私有的无法被继承：private)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pNwzumQf-1640263798708)(F:\研究生阶段\JAVA\8.Java面向对象\picture\image-20211209202150338.png)]

4.2.2 super

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-caOBrlo1-1640263798709)(F:\研究生阶段\JAVA\8.Java面向对象\picture\image-20211209204043976.png)]

public class Person {

    protected String name ="lzk";
}

public class Student extends Person {

    protected String name = "lanseyutou";

    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }

}

public class Application {

    public static void main(String[] args) {

        Student student = new Student();
        student.test("蓝色芋头");
    }
}

/*
蓝色芋头
lanseyutou
lzk
*/

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SGyJzO4S-1640263798711)(F:\研究生阶段\JAVA\8.Java面向对象\picture\image-20211209204819343.png)]

public class Person {

    public void print(){
        System.out.println("Person");
    }
}

public class Student extends Person {

    public void print(){
        System.out.println("Student");
    }

    public void test1(){
        print();
        this.print();
        super.print();
    }
}

public class Application {

    public static void main(String[] args) {
        student.test1();
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-24cPRW3x-1640263798712)(F:\研究生阶段\JAVA\8.Java面向对象\picture\image-20211209205839098.png)]

public class Person {

    public Person(){
        System.out.println("Person无参执行了");
    }
}    

public class Student extends Person {

    public Student(){
        //⬇⬇⬇⬇⬇隐藏代码：调用了父类的无参构造
        super();//调用父类的构造器，必须要在子类构造器的第一行
        System.out.println("Student无参执行了");
    }
}    

public class Application {

    public static void main(String[] args) {
    }
}

/*
Person无参执行了
Student无参执行了
*/
  • super注意点:
  1. super调用父类的构造方法，必须在构造方法的第一个
  2. super 必须只能出现在子类的方法或者构造方法中!
  3. super和 this 不能同时调用构造方法!
  • Vs this:
    • 代表的对象不同:
      • this:本身调用者这个对象
      • super:代表父类对象的应用
    • 前提
      • this:没哟继承也可以使用
      • super:只能在继承条件才可以使用
    • 构造方法
      • this() :本类的构造
      • super():父类的构造!

4.2.3 方法重写

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nHU1M89T-1640263798714)(F:\研究生阶段\JAVA\8.Java面向对象\picture\image-20211209213152990.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ddoamI3C-1640263798716)(F:\研究生阶段\JAVA\8.Java面向对象\picture\image-20211209213423121.png)]

package com.lanseyutou.oop.Demo06;

//重写都是方法的重写，跟属性无关
public class A extends B {
    //ctrl+o
    //Override ：重写
    @Override //注解：有功能的注释
    public void test() {
        System.out.println("A=>test()");
    }
}

package com.lanseyutou.oop.Demo06;

//重写都是方法的重写，跟属性无关
public class B {
    public void test(){
        System.out.println("B=>test()");
    }
}

package com.lanseyutou.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>Protected>Default>private
    4. 抛出的异常:范围，可以被缩小，但不能扩大; ClassNotFoundException --> Exception(大)
  • 重写，子类的方法和父类必要一致;方法体不同!
  • 为什么需要重写:
    • 父类的功能，子类不一定需要， 或者不一定满足!
  • 不能重写的情况：
    • static 方法，属于类，不属于实例
    • final 常量
    • private 私有方法

4.3 多态

4.3.1 多态基础

  • 即同一方法可以根据发送对象的不同而采用多种不同的行为方式。
  • 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
  • 多态存在的条件
    • 有继承关系
    • 子类重写父类方法
    • 父类引用指向子类对象
  • 注意:
    • 多态是方法的多态，属性没有多态性。
    • 子类和父类 有联系 类型转换异常（ClassCastExpectation）
    • 存在条件：继承关系；方法需要重写；父类引用指向子类对象
public class Person {

    public void run(){
        System.out.println("run");
    }

}

public class Student extends Person {

    @Override
    public void run() {
        System.out.println("son");
    }

    public void eat(){
        System.out.println("eat");
    }
}

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();
        //s2.eat();  Person类不能调用
    }
}

/*
son
son
*/

4.3.2 instanceof

instanceof（类型关系） 引用类型，判断一个对象是什么类型

public class Person {
}

public class Student extends Person{
}

public class Teacher extends Person{
}

public class Application {
    public static void main(String[] args) {

        //Object > String
        //Object > Person > Teacher
        //Object > Person > Student
        Object object = new Student();

        System.out.println(object instanceof Student);//true
        System.out.println(object instanceof Person);//ture
        System.out.println(object instanceof Teacher);//false
        System.out.println(object instanceof Object);//true
        System.out.println(object instanceof String);//false

        System.out.println("============");

        Person person = new Student();

        System.out.println(person instanceof Student);//true
        System.out.println(person instanceof Person);//ture
        System.out.println(person instanceof Teacher);//false
        System.out.println(person instanceof Object);//true
        //System.out.println(person instanceof String);//编译报错！

        System.out.println("============");

        Student student = new Student();

        System.out.println(student instanceof Student);//true
        System.out.println(student instanceof Person);//ture
        //System.out.println(student instanceof Teacher);//编译报错！
        System.out.println(student instanceof Object);//true
        //System.out.println(student instanceof String);//编译报错！
    }
}

4.3.3 类型转换

  • 父类<----->子类
public class Person {
    public void run(){
        System.out.println("run");
    }
}

public class Student extends Person {
    public void go(){
        System.out.println("go");
    }
}

public class Application {
    public static void main(String[] args) {

        //高                    低
        Person obj = new Student();

        //student将这个类型转换为Student类型，我们就可以使用Student类型的方法了

        Student student = (Student) obj;
        student.go();
        //((Student)obj).go();

        System.out.println("==========");

        //子类转换为父类可能会丢失一些自己本来的方法
        Student s1 = new Student();
        s1.go();
        Person person = s1;

    }
}
  1. 父类引用指向子类的对象
  2. 把子类转化为父类，向上转型
  3. 把父类转化为子类，向下转型，强制转换
  4. 方便方法调用，减少重复的代码。简洁

4.4 补充汇总：static

//static
public class Student {
    private static int age;//静态变量：属于类
    private double score;//非静态变量：属于对象

    public void run(){

    }

    public static void go(){

    }

    public static void main(String[] args) {
        Student s1 = new Student();

        System.out.println(Student.age);
        System.out.println(s1.score);
        System.out.println(s1.age);

    }
}

public final class Person { //用了final无法再被继承
    //第二个执行 ：  可以用来赋初始值
    {
        //（匿名）代码块
        System.out.println("匿名代码块");
    }
    //第一个执行，跟类一起执行,且只执行一次
    static {
        //静态代码块
        System.out.println("静态代码块");
    }
    //第三个执行
    public Person(){
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println("===========");
        Person person2 = new Person();
    }

}
/*
静态代码块
匿名代码块
构造方法
===========
匿名代码块
构造方法
*/

//静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;

public class Test {

    public static void main(String[] args) {
        System.out.println(Math.random());
        System.out.println(random());
        System.out.println(PI);
    }

}

蓝色芋头的干饭生活
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java面向对象程序设计 第3版_Java面向对象程序设计（第3版）-聂哲
weixin_32565397的博客
03-01 2237
前辅文第1章 打开Java之门1.1 为什么要学习Java1.1.1 Java语言产生1.1.2 Java语言应用场景1.2 什么是Java1.2.1 什么是Java语言1.2.2 什么是Java平台1.2.3 Java 7的新特性1.3 怎样学习Java语言1.3.1 Java集成开发工具介绍1.3.2 Java集成开发工具比较和选择1.3.3 创建Java开发环境1.3.4 学习路径规划1.3...
JAVA面向程序对象课程_Java面向对象程序设计知识图谱（20张）及教学大纲
weixin_40003767的博客
02-26 927
原标题：Java面向对象程序设计知识图谱(20张)及教学大纲1.总体概述 2.Java入门 3.数据类型与变量 4.运算符 5.控制流程 6.数组 7.字符串 8.类与对象 9.继承与多态 10.常用核心类 11.接口与Lambda表达式 12.枚举、注解与内部类 13.泛型与集合 14.异常与断言 15.并发编程 16.JDBC数据库 17.输入输出 18.网络编程 19.JavaFX基础 20...
java面向对象
黎小小的博客
08-21 4万+
本文内容是根据毕晓东老师的视频教程总结而得。包括面向对象概念、类与对象的关系、封装、构造函数、this关键字、static关键字、单例设计模式、继承、多态、内部类、异常、包等java基础知识。 1、面向对象 面向对象是相对面向过程而言 面向对象和面向过程都是一种思想 面向过程强调的是功能、行为 面向对象：将功能封装进对象，强调具备了功能的对象 面向对象是基于面向过程的 面向过程例子： ...
JAVA 面向对象 类 对象 封装
热门推荐
程序媛泡泡的博客
05-07 6万+
面向对象概念 面向对象其实是一种编程思想，通过它可以把生活中复杂的事情变得简单化，从原来的执行者变成了指挥者。 面向对象是基于面向过程而言的。 面向过程强调的是过程,比如: 打开冰箱门 2. 把大象放进去 3. 关上冰箱门 面向对象强调的是结果,比如: 什么样的冰箱?什么样的大象?谁负责把大象装进去? 而不是关注那个负责的人怎么把大象装冰箱里. 衣服脏了，直接让女盆友去处理,等着穿干净的就可以了。你不关注中间的过程,只要找好对象就可以了~ 再比如.我们想吃一道菜,无需考虑是怎么传菜,怎么做菜的,只需点菜即
java面向对象程序课本,Java面向对象程序设计
weixin_35710158的博客
03-10 350
出版说明前言第1篇 Java程序设计基础第1章 Java语言入门1.1 Java的诞生1.2 Java的特点1.3 Java程序的开发工具1.4 Java运行环境1.4.1 JDK的下载与安装1.4.2 配置Java运行环境1.4.3 JDK 6u19开发工具包的目录结构1.4.4 JDK、JRE和JVM之间的关系1.5 Java程序组成1.6 Java程序的开发步骤1.7 Java程序分类1.7...
JAVA面向对象知识点汇总
CJY_971028的博客
01-23 593
文章目录JAVA面向对象基础一、面向对象思想1. 概述1.1 三大思想1.2 三大特征2. 类与对象2.1 两者关系2.2 类的定义格式2.3 属性与方法2.4 对象的创建与使用3. 创建对象内存分析3.1 栈3.2 堆3.3 方法区3.4 PC寄存器3.5 本地方法栈4.构造方法(构造器)4.1 回顾对象创建4.2 构造方法概述4.3 定义格式4.4 构造方法设计4.5 方法的重载4.6 构造方法重载4.7 匿名对象5.封装5.1 示例5.2 this关键字5.3 static关键字5.4 代码块5.5
Java-05_面向对象（上）
m0_62036548的博客
05-29 1043
Java-05_面向对象
Java超全的面向对象复习笔记
HelloWorld
08-04 1084
文章目录Java 面向对象学习1. 类与对象1.1 面向对象简介1.2 类与对象简介1.3 类与对象的使用*1.4 对象内存分析*1.5 对象引用分析1.6 引用与垃圾产生分析2 深入分析类与对象2.1 成员属性封装2.2 构造方法和匿名对象3 this关键字3.1 this调用本类属性3.2 this调用本类方法3.3 简单Java类4 static关键字4.1 声明static属性4.2 声明static方法5 代码块5.1 普通代码块5.2 构造代码块5.3 静态代码块6 面向对象案例分析7 数组7.
Java-06_面向对象（中）
m0_62036548的博客
06-04 945
面向对象
Java面向对象各个知识点的总结
weixin_44525733的博客
04-21 847
Java面向对象各个知识点的总结前言补充一、面向对象编程概述二、类的成员1—成员变量三、类的成员2—方法5.1 方法介绍&理解5.2 方法的重载(overload)5.3 可变个数形参的方法5.4 方法的参数传递机制：值传递(重点、难点)5.5 递归方法四、类的成员3—构造器/构造方法五、类的成员4—代码块六、类的成员5—内部类七、面向对象特征1—封装八、面向对象特征2—继承extends8.1 继承性介绍8.2 方法重写8.3 Object超类九、面向对象特征3—多态（较难）十、关键字的使用。
poo-java-netbeans：NetBeans IDE 8.2中的面向对象的Java应用程序
02-15
Orientada a ObjetosEsse projeto arange agunscódigosconceituais sobre orientada a objetos em JAVA。 康乃馨类对象资产属性可视化Métodosgetter，二传手封装Objetos compostos entre objetos 锻炼实践Herança...
79.LabVIEW 面向对象程序设计的简介.doc-综合文档
05-23
面向对象的三大核心特性在LabVIEW中得到了体现： 1. **封装**：封装是将相关的数据和操作组合在一起，形成一个独立的实体，称为类。在LabVIEW中，类类似于Cluster，但比Cluster更进阶，因为Cluster仅包含数据，而类...
77.利用LabVIEW工程库实现面向对象编程.doc-综合文档
05-23
然而，需要注意的是，LabVIEW 8.2之后的版本进一步增强了对面向对象编程（LVOOP，LabVIEW Object-Oriented Programming）的支持，提供了更完善的类、继承、多态等特性。因此，使用更新版本的LabVIEW时，可以直接利用...
JAVA 面向对象程序设计第8章 内部类和泛型.pptx
07-05
8.2 静态内部类 静态内部类与非静态内部类的主要区别在于，静态内部类可以不依赖于外部类的实例而被创建。它就像普通的顶级类一样，只是物理位置在外部类中。静态内部类不能直接访问外部类的非静态成员，但可以通过...
Java面向对象程序设计第08章_Java-IO流.ppt
09-30
Java面向对象程序设计第08章_Java-IO流 Java 中的输入输出流（IO）是计算机输出 / 输入的接口。Java 的核心库 java.io 提供了全面的 IO 接口，包括文件读写、标准设备输出等等。Java 中的 IO 是以流为基础进行输入...
springboot民办高校科研项目管理系统-计算机毕业设计源码54009
VX_DZbishe的博客
08-11 321
论文主要是对基于springboot的民办高校科研项目管理系统进行了介绍，包括研究的现状，还有涉及的开发背景，然后还对系统的设计目标进行了论述，还有系统的需求以及整个的设计方案，对系统的设计以及实现，也都论述的比较细致，最后对基于springboot的民办高校科研项目管理系统进行了一些具体测试。本次报告，首先分析了研究的背景、作用、意义，为研究工作的合理性打下了基础。
SpringBoot快速入门（手动创建）
m0_74124657的博客
08-11 310
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
软件测试需要具备的基础知识【功能测试】---后端知识（三）
最新发布
yang_xs的博客
08-12 855
为了更好的学习软件测试的相关技能，需要具备一定的基础知识。需要学习的基础知识包括：1、计算机基础2、前端知识3、后端知识4、软件测试理论后期分四篇文章进行编写，这是第三篇CS架构BS架构效率：c/s效率高，某些内容已经安装在系统中了，b/s每次都要加载最新的数据升级：b/s无缝升级；c/s删除老版本再安装新版本安全：c/s更安全，需要安装、注册、登录；b/s有浏览器即可使用，安全程度低开发成本：b/s成本低；c/s需要不同的系统要不同的开发人员，成本高。
集合（1）
supercool7的博客
08-12 451
表示不同的类型集合，Collection、Map、List、Set、Queue、Deque等，以及辅助性质的接口Iterator、LinkIterator、Comparator、Comparable这些接口是为迭代和比较元素而准备。对接口的具体实现，主要常用的有：ArrayList、LinkedList、HashMap、HashSet、TreeMap等等。理解Java集合体系可以从三个层次：最上层的接口、中间的抽象类、最后的实现类。是所有集合框架的根接口，包含了对集合进行基本操作的方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值