面向对象扩展

最新推荐文章于 2022-03-24 22:33:36 发布
最新推荐文章于 2022-03-24 22:33:36 发布
阅读量162 收藏
点赞数
分类专栏： JavaSe 文章标签： java 抽象类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Monuomeng/article/details/114598689
版权

面向对象扩展

记录自己每次学习的成果

文章目录

一. instanceof和类型转换

1. instanceof

instanceof 是 Java 的保留关键字。它的作用是测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型。

实例：
import com.mnm.oop.demo01.Person;
import com.mnm.oop.demo01.Student;

public class Application {
    public static void main(String[] args) {
        Object student = new Student();
        System.out.println(student instanceof Student);
        System.out.println(student instanceof Person);
        System.out.println(student instanceof Object);
    }
}

public class Person {
}

public class Student extends Person {
}

//执行结果：
true
true
true

2. 类型转换

实例1：
import com.mnm.oop.demo01.Person;
import com.mnm.oop.demo01.Student;

public class Application {
    public static void main(String[] args) {
        Person person = new Student();
        ((Student)person).run();
    }
}

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

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

//执行结果：
run
实例2
import com.mnm.oop.demo01.Person;
import com.mnm.oop.demo01.Student;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        Person person=student;
        person.run();
    }
}

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

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

//执行结果：
报错！
//子类转换为父类，可能丢失自己本来的一些方法
  1. 总结
    父类的引用指向子类的对象
    把子类转换为父类为 向上转型（不用强制转换）
    把父类转化为子类为 向下转型（需要强制转换）
    方便方法的调用，减少重复代码，使代码简洁

二. static详解

1. 静态属性

实例

public class Student {
    public static int age;//静态变量
    public double score;//非静态变量

    public static void main(String[] args) {
        Student s1 = new Student();
        System.out.println(Student.age);//可直接以类名引用
        //System.out.println(Student.score);//不可直接以类名引用
        System.out.println(s1.age);
        System.out.println(s1.score);
    }
}

2. 静态方法

实例：

public class Student {
    public static void run(){
        System.out.println("run");
    }
    public void go(){
        System.out.println("go");
    }
    public static void main(String[] args) {
        run();
        Student.run();//静态方法可直接调用
        //Student.go();
        Student student = new Student();
        student.go();
        student.run();
    }
}

3. 静态代码块

public class Student {
	//第二个执行，每次创建对象，就会执行匿名代码块
	//一般用于赋初始值
    {
        System.out.println("匿名代码块");
    }
    //第一个执行，只执行一次
    static {
        System.out.println("静态代码块");
    }
    //第三个执行
    public Student() {
        System.out.println("构造方法");
    }
    public static void main(String[] args) {
        Student student = new Student();
    }
}
----------结果-----------
静态代码块
匿名代码块
构造方法

4. 静态导入包

//正常使用
import java.lang.Math;
public class Person {
    public static void main(String[] args) {
        System.out.println(Math.random());
        System.out.println(Math.PI);
    }
}

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

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

三. 抽象类

1. 定义

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。

由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。

父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。

在Java中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

2. 实例

//abstract  抽象类
public abstract class Person {
    //抽象方法，只有方法名字，没有方法的实现
    public abstract void mian();
}

//抽象类的所有方法，继承了他的子类，都必须实现他的方法，除非子类也是抽象类
public class Student extends Person{
    @Override
    public void mian() {
    }
}
//------------或者-----------
public abstract class Student extends Person{
}

抽象类的特点：

  1. 不能new这个抽象类，只能靠子类来实现，只是个约束
  2. 抽象类可以写普通方法，但抽象方法，只能在抽象类中

四. 接口

1. 接口的定义

关键字：interface / implements
普通类:只有具体实现
抽象类:具体实现和规范(抽象方法)都有!
接口:只有规范!自己无法写方法，约束和现实分离，又称为面向接口编程。
接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须能…”的思想。接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。
面向对象的精髓，是对对象的抽象，最能体现这一点的就是接口。

2. 定义接口：

//接口一般都需要实现类,关键字interface
public interface Person {
	//在接口中定义的属性，默认是常量
	//public static final int age;==int age;
	int age=90;
	
	
    //接口中的所有定义，其实都是抽象的-public abstract
    //void add();==public abstract void add();
    void add();
    void delete();
    void update();
    void query();
}

public interface Student {
    void speak();
}

3. 实现类

//类，可以实现接口，用关键字implements
//实现类接口的类，就需要重写接口的方法
//侧面实现多继承
public class PersonImpl implements Person,Student{
    @Override
    public void add() {
    }
    @Override
    public void delete() {
    }
    @Override
    public void update() {
    }
    @Override
    public void query() {
    }
    @Override
    public void speak() {
    }
}

接口总结：

接口就是约束
定义一些方法，让不同的人实现
方法都是 public abstract 定义
常量都是 public static final 定义
接口不能被实例化，接口中没有构造方法
implements可以实现多个接口，但必须要重写接口中的方法

五. 内部类

内部类就是在一个类的内部再定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。

共分为以下四种：

1.成员内部类
2.静态内部类
3.局部内部类
4.匿名内部类

1. 成员内部类

实例：

import com.mnm.oop.demo04.Outer;

public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.inner inner = outer.new inner();
        inner.in();
        inner.getId();
    }
}
-----------结果-----------
这是内部类
8792912
这是外部类

public class Outer {
    private int id=8792912;
    private void out(){
        System.out.println("这是外部类");
    }
    //成员内部类
    public class inner{
        public void in(){
            System.out.println("这是内部类");
        }
        //可以获得外部类的私有属性和方法
        public void getId(){
            System.out.println(id);
            out();
        }
        
    }
}

2. 静态内部类

实例：

public class Outer {
    private int id=8792912;
    private void out(){
        System.out.println("这是外部类");
    }
    //静态内部类
    public static class inner{
        public void in(){
            System.out.println("这是内部类");
        }
    }
}

3.局部内部类

实例：

public class Outer {
    public void out(){
        //局部内部类
        class method{
            public void in(){  
            }
        }
    }
}

4. 匿名内部类

实例：

public class Outer {
    public static void main(String[] args) {
        //没有名字初始化值，不用将实例保存到变量中
        //匿名内部类
        new A().a();
        //匿名内部类
        new UserService(){
            @Override
            public void hello() {
                System.out.println("Hello World");
            }
        };
    }
}
class A{
    public void a(){
        System.out.println("A");
    }
}
interface UserService{
    void hello();
}
莫诺蒙
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Javascript面向对象扩展库代码分享
10-28
最近一直在用js做项目，遇到了许多需要应用面向对象来设计的功能，由于js对OOP的原生支持还不是很完善，所以就写了一个面向对象的扩展库用做底层支持，现在把它单独整理出来，完善了一些功能，在这里分享一下
面向对象拓展
DingDing_Zhang的博客
08-02 260
1.call、apply、bind 函数的三个原型方法都可以修改函数内部this的指向 call：修改函数this的指向，直接调用函数，call方法的参数列表是普通参数列表 apply：修改函数this的指向，直接调用函数，apply方法的参数列表是参数列表组成的数组（可以将数组变成实参列表） bind：修改函数this的指向，不可以直接调用函数，返回一个修改后的函数 function fn(x, y) { console.log(x + y) } fn(2, 3);
面向对象——扩展方法
AI浩
04-13 9429
C#扩展方法： 1 方法所在的类必须是静态的 2 方法也必须是静态的 3 方法的第一个参数必须是你要扩展的那个类型，比如你要给int扩展一个方法，那么第一个参数就必须是int。 4 在第一个参数前面还需要有一个this关键字。 例: public static class PropertyExtension { publi...
面向对象与扩展学习的总结
qq_36542024的博客
12-05 239
面向对象章节的总结    在面向对象的章节中，我学习到了在写代码时，最好写一个类图，这样有利于 创建代码不会乱。然后还有封装的作用和用法，继承和封装的应用和规则，多 态的使用和好处，还有接口的一些注意点.到最后多态与封装的注意点，再到 最后的接口接抽象类继承给子类的方法和规则。    和以前相比，逻辑能力还是不行，创建一个类图还不太懂，就是说在题目中找 出要用的类、方法和属性，就是不知
面向对象 4 面向对象可扩展性总结&练习
qq_42936973的博客
09-27 409
class Chinese: country='China' def __init__(self,name,age,sex): self.name=name self.age=age self.sex=sex def eat(self): print('%s is eating'%self.name) ...
java 面向对象扩展编程
08-01
Java 基础知识
Dynace:Dynace面向C的面向对象扩展
05-22
Dynace面向C的面向对象扩展Dynace是对C语言的可移植的开源扩展，它为标准C添加了以下功能： 完整的面向对象功能，包括类，实例，方法和泛型函数封装多态性（多个）继承完全基于元类（例如Smalltalk或CLOS） 通过通用...
面向对象-C语言
06-27
面向对象的概念和应用已超越了程序设计和软件开发，扩展到如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。面向对象是一种对现实世界理解和抽象的方法，是...
Java数组详解
Monuomeng的博客
03-05 8426
Java数组详解 一. 什么是数组 二. 数组的声明和创建 1. 数组的声明 2. 数组的创建 三. 三种初始化和内存分析 1. 三种初始化 2. 内存分析 四. 数组的特点 1. 四个基本特点 2. 数组边界 五. 数组的使用 1. for-Each 循环 2. 数组做方法参数 3. 数组做返回值 六. 多维数组 1. 多维数组的动态初始化（以二维数组为例） 2. 多维数组的引用（以二维数组为例） 七. Arrays类讲解 八. 稀疏数组(扩展)
由Maven创建的项目,无法初始化类问题
Monuomeng的博客
03-24 1352
JDBC无法初始化类,could not initialize class...,maven配置
Java基础语法
Monuomeng的博客
02-28 278
Java基础语法 一. 注释 二. 标识符与关键字 三. 数据类型 四. 数据类型扩展 五. 类型转换 六. 变量常量作用域 1. 变量 2. Java 常量 七. 基本运算符 八. 自增自减 九. 逻辑运算符/位运算符 十. 三元运算符 十一. 包机制 十二. JavaDoc......
JAVA学习流程
Monuomeng的博客
04-20 209
JAVA学习流程 个人学习java的流程及笔记，仅此做为总结，方便日后复习
JAVA集合框架(一)
Monuomeng的博客
04-19 188
JAVA集合框架(一) 一. 集合的概念 1. Collection接口 Collection体系 2. Collection父接口 集合遍历： 例一： 例二： add()方法 addAll ()方法 remove()方法 clear()方法 contains()方法 equals()方法 isEmpty()方法 size()方法 toArray()方法
JVM探究
Monuomeng的博客
02-23 177
JVM探究 请你谈谈你对JVM的理解？Java8虚拟机和之前的变化更新? 什么是OOM,什么是栈溢出StackOverFlowError？怎么分析 JVM的常用调优参数有哪些？ 内存快照如何抓取,怎么分析Dump文件？知道吗？ 谈谈JVM中，类加载器你的认识？ jvm是什么: JVM是Java Virtual Machine的缩写。它是一种基于计算设备的规范，是一台虚拟机，即虚构的计算机。 JVM屏蔽了具体操作系统平台的信息（显然，就像是我们在电脑上开了个虚拟机一样），当然，JVM执行字节码时实际上还是
JAVA I/O框架(一)
Monuomeng的博客
04-19 171
JAVA I/O框架(一) 一. 流的概念 二. 流的分类 三. 字节流 1. 文件字节流 2. 字节缓冲流 3. 对象流 四. 编码方式
Java面向对象基础
Monuomeng的博客
03-06 166
Java面向对象基础
JAVA注解与反射
Monuomeng的博客
06-16 163
JAVA注解与反射 文章目录JAVA注解与反射一. 注解1. 什么是注解2. 内置注解3. 自定义注解，元注解 一. 注解 1. 什么是注解 Annotation是从JDK5.0开始引入的新技术 Annotation的作用: 不是程序本身,可以对程序作出解释(这一点和注释(comment)没什么区别) 可以被其他程序(比如:编译器等)读取 Annotation的格式 注解是以"@注释名"在代码中存在的,还可以添加一些参数值,例如: @SuppressWarnings(value=“unchecked”
python面向过程 面向对象
最新发布
09-28
面向过程和面向对象是两种不同的编程范式。面向过程编程将程序分解为一系列的步骤和函数，强调程序的过程和控制流。而面向对象编程则将程序组织为一系列的对象，强调对象之间的交互和数据的封装。 Python既支持面向...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值