Java面向对象(高级)

已于 2024-10-05 15:57:45 修改
阅读量1.1k 收藏 18
点赞数 19
分类专栏： # JavaSE入门篇 文章标签： java 开发语言 后端
于 2024-09-11 21:53:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_70587611/article/details/142151050
版权

文章目录

前言

众里寻他千百度，蓦然回首，那人却在，灯火阑珊处。    — 辛弃疾 《青玉案·元夕》
在这里插入图片描述

1 static和final关键字

1.1 static关键字

  • 在Java中，被static关键字修饰的成员是静态成员（属于类），没有被static修饰的成员是实例成员（属于对象）

  • static关键字可以用来修饰成员变量和成员方法

              有static修饰的变量为静态变量，也称为类变量；

              无static修饰的方法为静态方法，也称为类方法

  • 静态成员：类名访问；实例成员：对象访问。

1.1.1 静态变量

       静态变量是有static关键字修饰的变量

       1. 定义和使用

// 1.定义
修饰符 static 数据类型 变量名 = 初始值；
// 2.使用
类名.静态变量

       2. 代码示例

package com.syh;

public class Esther {
    // 1.定义静态变量
    public static String country = "中国";

    public static void main(String[] args) {
        // 2.使用静态变量
        System.out.println(Esther.country);
    }
}

1.1.2 实例变量

       实例变量是没有static关键字修饰的变量，对于实例变量，只需要了解其访问格式即可。

格式：对象.实例变量

1.1.3 静态方法

       静态方法是有static关键字修饰的方法

       1. 定义及使用

// 1.定义
修饰符 返回值类型 方法名(参数){
    方法体；
}
// 2.使用
类名.静态变量

       2. 代码示例

package com.syh;

public class Esther {
    public static void main(String[] args) {
        /**
         * 静态方法调用
         */
        Esther.print();
    }
    /**
     * 静态方法
     */
    public static void print() {
        System.out.println("少年辛苦终身事，莫向光阴堕寸功！");
    }
}

1.1.4 实例方法

       实例方法是没有static关键字修饰的方法，对于实例方法，只需要了解其访问格式即可。

格式：对象.实例方法

1.2 final关键字

1.2.1 概述

final关键字： 表示修饰的内容不可改变，最终的含义。可以用于修饰类、方法和变量。

  • 类：被修饰的类，不能被继承。
  • 方法：被修饰的方法，不能被重写。
  • 变量：被修饰的变量，有且仅能被赋值一次。

1.2.2 使用方式

1. 修饰类

       final修饰的类，不能被继承。代码示例如下：

final class Fu {
}
// class Zi extends Fu {} // 报错,不能继承final的类

2.修饰方法

       final修饰的方法，不能被重写。代码示例如下：

class Fu2 {
	final public void show1() {
		System.out.println("Fu2 show1");
	}
	public void show2() {
		System.out.println("Fu2 show2");
	}
}

class Zi2 extends Fu2 {
//	@Override
//	public void show1() {
//		System.out.println("Zi2 show1");
//	}                                   // 报错，不能被重写
	@Override
	public void show2() {
		System.out.println("Zi2 show2");
	}
}

3.修饰变量(局部变量)

       final关键字修饰局部变量，被final修饰后，只能赋值一次，代码示例如下：

public class FinalDemo1 {
    public static void main(String[] args) {
        // 声明变量，使用final修饰
        final int a;
        // 第一次赋值 
        a = 10;
        // 第二次赋值
        a = 20; // 报错,不可重新赋值
    }
}

4.修饰变量(成员变量)

       final关键字修饰成员变量，被final修饰后，只能赋值一次，代码示例如下：

public class Student {
    final int num = 10;
}

注意：被final修饰的常量名称，一般都有书写规范，所有字母都大写。

2 Java中的包

       包名一般是公司域名的倒写。例如：黑马是www.itheima.com,包名就可以定义成com.itheima.技术名称。

2.1 导包

1. 什么时候需要导包？

       情况一：在使用Java中提供的非核心包中的类时

       情况二：使用自己写的其他包中的类时

2. 什么时候不需要导包？

       情况一：在使用Java核心包（java.lang）中的类时

       情况二：在使用自己写的同一个包中的类时

3 权限修饰符

3.1 权限修饰符概述

       在Java中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限

  • public：公共的，所有地方都可以访问。

  • protected：受保护的，本类 ，本包，其他包中的子类都可以访问。

  • 默认：默认是空着不写，本类 ，本包可以访问。

  • private：私有的，当前类可以访问。
    public > protected > 默认 > private

3.2 权限列表

publicprotected默认private
同一类中√√√√
同一包中的类√√√
不同包的子类√√
不同包中的无关类√

4 抽象类

4.1 抽象类概述

  • 抽象方法 ： 没有方法体的方法。
  • 抽象类：包含抽象方法的类。

4.2 abstract关键字

       abstract是抽象的意思，用于修饰方法方法和类，修饰的方法是抽象方法，修饰的类是抽象类。

1.抽象方法

使用abstract 关键字修饰方法，没有方法体。

// 1.定义格式：
修饰符 abstract 返回值类型 方法名 (参数列表)；
    
// 2.代码实例：
public abstract void run();

2.抽象类

如果一个类包含抽象方法，那么该类必须是抽象类。

// 1.定义格式：
abstract class 类名字 { 
  
}
// 2.代码示例：
public abstract class Animal {
    public abstract void run();
}

3.抽象类的使用

       继承抽象类的子类必须重写父类所有的抽象方法

       代码示例：

package com.syh;
/**
 * 父类(抽象类)
 */
public abstract class Animal {
    private String name;
    private int age;

    public Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Animal{name = " + name + ", age = " + age + "}";
    }

    /**
     * 抽象方法
     */
    public abstract void eat();
}

package com.syh;

/**
 * 猫类（子类）
 */
public class Cat extends Animal {
    private String name;
    private int age;

    public Cat() {
    }

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Cat{name = " + name + ", age = " + age + "}";
    }

    /**
     * 子类实现父类抽象方法
     */
    @Override
    public void eat() {
        System.out.println("猫吃猫粮!");
    }
}

package com.syh;

/**
 * 测试类
 */
public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat("小白",3);
        System.out.println("猫的名字：" + cat.getName());
        System.out.println("猫的年龄：" + cat.getAge());
        cat.eat();
    }
}

注意：1.抽象类不能创建对象

            2.抽象类不一定有抽象方法，但是有抽象方法的类必须定义成抽象类。

5 接口

5.1 接口概述

  • 接口是更加彻底的抽象。
  • 接口中全部是抽象方法。
  • 接口同样是不能创建对象的。

1. 接口定义

接口使用interface关键字定义

//接口的定义格式：
interface 接口名称{
    // 抽象方法
}

2. 抽象方法和常量

  • 接口中只有常量和抽象方法
  • 接口中的常量默认会自动加上public static final修饰，常量名全部大写，多个单词用下划线连接。
  • 接口中的抽象方法默认会自动加上public abstract修饰，程序员无需自己手写！

3. 代码示例

package com.syh;

public interface Esther {
    // 1.常量默认会加 public static final
    String NAME = "Esther";
    // 2.抽象方法默认会加 public abstract
    void run();
}

5.2 基本的实现

1. 类实现接口

  • 类与接口的关系为实现关系，即类实现接口，
  • 实现使用 implements关键字。
  • 接口是可以被多实现的
/**
 * 实现接口
 */
class 类名 implements 接口1,接口2,接口3...{

}

注意：必须重写实现的全部接口中所有抽象方法。

2.代码示例

package com.syh;

/**
 * 运动员接口
 */
public interface SportMan {
    void run(); // 抽象方法，跑步。
}

package com.syh;

/**
 * 博尔特类
 */
public class Bolt implements SportMan {
    @Override
    public void run() {
        System.out.println("博尔特在跑步！！");
    }
}

package com.syh;

/**
 * 测试类
 */
public class Test {
    public static void main(String[] args) {
        // 创建实现类对象。
        Bolt bolt = new Bolt();
        bolt.run();
    }
}

注意：类与接口之间的关系是多实现的，一个类可以同时实现多个接口。

6 内部类

6.1 内部类概述

       将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。

6.2 内部类的分类

1.按定义的位置来分

  • 成员内部内，类定义在了成员位置 (无static修饰的内部类)
  • 静态内部类，类定义在了成员位置 (有static修饰的内部类)
  • 局部内部类，类定义在方法内
  • 匿名内部类，没有名字的内部类

2.成员内部类

       成员内部类是没有static修饰的内部类，格式如下：

// 创建成员内部类的对象
外部类.内部类 变量 = new 外部类（）.new 内部类（）;

       代码示例

package com.syh;

public class Outer {
    /**
     * 成员内部类
     */
    public class Inner{
        public void method(){
            System.out.println("成员内部类");
        }
    }
}



package com.syh;

/**
 * 测试类
 */
public class Test {
    public static void main(String[] args) {
        /**
         * 创建内部类的对象
         */
        Outer.Inner oi = new Outer().new Inner();
        oi.method();
    }
}

3. 静态内部类

       静态内部类是有static修饰的内部类，格式如下：

// 创建静态内部类的对象
外部类.内部类  变量 = new  外部类.内部类构造器;

       代码示例

package com.syh;

public class Outer {
    /**
     * 静态内部类
     */
    public static class Inner{
        public void method(){
            System.out.println("静态内部类");
        }
    }
}

package com.syh;

/**
 * 测试类
 */
public class Test {
    public static void main(String[] args) {
        /**
         * 静态内部类
         */
        Outer.Inner oi  = new Outer.Inner();
        oi.method();
    }
}

4. 局部内部类（了解即可)

       局部内部类是定义在方法中的类，格式如下：

class 外部类名 {
	修饰符 返回值类型 方法名(参数列表) {
		/**
		 * 局部内部类
		 */
		class 内部类 {
		}
	}
}

5. 匿名内部类

       匿名内部类是内部类的简化写法。他是一个隐含了名字的内部类。格式如下：

new 类名或者接口名() {
     重写方法;
};

       代码示例：

package com.syh;

/**
 * 游泳接口
 */
interface Swim {
    public abstract void swimming();
}

package com.syh;

/**
 * 测试类
 */
public class Test {
    public static void main(String[] args) {
        /**
         * 创建匿名内部类并调用
         */
        new Swim() {

            @Override
            public void swimming() {
                System.out.println("匿名内部类");
            }
        }.swimming();
    }
}
宗政依然...
关注
专栏目录
头歌--Java高级之面向对象（上）
m0_56638814的博客
04-10 6508
头歌实践教学--Java高级之面向对象（上）
java面向对象编程总结
weixin_64926930的博客
04-29 1523
在经过十周的java学习后，我对于原本一窍不通的课程又有了新的理解，它也并不是原本我不认识之前高冷的模样，我在慢慢的接触它，认识它，了解它。但现在为止，我对于我所学习的java中的“面向对象编程”做一个个人总结，其中观点仅代表个人，如有错误，敬请纠正。 在我所学习的教材中，将“面向对象编程”分为1,2,3三个章节，我也将我所学习的内容分为三个点来进行总结。 面向对象编程1 什么是面向对象 在这个章节里面，我们知道了什么是面向对象，如果用一个比喻来说的话，面向对象就像是养花一样，买个花瓶，再买束鲜花，不喜
头歌平台Java实验：Java面向对象高级
jing13_13的博客
04-18 4357
2.实现Demo接口，完善接口中的show方法，打印输出 “实现了接口中的show方法”System.out.println("实现了接口中的show方法");1.编写MyInterface接口，含一个抽象方法sayHi，返回值为void。System.out.println("接口定义完成");根据提示，在右侧编辑器补充代码，完成接口的书写和接口的实现。实现了接口中的show方法。
Java面向对象之异常处理
qq15035899256的博客
01-28 1957
本文是继续Java面向对象的学习，认识常见的异常，并且使用try..catch..处理异常，认识关键字throws和throw，自定义异常类
java高级之面向对象(上)
ros275229的博客
03-06 2749
朵拉的java实训
java中面向对象的例子_java面向对象九个经典例子程序
weixin_26834815的博客
02-27 2966
1 Hello world例子 2 类的基本组成示例 3静态与非静态变量及方法的使用 4 类继承的例子 5类的访问修饰符 6抽象类及其实现示例 7接口及其实现 8 抽象类与接口混合编程例子 9 接口回调与多态性package Example;interface Eat //定义一个接口{void eat();}class Cow implements Eat //实现接口。{public ...
Java面向对象（知识点整理）
热门推荐
yang642019851的博客
02-22 6万+
文章目录面向对象类与对象匿名对象创建对象的内存分析栈(stack)堆(heap)方法区PC寄存器本地方法栈内部类成员内部类局部内部类匿名内部类静态内部类包装类拆箱和装箱操作字符串转换基本数据类型和包装类型的区别Integer类型的重点抽象类抽象方法不能被实例化常见问题抽象类和普通类的区别接口面向接口编程思想全局常量和抽象方法的简写接口的实现 implements接口的继承 extends接口与抽象类的区别多态多态的体现多态的使用：对象的类型转换InstanceofObject类Object的多态toStri
Java 面向对象 习题（高级篇）
亮点菌
08-10 2745
1、设计类Company：获取类信息。2、编写Graph类。3、建立一个人类(Person)和学生类（Student)。4、定义员工类，具有姓名、年龄、性别属性，并具有构造方法和显示数据方法。定义管理层类，继承员工类，并有自己的属性职务和年薪。定义职员类，继承员工类，并有自己的属性所属部门和月薪。5、使用面向对象的概念表示出下面的生活场景： 小明去超市买东西，所有买到的东西都放在了购物车之中，最后到收银台一起结账......
java面向对象
黎小小的博客
08-21 4万+
本文内容是根据毕晓东老师的视频教程总结而得。包括面向对象概念、类与对象的关系、封装、构造函数、this关键字、static关键字、单例设计模式、继承、多态、内部类、异常、包等java基础知识。 1、面向对象 面向对象是相对面向过程而言 面向对象和面向过程都是一种思想 面向过程强调的是功能、行为 面向对象：将功能封装进对象，强调具备了功能的对象 面向对象是基于面向过程的 面向过程例子： ...
头歌（educoder）第 5 章 Java 面向对象之类和对象 Java面向对象 - 封装、继承和多态
qq_35353972的博客
09-19 2万+
头歌（educoder）第 5 章 Java 面向对象之类和对象 Java面向对象 - 封装、继承和多态
JAVA面向对象高级编程
06-10
OOP: Object Oriented Programming,面向对象的程序设计。所谓“对象”在显式支持面向对象的语言中，一般是指类在内存中装载的实例，具有相关的成员变量和成员函数（也称为：方法）。面向对象的程序设计完全不同于...
java面向对象高级笔记详细
08-16
详细的面向对象封装继承笔记
java面向对象高级集合笔记详细
08-16
初学者学习
实验三Java面向对象高级编程.doc
10-06
"Java面向对象高级编程实验报告" 本实验报告涵盖了Java面向对象高级编程的知识点，包括继承、多态、抽象类和接口等。实验目的旨在掌握Java面向对象编程技术，能够使用继承创立子类并实现方法覆盖，创立异类集合并...
java面向对象高级多态，接口学习笔记
08-16
内容详细，适合初学者学习
【JAVA开源】基于Vue和SpringBoot的高校学科竞赛平台
杨荧的CSDN博客
10-10 1405
教师功能有个人中心，题目类型管理，竞赛题库管理，竞赛类型管理，竞赛信息管理，报名信息管理，竞赛评分管理，参赛名单管理，晋级名单管理，获奖名单管理，竞赛总结管理，报销清单管理，成绩申诉管理，参赛信息管理，参赛信息管理，往年成绩管理，获奖情况管理。
Netty 相比原生IO模型的优势
lssffy的博客
10-09 630
Java提供了多种I/O模型，每种模型都有其适用的场景和特点，随着网络应用需求的变化，I/O模型也在不断发展。阻塞I/O（BIO，Blocking I/O）传统的I/O模型，使用简单，但每次I/O操作都会阻塞线程。每个请求需要独立的线程来处理，这在并发请求较少时问题不大，但在高并发情况下，线程资源将成为瓶颈。非阻塞I/O（NIO，Non-Blocking I/O）引入了多路复用技术，一个线程可以处理多个连接，避免了BIO中每个连接占用一个线程的问题。通过Selector。
Backend - Java 基础
是萝卜干呀的博客
10-11 559
知识量决定了未来能走多远
Hex编码
最新发布
weixin_74305514的博客
10-13 100
emps;是一种将数据转换为十六进制表示的方法。Hex编码使用16个字符来表示数据。&emps;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值