JAVA 面向对象（OOP）

最新推荐文章于 2023-03-27 22:04:22 发布
最新推荐文章于 2023-03-27 22:04:22 发布
阅读量161 收藏
点赞数
分类专栏： JAVA 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011868279/article/details/126296394
版权

1.什么是面向对象？

2.面向过程与面向对象的区别

3.回顾方法的定义

  • break和return的区别

 跳出switch，结束循环和return的区别

  •  方法名: 注意规范。驼峰命名法。
  • 参数列表
  • 异常抛出

4.回顾方法的调用

  • 静态方法
  • 非静态方法
  • 形参和实参
  • 值传递和引用传递
  • this 关键字

5.类与对象的创建

 使用new关键字创建对象

使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。

类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：
1、必须和类的名字相同
2、必须没有返回类型，也不能写void

package org.psmaxwell.oop.demo02;
//学生类
public class Student {
    //属性： 字段
    String name; //null
    int age;    //0

    //方法
    public void study(){
        System.out.println(this.name +"在学习");
    }

}

/**
 *     public static void main(String[] args) {
 *
 *
 *         // 类： 抽象的， 实例化
 *         // 类实例化后会返回一个自己的对象！
 *         //student 对象就是一个Student类的具体实例！
 *         Student xiaoming = new Student();
 *         Student xh = new Student();
 *
 *         xiaoming.name = "小明";
 *         xiaoming.age = 3;
 *
 *         System.out.println(xiaoming.name);
 *         System.out.println(xiaoming.age);
 *
 *         xh.name = "小红";
 *         xh.age = 3;
 *
 *         System.out.println(xh.name);
 *         System.out.println(xh.age);
 *
 *     }
 */

6.构造器详解

package org.psmaxwell.oop.demo03;

public class Pet {
    public String name;
    public int age;

    //无参构造

    public void shout(){
        System.out.println("叫了一声");
    }

}


/**
 *
 Pet dog = new Pet();
 dog.name = "旺财";
 dog.age = 3;
 dog.shout();

 System.out.println(dog.name);
 System.out.println(dog.age);
 */

7.简单小结类与对象

      
        1.类是一个模板，对象是一个具体的实例。
        2.方法
        定义、调用！
        3.对应的引用
        引用类型： 基本类型
        对象是通过引用来操作的，栈---》堆

        4.属性： 字段Field 成员变量
        默认初始化
        数字 ： 0     0.0
        char : u0000
        boolean : false
        引用 ： null

        修饰符 属性类型 属性名 = 属性值！

        5.对象的创建和使用
        - 必须使用new 关键字创造对象，构造器 Person Maxwell = new Person();
        - 对象的属性 Maxwell.name
        - 对象方法  Maxwell.sleep()

        6.类
           静态的属性    属性
           动态的行为    方法

           封装、继承、多态

 8.封装详解

    该露的露，该藏的藏
   我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成。不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。     

封装（数据的隐藏）
通常，应禁止直接访问一个对象中数据的实际标识，而应通过操作接口来访问，这称为信息隐藏。

记住这句话就够了：属性私有，get/set

package org.psmaxwell.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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age>120 || age<0) {
            this.age = 3;
        }else{
            this.age = age;
        }
    }
}

/**
 * 
 *         Student s1 = new Student();
 *
 *         s1.setName("Maxwell");
 *
 *         System.out.println(s1.getName());
 *
 *         s1.setAge(999);  //不合法
 *
 *         System.out.println(s1.getAge());
 */

9.什么是继承？

 10.Super详解

super注意点：
1.调用父类的构造方法，必须在构造方法的第一个
2.super必须只能出现在子类的方法或者构造方法中。
super和this不能同时调用构造方法。


Super Vs this:
代表的对象不同：
this ： 本身调用者这个对象
super:  代表父类对象的应用

前提：
this : 没有继承也可以使用
super: 只能在继承条件下才可以使用

构造方法：
this() : 本类构造器。
super() : 父类构造器！

package org.psmaxwell.oop;

import org.psmaxwell.oop.demo05.Person;
import org.psmaxwell.oop.demo05.Student;

// 一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {

        Student student = new Student();
       // student.test("小山");
       // student.test1();
    }
}

package org.psmaxwell.oop.demo05;

// 学生 is 人   子类 派生类
// 子类继承了父类，就会拥有父类的全部方法
public class Student extends Person {

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

    //Ctrl + H
    private String name = "xiaoshan";

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

    public void test1(){
        print();  //Student
        this.print();  //Student
        super.print();  //Person
    }
    public void test2(String name){
        System.out.println(name); // 小山 main
        System.out.println(this.name); //调用子类
        System.out.println(super.name); //调用父类
    }
}

package org.psmaxwell.oop.demo05;
//Person is 人   父类
//在Java中，所有的类，都默认直接或者间接继承Object
public class Person /*extends Object*/{

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

    protected  String name = "Maxwell";

    //私有的东西无法被继承
    public void print(){
        System.out.println("Person");
    }
}

11.方法重写

---重写

重写： 需要有继承关系，子类重写父类的方法！
1.方法名必须相同
2.参数列表必须相同
3.修饰符：范围可以扩大; public> protected>Default>private
4.抛出的异常：范围可以被缩小，但不能扩大；ClassNotFoundException ---> Exception(大)
重写，子类的方法和父类必须一致；方法体不同

为什么需要重写？
1.父类的功能，子类不一定需要，或者不一定满足。
Alt + Insert :overwrite;

package org.psmaxwell.oop;

import org.psmaxwell.oop.demo05.A;
import org.psmaxwell.oop.demo05.B;

//静态的方法和非静态方法区别很大！

//非静态： 重写

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

        // 静态方法： //方法的调用只和左边，定义的数据类型有关
        A a = new A();
        a.test();   //A

        //父类的引用指向子类
        B b = new A();  //子类重写了父类的方法
        b.test();  //B
    }
}

package org.psmaxwell.oop.demo05;
//继承
public class A extends B{


    //重写
    @java.lang.Override   //注解
    public void test() {
        System.out.println("A=>test()");
    }
}

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

12.instanceof和类型转换

package org.psmaxwell.oop;

import org.psmaxwell.oop.demo06.Person;
import org.psmaxwell.oop.demo06.Student;
import org.psmaxwell.oop.demo06.Teacher;

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();

/**
 * 1.父类的引用执行子类的对象
 * 2.把子类转换为父类，向上转型
 * 3.把父类转换为子类，向下转型，强制转换。
 * 4.方便方法的调用，减少重复的代码，简洁
 *
 * 封装、继承、多态、接口
 * 多实践、多测试、实践出真知。
 * 
 *
 */
    }
}

package org.psmaxwell.oop.demo06;

public class Person {

    public void run(){
        System.out.println("run");
    }
}
package org.psmaxwell.oop.demo06;

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

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

/**
 *
 *    // Object > String
 *         // Object > Person > Teacher
 *         // Object > Person > Student
 *         Object object = new Student();
 *
 *         //System.out.println(x instanceof y); //能不能通过
 *
 *         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); //编译报错
 */

13.static关键字详解

package org.psmaxwell.oop.demo07;
//静态导入包
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(PI);
    }
}
package org.psmaxwell.oop;

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

    }
}
package org.psmaxwell.oop.demo07;
//static
public class Student {

    private static int age;   //静态的变量
    private double score;    //非静态变量

    public void run(){
        go();

    }

    public static void go(){

    }

    public static void main(String[] args) {
        Student.go();

    }
}

package org.psmaxwell.oop.demo07;

public class Person {

//2
    {
        //代码块（匿名代码块）
        System.out.println("匿名代码块");
    }
// 1  只执行一次
    static {
        //静态代码块
        System.out.println("静态代码块");
    }
//3
    public Person() {
        System.out.println("构造方法");
    }

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

14.抽象类

  • abstract 修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法，如果修饰类，那么该类就是抽象类。
  • 抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类。
  • 抽象类，不能使用new关键字来创建对象，它是用来让子类继承的。
  • 抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的。
  • 子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。
package org.psmaxwell.oop.demo08;
//abstract 抽象类  类 extends: 单继承   （接口可以多继承）
public abstract class Action {

    // 约束 有人帮我们实现-
    // abstract ,抽象方法，只有方法名字，没有方法的实现。
    //约束- 有人帮我们实现 抽象方法，只有方法的名字，没有方法的实现
    public abstract void doSomething();

    //1.不能new这个抽象类， 只能靠子类去实现它，约束。
    //2.抽象类中可以写普通的方法
    //3.抽象方法必须在抽象类中
    //抽象的抽象 ： 约束

    // 思考题  new ， 存在构造器吗？
    //存在的意义 抽象出来， 提高开发效率
}

package org.psmaxwell.oop.demo08;

//抽象类的所有方法，都继承了它的子类，都必须要实现它的方法 除非
public class A extends Action{
    @java.lang.Override
    public void doSomething() {

    }
}

15.接口的定义与实现

package org.psmaxwell.oop.demo09;

//抽象的思维  Java



//interface 定义的关键字, 接口都需要有实现类。
public interface UserService {

    //常量
    public static final int AGE = 99;



    //接口中的所有定义其实都是抽象的public
    void run(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

package org.psmaxwell.oop.demo09;

//抽象类 ： extends
// 类 可以实现接口 implements 接口
// 实现了接口的类， 就需要重写接口中的方法
//利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService{
    @java.lang.Override
    public void run(java.lang.String name) {

    }

    @java.lang.Override
    public void delete(java.lang.String name) {

    }

    @java.lang.Override
    public void update(java.lang.String name) {

    }

    @java.lang.Override
    public void query(java.lang.String name) {

    }

    @java.lang.Override
    public void timer() {

    }
}

package org.psmaxwell.oop.demo09;

public interface TimeService {
    void timer();
}

作用：
1.约束
2.定义一些方法，让不同的人实现
3.public abstract
4.public static final
5.接口不能被实例化，接口中没有构造方法
6.implements 可以实现多个接口
7.必须要重写接口中的方法
8.总结博客

16.N种内部类

package org.psmaxwell.oop.demo10;

public class Outer {

    private int id=10;

    public void out(){
        System.out.println("这是外部类的方法");
    }

    public  class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }

        //获得外部类的私有属性
        public void getID(){
            System.out.println(id);
        }
    }
}

package org.psmaxwell.oop;

import org.psmaxwell.oop.demo10.Outer;

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

        // new
        Outer outer = new Outer();
        //通过这个外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getID();
    }
}
package org.psmaxwell.oop.demo10;

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

        class Inner{
            public void in(){
                
            }
        }

    }

}

//一个java类中可以有多个class类，但只能有一个public class
//class A{
//    public static void main(String[] args) {
//
//    }
//}
package org.psmaxwell.oop.demo10;

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

        class Inner{
            public void in(){

            }
        }

    }

}

//一个java类中可以有多个class类，但只能有一个public class
//class A{
//    public static void main(String[] args) {
//
//    }
//}
package org.psmaxwell.oop.demo10;

public class Test {
    public static void main(String[] args) {
        //没有名字初始化类，不用讲实例保存到变量
        new Apple().eat();

        UserService userService = new UserService(){
            @java.lang.Override
            public void hello() {

            }
        };

    }
}

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

interface UserService{
    void hello();
}
DB架构
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java_面向对象
m0_48213795的博客
05-10 126
面向对象：注重找“参与者”,将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。属性（field 成员变量）：属性用于定义该类或该类对象包含的数据或者说静态特征。属性作用范围是整个类体。属性定义格式： 方法：方法用于定义该类或该类实例的行为特征和功能实现。方法是类和对象行为特征的抽象。方法定义格式： void代表没有返回值；方法的作用：重用代码，封装功能，便于修改示例 创建对象 示例 局部变量与成员变量 它们之间的区别如下：引用数据类型：null示例 构造器 示例 构造器重载 示例
手把手教你写一个小型面向对象项目
m0_63075532的博客
07-07 900
本文主要讲解Java语言面向对象的一个小型的总结性项目，图书管理系统，主要包含了封装、多态、继承、接口等知识
Java面向对象
qq_45909136的博客
03-27 135
我们学习编程语言最终目的是用程序去模拟现实生活中的事物，让事物与事物之间产生关系，然后模拟现实生活中的场景。属性：就是对事物的描述 -------成员变量行为：就是事物能够做什么事情 -------成员方法成员变量：在类中方法外定义的变量都叫成员变量语句定义格式：修饰符 数据类型 变量名;​成员方法：在类中定义定义的格式与我们在学习时规范的定义语法是一样：​修饰符 返回值类型 方法名(参数类型1 参数名1,....){方法体;注意：现在开始将static去掉！！！！
Java存钱取钱问题
w1112226的博客
04-09 2114
Java存钱取钱问题 题目如下: 1、写一个名为 Account 的类模拟账户。该类的属性和方法如下图所示。该类包括的属性： 账号 id，余额 balance，年利率 annualInterestRate；包含的方法：访问器方法（getter 和 setter 方法），取款方法 withdraw()，存款方法 deposit() 提示：在提款方法 withdraw 中，需要判断用户余额是否能够满足提款数额的要求，如果不 能，应给出提示。 创建 Customer 类。 a. 声明三个私有对象属性：first
java基础之面向对象OOP
火箭 的博客
12-06 192
什么是面向对象OOP？面向过程思想：面向对象思想：对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，需要使用面向对象的思路来分析整个系统。但是具体到微观操作，仍然需要面向过程的思路去处理。面向对象编程的本质：以类的方式组织代码，以对象组织封装数据。面向对象三大特性：封装、继承、多态从认知角度考虑是先有对象后有类，对象是具体的事物；类是对象的抽象。从代码运行的角度考虑是先有类后有对象。
day01Java面向对象OOP(1).xmind
最新发布
03-20
day01Java面向对象OOP(1).xmind
java面向对象编程pdf
04-16
Java面向对象编程PDF 在这篇文章中，我们将对Java面向对象编程的基础知识进行总结和解释。面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它将程序设计看作是对象的交互，对象之间的关系和行为...
JavaOOP:Java面向对象
05-17
JavaOOPJava面向对象回顾:1.方法:函数、过程封装一段特定的业务逻辑功能尽可能的独立，一个方法只干一件事可以被反复调用多次减少代码重复，有利于代码维护，有利于团队协作开发2.方法的定义:修饰词 返回值类型 方法...
浅谈Java实现面向对象编程java oop
08-18
Java面向对象编程具有很多优点，例如： 1. 可读性和维护性高：Java的面向对象编程可以实现代码的可读性和维护性高。 2. 灵活性强：Java的面向对象编程可以实现灵活的编程方式。 3. 可重用性高：Java的面向对象编程...
Java面向对象流程图
12-08
Java面向对象是编程领域中的一个核心概念，它是一种编程范式，强调数据和操作数据的方法组织在一起，模拟现实世界中的对象。在这个主题中，我们将深入探讨面向对象编程（OOP）的基本概念，包括类、对象、封装、继承...
Java 游戏项目完整源码（共四个项目，适合java初学者进一步学习和精通java，掌握面向对象编程技术）
01-04
适合java初学者进一步学习和精通java，掌握面向对象编程技术的几个非常有趣、适合java学习的游戏项目，共有四个，已经测试可以使用，并且包含完整源码和资源。
java面向对象小游戏
01-03
java面向对象编程，开发飞机类小游戏。涵盖了各种知识点！
Java面向对象经典案例10个
03-22
Java面向对象经典案例10个，适合初学者，大学老师经典讲课习题
javaOOP第十一章案例
12-27
从数据库中读取所有新闻信息保存在泛型集合中 为替换模板文件中的占位符作为准备
javaOOP项目案例
06-19
用面向对象的方法模仿一个计算机的存储与显示操作
JAVA 零钱通项目OOP（韩顺平）
wztmds的博客
04-01 1287
一.项目需求说明 使用java开发 零钱通项目，可以完成收益入账，消费，查看明细，退出系统等功能 二.项目界面 三.步骤（化繁为简） 1.完成菜单的显示 2.完成零钱通明细 3.完成收益入账 4.消费 5.退出 四.具体步骤及其代码 菜单的显示放到最后再说 1.菜单的显示（可以最后再来看菜单的显示） public void mainMenu() { System.out.println("显示菜单"); do { Syst
javaoop项目:书虫阅读器
weixin_69411453的博客
08-17 4642
System.out.println("-----------------------小说列表结束-------------------------------");System.out.println("-----------------言情小说列表开始---------------------");System.out.println("-----------------武侠小说列表开始---------------------");if (in.next().equals("是")) {......
java面向对象阶段项目 学生信息管理系统
m0_48981808的博客
07-01 236
// scanner 导包； import java.util.*; //类 public class Exec1{ //static 的全局变量 static Student[] data = new Student[5]; static Scanner sc = new Scanner(System.in); //main()方法（程序开始的地方） public static void main(String[] args){ //Student stu = new Student("
java面向对象的小项目_Java——面向对象（小知识点）
weixin_29612623的博客
02-17 317
主要内容：类和对象，方法详解，成员变量和局部变量，隐藏和封装，深入构造器，类的继承，多态，继承和组合，初始化块。1.类和对象：所有使用类定义的变量都是引用变量，引用变量里存放的仅仅是一个引用，它指向实际的对象。Java支持面向对象的三大特征：封装、继承和多态。类里的各成员之间的定义顺序没有任何影响，static修饰的成员不能访问没有static修饰的成员(即static修饰的方法不能使用this引...
Java-面向对象设计-类和对象.docx
12-16
Java面向对象设计的核心概念主要围绕类和对象展开。面向对象编程（Object-oriented Programming, OOP）是一种编程范式，它模仿现实世界的实体及其交互方式，将复杂的问题分解为更易于管理的组件。类是OOP的基础，它...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值