[java学习笔记]-面向对象(2)

已于 2022-07-28 14:40:27 修改
阅读量122 收藏
点赞数
分类专栏： java基础 文章标签： java jvm 开发语言
于 2022-07-26 15:35:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/noob0208/article/details/125995733
版权

[java基础]-面向对象_2

每一个java类都是一个.java文件

多态

动态编译

//Application
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        Person s2 = new Student();
        Object s3 = new Student();
        s2.run();
    }
}

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

//Student
public class Student extends Person{

}

输出

输出

修改代码 重写 run() 方法

//Application
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        Person s2 = new Student();
        Object s3 = new Student();
        s2.run();
        s1.run();
    }
}

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

运行输出

在这里插入图片描述

s2.run()//子类重写父类的方法，执行子类的方法

添加 eat() 方法

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

//Application
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        Person s2 = new Student();
        Object s3 = new Student();
    
         s2.eat();    //报错
    }
}

在这里插入图片描述

Person s2 = new Student();
s2.eat();
//对象能执行哪些方法，主要看对象左边的类型，和右边关系不大

Student s1 = new Student();
    //Student 能调用的方法都是自己的或者继承父类的
Person s2 = new Student();
    //Person 父类型，可以指向子类，但不能调用子类独有的方法
Object s3 = new Student();

多态注意事项
1.多态是方法的多态，属性没有多态
2.父类和子类有联系，类型转换异常！ ClassCastException!
3.存在条件:继承关系，方法需要重写，父类的引用指向子类对象！ Father f1 = new Son();

Instanceof 类型转换

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

//Person.java
public class Person {

}

//Teacher.java
public class Teacher extends Person{
}

//Student.java
public class Student extends Person{
}

运行得到

在这里插入图片描述

因为
Object > Person > Student
Object > Person > Teacher
Object > String

继续尝试

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

        Object object = new Student();
        System.out.println(object instanceof Student);  //True
        System.out.println(object instanceof Person);   //True
        System.out.println(object instanceof Object);   //True
        System.out.println(object instanceof Teacher);  //False
        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);   //True
        System.out.println(person instanceof Object);   //True
        System.out.println(person instanceof Teacher);  //False
//        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);   //True
        System.out.println(student instanceof Object);   //True
//        System.out.println(student instanceof Teacher);  //报错
//        System.out.println(student instanceof String);   //报错
    } 
}

在这里插入图片描述

System.out.println(X instanceof Y);
X和 Y 有关系

转换类型

//Application
public class Application {
    public static void main(String[] args) {
        //类型之间的转换
        //高                 低
        Person Muz1 = new Student();
        //将这个对象转换为Student类型，我们可以使用Student类的方法
        
        Student muz1 = (Student) Muz1;
        muz1.go();
        
        ((Student) Muz1).go();
    }
}

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

运行

在这里插入图片描述

Student muz1 = (Student) Muz1;
 muz1.go();
        
((Student) Muz1).go();

//两种转换类型的格式

static

静态的属性

//Demo
public class Student {
    private static int age; //静态变量
    private double score;   //非静态变量
    public static void main(String[] args) {
        Student s1 = new Student();
        System.out.println(Student.age);    //类
        System.out.println(s1.age);         //对象
    }
}

在这里插入图片描述

静态的方法

//Demo
public class Student {

    public void run(){
        System.out.println("run");
    }
    public static void go(){
        System.out.println("go");
    }
    public static void main(String[] args) {

        new Student().run();    //非静态方法
        go();                    //静态方法
    }
}
//run
//go

静态代码块

public class Person {
    {
        System.out.println("匿名代码块");
    }
    static {
        System.out.println("静态代码块");
    }
    public Person() {
        System.out.println("构造方法");
    }
    public static void main(String[] args) {
        Person person = new Person();
    }
}

输出

在这里插入图片描述

main方法中添加代码

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

执行输出

在这里插入图片描述

static{}静态方法 只执行一次

抽象类

abstract

//Action
//abstract 抽象类
public abstract class Action {

    //abstract，抽象方法，只有方法的名字，没有方法的实现
    public abstract void doSomething();
}

//A
//抽象类对的所有方法，继承了他的子类，都必须要实现它的方法
public class A extends Action{
    @Override
    //方法的重写
    public void doSomething() {
    }
}

类是单继承，接口可以多继承

新建一个main方法 去new 抽象类

//Application
public class Application {
    public static void main(String[] args) {
        new Action();
    }
}

在这里插入图片描述

只能去new 抽象类的子类

接口

关键字 interface

//Demo
public interface UserService {

}

接口中不存在方法

在这里插入图片描述

只有抽象的定义

 public interface UserService {
     //接口中的所有定义其实都是抽象的
    void go();
    public abstract void run();
}

写一个增删查改方法

//UserService 
public interface UserService {
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

写一个接口,必须要重写方法

//抽象类：extends
//接口 implements 接口
public class UserServiceImpl implements UserService{
    @Override
    public void add(String name) {
    }
    @Override
    public void delete(String name) {
    }
    @Override
    public void update(String name) {
    }
    @Override
    public void query(String name) {
    }
}

作用：
1.约束
2.定义一些方法，让不同的人实
3.public abstra
4.public static
5.接口不被实例化，接口中没有
6.implements可以实
7.必须要重写接口中的方法

内部类

Demo

//Out
public class Outer {
    private int id;
    public void out(){
        System.out.println("out");
    }
    public class Inner{
        public void in(){
            System.out.println("in");
        }
    }
}

//Application
public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
        //通过这个外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();
    }
}

在这里插入图片描述

内部类获取外部类的资源 私有属性

//Out
public class Outer {
    private int id = 2022;

    public class Inner{
        public void getID(){
            System.out.println(id);
        }
    }
}

//Application
public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
        //通过这个外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.getID();
    }
}

在这里插入图片描述

一个java类中可以有多个class类，但只能有一个public class类

public class Outer {

}
class A{
  
}
class B{
  
}

没有名字初始化类

public class Test {
    public static void main(String[] args) {
        //没有名字初始化类，不用实例保存
        new Apple().eat();
    }
}
class Apple{
    public void eat(){
        System.out.println("Apple");
    }
}

在这里插入图片描述

Error和Exception

检查性异常

运行时异常

错误ERROR

捕获和抛出异常

try
catch
finally
throw
throws

Demo写一段报错代码

//Test
public class Test {
    public static void main(String[] args) {
        int a = 1;
        int b = 0;
        System.out.println(a/b);
    }
}

在这里插入图片描述

出现异常，然后实现捕获异常

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

        int a = 1;
        int b = 0;

        try {
            System.out.println(a/b);
        }catch (ArithmeticException e){
            System.out.println("程序出现异常，变量b不能为0");
        }finally {
            System.out.println("finally");
        }
    }
}

在这里插入图片描述

finally都会执行

手动栈溢出

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

        try {   //监控区域
            new Test().a();
        }catch (Throwable e){ //捕获异常
            System.out.println("程序出现异常，捕获到Throwable");
        }finally {  //最后执行
            System.out.println("finally");
        }

    }
    public void a(){
        b();
    }
    public void b() {
        a();
    }
}

在这里插入图片描述

捕获 1/0 的异常等级

//Test
public class Test {
    public static void main(String[] args) {
        int a = 1;
        int b = 0;
        try {   //监控区域
            System.out.println(a/b);
        } catch (Error e){ //捕获异常
            System.out.println("Error");
        } catch (Exception e){
            System.out.println("Exception");
        } catch (Throwable t){
            System.out.println("Throwable");
        } finally {  //最后执行
            System.out.println("finally");
        }  
    }
}

在这里插入图片描述

逐层递进关系 ， 从小到大捕获

主动抛出异常

//Test
public class Test {
    public static void main(String[] args) {
        new Test().test(1,0);
    }
    public void test(int a, int b){
        if(b == 0){
            throw new ArithmeticException();//主动抛出异常
        }
    }
}

在这里插入图片描述

木拖把
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Java学习笔记-面向对象-001-面向对象概括
06-05
同时，阅读优秀的Java学习笔记和参考书籍，参与在线社区和论坛讨论，都可以帮助你加快学习进度，提高编程技能。在Java的世界里，不断探索和实践，你将能够构建出高效、可靠的面向对象软件系统。
Java面向对象编程学习笔记.pdf
12-01
"Java面向对象编程学习笔记.pdf" Java面向对象编程学习笔记是Java程序设计语言中面向对象编程（Object-Oriented Programming，OOP）的一份学习笔记。面向对象编程是一种软件设计方法，它强调使用对象和类来模拟现实...
UserService
m0_56021431的博客
04-26 486
Demo09 //interface 定义的关键字 接口都需要实现类 public interface UserService { //常量~ public static final int AGE=99; //接口中所有定义其实都是抽象的 public abstract void run(String name); void delete(String name); void update(String name); void query(String name); } ...
UserService类
qq_38416836的博客
01-26 6382
package com.bjhst.ssm.service; import com.bjhst.ssm.model.User; import java.util.List; /** * @author admin */ @SuppressWarnings("all") public interface UserService { ListUser> getAllUser();
黑猴子的家：Stock(十 一) 创建 UserService 接口
黑猴子的博客
03-11 982
1、service包下 –> New -> Interface 2、 Name -> UserService -> Finish 3、UserService 内容 package com.yg.service; import java.util.List; import com.yg.entity.User; //类名首字母大写 public inter...
NORDIC Thingy:52 蓝牙 BLE 服务 SoC 程序调用流程分析之三, User interface service
Hansen Mi Blog
07-24 570
Nordic Thingy 52 BLE Services * Thingy configuration service  * Environment service  * User interface service  * Motion service  * Sound service  * Battery service  * DFU service * User interf...
新闻发布项目——业务逻辑层（UserService）
穆雄雄的博客
11-24 354
package bdqn.newsManageServlet.Service; import bdqn.newsManageServlet.entity.User; /** * 用户信息 * @author Administrator * */ public interface UserService { public User getLoginUser(String uName,S...
Java学习笔记之面向对象基本概念
12-22
　面向对象程序设计是将人们认识世界过程中普遍采用的思维方法应用到程序设计中。 　对象是现实世界中存在的事物，它们是有形的，如某个人、某种物品;也可以是无形的，如某项计划、某次商业交易。 　对象是构成...
java学习笔记（面向对象）
03-07
通过不断练习和学习，可以更好地利用Java的面向对象特性来解决各种复杂问题。对于初学者来说，可以参考书籍、在线教程或实际项目来深入学习这些知识。同时，刷LeetCode等平台的题目，可以帮助巩固理论知识并提高编程...
Java学习笔记，面向对象深化
02-06
【Java面向对象深化】知识点详解 面向对象编程是Java的核心特性之一，它通过类和对象的概念，模拟现实世界中的实体，使代码更加模块化和可维护。以下将深入讲解Java中面向对象的一些关键知识点。 1. **继承**： -...
第十六篇、接口的定义与实现
weixin_45796249的博客
07-31 113
接口的定义与实现
子类继承父类，并重写父类方法
m0_56255158的博客
03-26 2192
原 子类继承父类，并重写父类方法 2016年08月04日 00:04:07 jinxueH专栏 阅读数：17172  版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/euxnijuoh/article/details/52108863   例子1： 父类： public class Person { &nbsp...
Java的四种内部类详解
m0_60996938的博客
12-23 982
N种内部类 1.什么是内部类？ 内部类就是在一个类的内部再定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类。 他一共有以下几种： 成员内部类 静态内部类 局部内部类 匿名内部类 2.成员内部类 咱们先看一下定义成员内部类的方式，代码如下： public class Outer //外部类 { private int id; public void out()
public class UserServiceImpl extends ServiceImpl UserMapper, User implements UserService
周红伟讲AI
05-18 3504
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService 1.1 shixianle gonggong chouxianglei. 1.2 shixianle jiekoulei
Elsaticsearch java基本操作
最新发布
qq_62383709的博客
07-13 346
索引 基本操作 package com.orchids.elasticsearch.web.controller; import cn.hutool.core.collection.CollUtil; import cn.hutool.json.JSONUtil; import com.orchids.elasticsearch.web.po.User; import io.swagger.annotations.Api; import io.swagger.annotations.ApiOperatio
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 379
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 443
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
java Object 转 Integer
servepeople的博客
07-09 1444
在 Java 中，可以通过多种方法将一个Object转换为Integer。
JavaSE笔记11111
10-15
本篇JavaSE笔记详细介绍了Java编程基础和核心概念，主要包括以下几个方面： ...通过这篇笔记，初学者可以掌握Java语言的基础语法，了解面向对象编程的基本思想，并为后续更深入的学习打下坚实的基础。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值