10、 java基础——this、面向对象三大特征、修饰符

最新推荐文章于 2024-11-04 20:33:37 发布
最新推荐文章于 2024-11-04 20:33:37 发布
阅读量159 收藏
点赞数
文章标签： java jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Liuyuanhanging/article/details/126670115
版权
本文详细介绍了面向对象编程的四大特征：抽象、封装、继承和多态，并通过实例展示了如何在Java中实现这些概念。包括构造方法的使用、属性的封装、子类继承父类、方法的重写以及多态的应用。此外，还讨论了数据类型的转换、instanceof关键字的使用以及对象创建的流程。
摘要由CSDN通过智能技术生成

this

  • 表示当前对象

        public Phone(String brand, double price) {
        this.brand = brand;
        this.price = price;
    }

  • 调用构造方法

        public Phone(String brand, double price, int memory) {
        
        this(brand, price);
        this.memory = memory;
    }
package com.qfedu;
​
public class Demo01 {
    
    public static void main(String[] args) {
        Phone phone = new Phone();
        phone.brand = "huawei";
        phone.price = 8800;
        phone.memory = 256;
        
        
        /*
         * 有参构造方法，就一个目的在创建对象时，为属性赋值
         */
        Phone phone2 = new Phone("oppo",3400, 128);
        Phone phone3 = new Phone("ovvo",3800, 258);
        
        System.out.println(phone2.brand+","+phone2.price);
        
    }
    
}
​
/*
 * this 朕  当前对象
 *  通过this.属性名  操作当前对象的属性
 * this(参数列表)  调用当前类的构造方法
 */
class Phone {
    
    String brand;
    double price;
    int memory;
    
    public Phone() {
        System.out.println("无参构造方法---");
    }
    
    public Phone(String brand, double price, int memory) {
        
        this(brand, price);
        this.memory = memory;
        
    }
    
    public Phone(String brand, double price) {
        this.brand = brand;
        this.price = price;
    }
    
    
    public void call() {
        System.out.println("打电话");
    }
    
}

面向对象特征

抽象，封装，继承，多态

  • 抽象

    • 抽象是过程，抽取出一个类事物的特性

  • 封装

    • 属性私有

  • 继承

    • 子类可以继承父类的属性及方法

  • 多态

    • 重写，父类的引用指定子类的对象，执行重写后的方法，各自执行各自的方法

封装

属性私有

添加get set方法

public class Demo{
    public static void main(String[] args) {
        Pig pig = new Pig();
        pig.color = "各色";
    }
}

public class Pig{
    
    private String color;
    private double weight;
    private int month;
    
    
    public void setColor(String color) {
        this.color = color;
    }
    
    public String getColor() {
        return color;
    }
    
}
​
Pig pig = new Pig();
pig.setColor("黑色");
​
String color = pig.getColor();

继承

语法：

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

  • 子类继承父类所有的非私有的属性和方法

package com.qfedu.p2;
​
//宠物类
public class Pet {
​
    //定义宠物都共有的特性
    String variety;
    String color;
    int month;
}
package com.qfedu.p2;
​
/*
 * Pet 宠物类
 * Cat 猫类
 * 
 * 如果表示猫是宠物这件事情  就是extends 来表示
 * 
 * Cat extends Pet
 * 
 * 
 * 继承的类  Cat   叫做子类
 * 被继承的类 Pet  叫做父类
 * 
 * 子类继承了父类所有的属性
 */
public class Cat extends Pet{
​
    
    //猫这类宠物，特有的属性
    String character; 
}
package com.qfedu.p2;
​
//狗是宠物
public class Dog extends Pet{
​
    //狗所特有的属性
    double legLength;  
}
package com.qfedu.p2;
​
public class Test02 {
​
    public static void main(String[] args) {
        
        /*
         * 子类继承父类非私有的属性
         */
        Cat cat = new Cat();
        cat.variety = "加菲猫";
        cat.color = "花色";
        cat.month = 30;
        
        cat.character = "傲娇";
        
        Dog dog = new Dog();
        dog.variety = "金毛";
        dog.color = "金色";
        dog.month = 4;
        dog.legLength = 30;
        
        /*
         * 鸡类       品种   颜色  重量      是否打鸣
         * 鸭类                品种   颜色  重量      鸭掌大小
         * 家禽类
         */
        
    }
}

修饰符

 

package com.qfedu.p3;
​
public class Computer {
​
    private String brand;
    
    //不添加任何修饰符，表示默认default
    double price;
    
    protected String color;
    
    public String cpu;
    
    
    public void print() {
        System.out.println(brand + price+color+cpu);
    }
    
}
​
package com.qfedu.p3_2;
​
import com.qfedu.p3.Computer;
​
public class Pc extends Computer{
​
    
    public void printSelf() {
        System.out.println(color+cpu);
    }
}
​
package com.qfedu.p3;
​
public class Test03 {
​
    public static void main(String[] args) {
        Computer c = new Computer();
        // c.brand = "acer";
        
        c.price = 3222.0;
        c.color = "黑色";
        c.cpu = "i11";
    }
}
​
package com.qfedu.p3_2;
​
import com.qfedu.p3.Computer;
​
public class Test04 {
​
    public static void main(String[] args) {
        Computer c = new Computer();
        c.cpu = "";
    }
}

重写

父类的方法不能满足子类的需要，所有子类可以重新写父类的方法

  • 如果不重写，就会调用父类的方法

  • 重写后，就会调用子类重写后的方法

package com.qfedu.p4;
​
//作为父类，定义了call方法，表示所有的动物都会叫
public class Animal {
    
    String variety; 
​
    public void call() {
        System.out.println("动物叫---");
    }
}
​

package com.qfedu.p4;
​
public class Chicken extends Animal{
​
    
    public void call() {
        System.out.println("鸡叫-咕咕咕咕");
    }
    
}

package com.qfedu.p4;
​
public class Duck extends Animal {
​
    
    /*
     * 父类的方法，不能满足子类的需求
     * 所有把父类的方法重写（重新写），修改了方法体
     */
    public void call() {
        System.out.println("鸭叫 - 嘎嘎嘎嘎");
    }
    
}

package com.qfedu.p4;
​
public class Test05 {
​
    public static void main(String[] args) {
        /*
         * 子类会继承父类非私有的方法和属性
         */
        
        Chicken c = new Chicken();
        c.variety = "老母鸡";
        
        
        Duck d = new Duck();
        d.variety = "烤鸭";
        
        c.call();
        d.call();
    }
}
    /*
         * 人            吃饭
         * 中国人      用筷子吃
         * 印度人      有手吃
         */
package com.qfedu.p2;
​
public class Text02 {
​
    public static void main(String[] args) {
        Chinese chinese=new Chinese();
        
        chinese.human="中国人";
        
        Indian indian=new Indian();
        
        indian.human="印度人";
        
        chinese.eat();
        indian.eat();
    }
}
         
package com.qfedu.p2;
​
import com.qfedu.p2.Human;
​
public class Chinese  extends Human{
​
    public void eat() {
        System.out.println("中国人吃饭用筷子");
    }
}
​
package com.qfedu.p2;
​
public class Human {
    String human;
    public void eat() {
        System.out.println();
    }
​
}
​
package com.qfedu.p2;
​
import com.qfedu.p2.Human;
​
public class Indian  extends Human{
    
    public void eat() {
        System.out.println("印度人吃饭用手");
    }
​
    
}
​

super

  • 在子类中，可以通过super.方法名(); 调用父类的方法

  • 在子类中，可以通过super.属性名 设置或获取父类非私有的属性

  • 在子类中，可以通过super() 调用父类的构造方法

每一个子类的构造方法的第一行默认都是super();

默认调用的是父类的无参构造方法

也可以不默认调用父类的无参构造方法，自定义调用的构造方法，但是必须定义在第一行

记住：任何时候都给一个类定义一个无参构造方法

package com.qfedu.p5;
​
//作为父类
public class A {
    
    //属性
    private String a;
    
    String b;
    
    //构造方法
    public A() {
        
    }
    
    public A(String a) {
        this.a = a;
    }
    
    //实例方法
    public void a() {
        System.out.println("A a()  start");
    }
    
    //打印属性方法
    public void print() {
        System.out.println("a="+a+",b="+b);
    }
​
}
​
package com.qfedu.p5;
​
//B作为子类
public class B extends A{
​
    /*
     * super.方法名();  调用父类的方法
     */
    public void a() {
        /* System.out.println("A a() start "); */
        super.a();                                  //调用父类的方法
        
        System.out.println("B a()  end"); 
    }
    
    /*
     * super.属性名   可以获取父类的非私有的属性
     * 
     * super(实参);  调用父类的构造方法
     */
    public B(String a, String b) {
        super(a);        //调用父类的构造方法
        
        super.b = b;     //调用父类的非私有的属性
    }
    
    
}
package com.qfedu.p5;
​
public class Test05 {
​
    public static void main(String[] args) {
        B b = new B("jackma", "pony");//a=jacket b=pony
        b.print();
    }
}

子类对象创建流程：

  • 创建一个父类对象

    • 为属性分配空间

    • 赋默认值

    • 调用构造方法

  • 创建子类对象

    • 为属性分配空间

    • 赋默认值

    • 调用构造方法

  • 把子类对象地址赋值给变量

 

多态

  • 子类重写父类的方法

  • 父类的引用指向子类的对象

  • 执行相同的方法

package com.qfedu.p8;
​
//宠物类
public class Pet {
​
    public void call() {
        System.out.println("宠物叫-----");
    }
    
}
package com.qfedu.p8;
​
public class Cat extends Pet{
​
    public void call() {
        System.out.println("喵喵喵-----");
    }
    
}
package com.qfedu.p8;
​
//狗是宠物
public class Dog extends Pet{
​
    public void call() {
        System.out.println("汪汪汪-----");
    }
    
}
package com.qfedu.p8;
​
public class Test02 {
​
    public static void main(String[] args) {
        
        /*
         * 父类的引用指向子类的对象
         * 然后相同的方法，出现不同结果
         * 
         * 多态
         */
        
        //有一只宠物是一只猫
        Pet p1 = new Cat();
        
        
        //有一只宠物是一只狗
        Pet p2 = new Dog();
        
        p1.call();
        p2.call();
        
    }
}

数据类型转化

  • 数据类型往上转，装箱（自动转化）

Cat c = new Cat();   
Pet p = c;
​
int i = 5;
double d = i;

  • 数据类型往下转，拆箱（强制转化）

    /*
    * 数据类型范围变小了，数据类型往下转， 拆箱     （强制转化）
    * 想要执行子类的方法（子类一定比父类强大）
    * 
    * 子类数据类型 c2 = (子类数据类型)父类的引用;
    */
    Pet p = new Cat();
​
    Cat c2 = (Cat)p;
    c2.catchMice();

instanceof关键字

可以通过instanceof关键字，判断该变量的数据类型，返回一个boolean类型数据

  • 是 返回true

  • 不是 返回false

boolean b = 变量 instanceof 数据类型;
package com.qfedu.p9;
​
​
public class Demo01 {
​
    public static void main(String[] args) {
        /*
         * 数据类型转化
         * 
         * 数据类型范围变大了，数据类型往上， 装箱     （自动转化）
         * 
         * 只能执行父类自己的方法
         */
        Cat c = new Cat();   
        Pet p = c;
        
    
        
        int i = 5;
        double d = i;
        
        
        /*
         * 数据类型范围变小了，数据类型往下转， 拆箱     （强制转化）
         * 想要执行子类的方法（子类一定比父类强大）
         * 
         * 子类数据类型 c2 = (子类数据类型)父类的引用;
         */
        Cat c2 = (Cat)p;
        c2.catchMice();
        
        
        
        //有只宠物是只狗
        Pet p2 = new Dog();
        
        
        /*
         * 在进行强制类型转化之前，可以对变量的的数据类型进行判断
         * 
         * 变量名  instanceof  目标数据类型;
         * - true
         * - false
         */
        boolean isCat = p instanceof Cat;
        
        System.out.println(isCat);
        
        if(isCat) {
            Cat c3 = (Cat)p;
            c3.catchMice();
        }
        
    }
}
​
class Pet {
​
    public void call() {
        System.out.println("宠物叫-----");
    }
    
}
​
class Dog extends Pet{
​
    public void call() {
        System.out.println("汪汪汪-----");
    }
    
}
​
class Cat extends Pet{
​
    public void call() {
        System.out.println("喵喵喵-----");
    }
    
    public void catchMice() {
        System.out.println("逮老鼠");
    }
    
    
}
Liuyuanhanging
关注
19、Java面向对象——面向对象的三大特征、private权限修饰符、get()/set()方法、封装
CSDN_Loveletter的博客
10-11 1184
把对象的所有组成部分组合在一起，封装定义程序如何引用对象的数据，封装实际上是使用方法将类的数据隐藏起来，控制用户对类的修改和访问数据的程度。适当的封装可以让程序代码更容易理解和维护，也加强了程序代码的安全性。
对java面向对象的三大特征的理解_Java面向对象三大特征
weixin_35569158的博客
02-27 856
一、面向对象特征一：封装性1.为什么要引入封装性？我们程序设计追求“高内聚，低耦合”。高内聚：类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅对外暴露少量的方法用于使用。隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。2.问题引入：当我们创建一个类的对象以后，我们可以通过...
Java 基础面试题——面向对象
代码星辰的博客
02-17 2386
本文记录了 Java 中与面向对象相关的面试题。
Java基础——面向对象编程基础（类及类的成员）
Yc317900的博客
08-12 1037
①Java类及类的成员：属性、方法、构造器、代码块、内部类②面向对象特征：封装、继承、多态③一些关键字的使用：this、super、package、import、static、final、interface、abstract等将一个类A定义在另一个类B里面，里面的那个类A就称为内部类。当一个事物A的内部，还有一个部分需要一个完整的结构B进行描述，而这个内部的完整的结构B又只为外部事物A提供服务，不在其他地方单独使用，那么整个内部的完整结构B最好使用内部类。
java基础总结——java面向对象
小白龙白龙马的博客
05-06 1785
面向对象 程序的三种基本结构：顺序结构、选择结构、循环结构。 面向对象程序设计方法的基本思想是使用类、对象、继承、封装、消息等基本概念进行程序设计。 成员变量(状态数据)+方法(行为)= 类定义 面向对象的基本特征 面向对象方法具有三个基本特征：封装(Encapsulation)、继承(Inheritance)和多态(Polymorphism)。 封装：指将对象的实现细节隐藏起来，然后通过一些公...
【Java基础】——面向对象:封装
lingxw的博客
01-30 1317
方法是类或对象行为特征的抽象，用来完成某个功能操作。在某些语言中也称为函数或过程。将功能封装为方法的目的是，可以实现代码重用，简化代码。Java里的方法不能独立存在，所有的方法必须定义在类里。比如：Math类：sqrt()\random() …Scanner类：nextXxx() …Arrays类：sort() \ binarySearch() \ toString() \ equals() \ …
JAVA面向对象三大特征————封装
weixin_59369438的博客
06-19 729
需要指出的是，包名与文件目录结构一致是针对.class文件而言的，对于源代码文件没有这一要求，但是通常也将源代码文件放到与包名一致的目录结构中。（3）类的全部或部分方法的访问权限为public，类的公有方法是类对外开放的接口，供外部代码使用类的功能。类的私有方法通常是辅助方法实现部分功能，供类的公有方法调用。（1）将类的属性的访问权限设置为private，提供访问权限为public的set和get方法。如果在类的外部可以随意访问类的成员，那将属性和方法放到类中就没有意义了。封装是面向对象的三大特征之一。
Java基础——面向对象
qq_43450758的博客
12-03 630
用很通俗易懂的说法说一下面向对象。。。
Java面向对象篇(二)——三大特征
qq_43355770的博客
04-26 1210
本文章主要讲面向对象三大特征，非常适合小白阅读。
JAVA基础——数组、面向对象
weixin_56451428的博客
02-15 1531
JAVA基础包含数组+面向对象。视频学习参考狂神说java
java基础之面向对象编程
02-20
Java是一种广泛使用的面向对象编程语言，其面向对象的特性使得代码更加模块化、易于理解和维护。面向对象编程（OOP）的核心概念包括类、封装、继承和多态性。 1. **类**： 类是面向对象编程的基础，它是创建对象的...
Java面向对象浅谈——面向对象三大特征：封装、继承、多态
Meqtix的博客
09-03 315
面向对象高级继承继承格式子类实例化内存分析super详解重写（Override）重写（Override）规则重写（Override）与重载（Overload）的区别final关键字作用抽象类概念格式抽象方法不能被实例化常见问题抽象类和普通类的区别接口概念面向接口编程思想全局常量和抽象方法的简写接口的实现 implements接口的继承注意接口和抽象类的区别 继承 继承是Java面对对象很重要的一部分，给类进行等级层次的划分，即分为父类和子类，父类拥有的特征和行为，能被子类继承。 继承格式 class 子类
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 455
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 947
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
服务器虚拟化
Hellc007的博客
10-30 990
服务器虚拟化是一种将物理服务器的计算资源分割为多个独立虚拟环境的技术，通过软件层将底层硬件资源抽象化并在上层构建多个虚拟机（Virtual Machine, VM）。每个虚拟机运行独立的操作系统和应用程序，相互之间不受干扰，具备类似于物理服务器的功能。这种技术使得一台物理服务器能够承担多台虚拟服务器的角色，从而极大地提升了硬件资源的利用率。服务器虚拟化的概念最早可追溯到20世纪60年代IBM大型机时代，当时虚拟化被用来将大型机的资源分配给多个任务，使得企业在有限的资源下能够同时运行多个应用。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 1011
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
spring循环依赖解决方式
最新发布
qq_36400213的博客
11-04 489
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
SpringSession源码分析
lkr_lkr的博客
11-01 335
默认对常规Session的理解和使用，如何使用Set-Cookie。
Java编程：从基础到进阶——面向对象与环境配置
第1章介绍Java概述，首先阐述了面向对象程序设计的基本概念，这是Java编程的基础，强调了Java语言的特性，如平台无关性、安全性、健壮性和可移植性。此外，还涉及Java运行开发环境的配置，包括常用的java命令和开发...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值