面向对象(重点)

最新推荐文章于 2024-06-16 09:46:44 发布
最新推荐文章于 2024-06-16 09:46:44 发布
阅读量155 收藏
点赞数
分类专栏： java 后端 代码人生 文章标签： java 面向对象编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44681042/article/details/119771138
版权
java 同时被 3 个专栏收录
13 篇文章 0 订阅
订阅专栏
后端
12 篇文章 0 订阅
订阅专栏
代码人生
9 篇文章 0 订阅
订阅专栏

面向对象

文章目录

初识面向对象

image-20210818053336596

image-20210818053438291

方法回顾

image-20210818053737080

对象的创建分析

创建

image-20210818053911818

package OOP;



//学生类
public class Student {
    //属性:字段
    String name;
    int age;
    
    //方法
     public void study(){

         System.out.println(this.name+"学生在学习");
     }

}
/*
public static void main(String[] args) {
        //类:抽象的 ,实例化
        //实例化后会返回一个自己的对象
        //Student对象就是Student类的具体实例
        Student student = new Student();

        student.name = "小红";
        student.age = 3;

        System.out.println(student.name);
        System.out.println(student.age);
    }
 */

构造器

package OOP;
//java-->class
public class Person {
    //一个类即使什么都不写,它也会存在一个方法
    //构造器

    String name;
    int age;
    //1.使用new关键字,实际在调用构造器
    //2.用来初始化值
    public Person() {
    }

    //有参构造:一旦有了有参构造,无参必须显示定义
    public Person(String name) {
        this.name = name;
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
/*
public static void main(String[] args) {

        //new 实例化一个对象
        Person person = new Person("Yixin",20);
        System.out.println(person.name);

    }
    ===================================================
    构造器:
        1.和类名相同
        2.没有返回值
    作用:
        1.new 本质在调用构造方法    
        2.初识话对象值
    注意点:
        1.有参构造:一旦有了有参构造,无参必须显示定义   
 */

类与对象小结

/*

1.类与对象
    类是一个模板:抽象.对象是一个具体实例
2.方法
    定义.调用
3.对应的引用
    引用类型: 基本类型(8)
    对象是通过引用来操作的: 栈--->堆
4.属性:字段field 成员变量
    默认初始化:
        数字 0 0.0
        char : u0000
        boolean : false
        引用: null
  修饰符 属性类型 属性名 = 属性值 ;
5.对象的创建和使用
    - 必须使用new关键字创造对象,构造器 Person Yixin = new Person();
    - 对象的属性 Yixin.name
    - 对象的方法 Yixin.sleep()
6.类
    静态的属性 属性
    动态的行为 方法
    
    */

面向对象的三个特征

封装

image-20210818053941618

package OOP;
/*
    1.提高程序的安全性,保护数据
    2.隐藏代码的实现细节
    3.同一接口
    4.系统可维护增加
 */


//类 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(){
        this.name = name;
    }

    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;
        }
    }
    
    /*
    public static void main(String[] args) {

        Student s1 = new Student();
        s1.setAge(18);
        System.out.println(s1.getAge());
    }
    
     */
    
}

继承

image-20210818054037556

package OOP.demo1;


public class Person {
    public void say() {
        System.out.println("说话");
    }
}

/*
package OOP.demo1;

//扩展
public class Student extends Person {
}

//基础默认类 object   ctrl+H 继承结构图
public static void main(String[] args) {

        Student student = new Student();
        student.say();
    }
*/
super
super注意点:
    1.super调用父类的构造方法,必须在构造方法的第一个
    2.super 必须在子类的方法或构造器中
    3.super和this不能同时调用构造方法
VS this:
    代表不同的对象:
        this:代表调用者本身
        super:代表父类的对象应用
    前提:
        this:没有继承也可由使用
        super:只能在继承条件下使用
    构造方法:
        this()本类的构造
        super()父类的构造

package OOP.demo2;


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

    protected String name = "Yixin";
    //私有的无法被继承
    public void print(){
        System.out.println("Person");
    }

}

package OOP.demo2;

public class Student extends Person {

    public Student() {
        //隐藏代码: 调用了父类的构造器

        super();//调用父类构造器,必须在子类构造器的第一行
        System.out.println("Student无参构造执行");
    }

    private String name = "xiaoming";

    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
    public void print(){
        System.out.println("Student");
    }

    public void test1(){
        print();
        this.print();
//        super.print();
    }
}

package OOP;


import OOP.demo2.Student;
import OOP.demo3.Person;

class Application {
    public static void main(String[] args) {
        Student student = new Student();
//        student.test("意心");
//            student.test1();

    }
}
方法重写
package OOP.demo3;

public class Student extends Person {
    //重写 父类 方法
    @Override
    public void run() {
        System.out.println("son");
    }
    // 子类 独有方法
    public void eat(){
        System.out.println("eat");
    }
}

多态

image-20210818054336334

package OOP.demo3;

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

}


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

/*
public static void main(String[] args) {
        //对象的实际类型是确定的
        //new Student Person
        //可以指向的引用类型不确定 : 父类的引用指向子类


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

//        s2.eat(); //不行 子类独有方法
        //子类重写了父类的方法
        s2.run();
        //对象能执行的方法: 主要看左边的类型,和右边关系不大
        s1.eat();


    }

 */
instanceof 类型判断
package OOP.demo4;

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


/*
instanceof 类型判断

public static void main(String[] args) {
        //Object > Person > Student
        //Object > Person > Teacher
        //Object > String
        //三条继承线路


        //System.out.println(x instanceof y);
        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);//fales
        System.out.println(Object instanceof String);//fales
        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);//fales
//        System.out.println(Person instanceof String);//编译报错

        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);//编译报错


    }


//类型强转

    public static void main(String[] args) {
        //子类转换父类 可能丢失自己本来的方法
        //类型之间转换: 父 子
        //高    -->    强转           //低
        Person s1 = new Student();
        //将s1 转换成Student类 就能 使用Student方法
        // 父 调用 子 需要强转

        ((Student)s1).go();

//        Student s11= (Student) s1;
//        s11.go();


        1.父类引用指向子类的对象
        2.把子类转换为父类,向上转型
        3.把父类转换为子类,向下转型.强转
        4.方便方法的调用.减少重复代码


     */

static

package OOP.demo5;

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

    public void run(){
        System.out.println("run");

    }
    public static void go(){
        System.out.println("go");
    }

    public static void main(String[] args) {
        Student s1 = new Student();
        System.out.println(Student.age);
//        System.out.println(Student.score); //错误

        System.out.println(s1.score);
        System.out.println(s1.age);
        Student.go();


    }




}

package OOP.demo5;

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 person1 = new Person();
    }

}

抽象类和接口

抽象类

image-20210818055202789

package OOP.demo6;
/**
 * @author YixinWen
 */
//抽象类的所有方法都必须继承它的子类,都必须要实现它的方法
//abstract 抽象类 extends 单继承  (接口可以多继承)
public  abstract class Action {
    //abstract ,抽象方法,只有方法名字,没有方法的实现
    public abstract void doSomething();
}
//1.不能new这个抽象类,只能靠子类实现它
//2.抽象类中可以普通方法
//3.抽象方法必须在抽象类中

package OOP.demo6;


//抽象类的所有方法都必须继承它的子类,都必须要实现它的方法
public class Test extends Action {
    @Override
    public void doSomething() {

    }
}
接口

image-20210818055226185

作用:
    1.约束
    2.定义方法,让不同的人实现
    3.接口不能实例化,接口中没有构造方法
    4.可以实现多个接口
    5.必须重写接口方法 implements
    6.public abstract
    6.public static final

package OOP.demo7;

public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void time() {

    }
}

package OOP.demo7;

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

内部类

image-20210818055303483

package OOP.demo8;

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);
    }
}
//一个java类中可以有多个class类,但只能有一个public class
class A{
    public static void main(String[] args) {

    }
}

package OOP.demo8;


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

    }
}

package OOP.demo8;

public class test {
    //局部内部类
    public void method(){
        class Inner{
            public void in(){

            }
        }
    }
}

package OOP.demo8;

public class wen {
    public static void main(String[] args) {
        //匿名内部类
         new Apple().eat();
        User user = new User() {
            @Override
            public void hello() {

            }
        };

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


    interface User{
        void hello();

    }
}

Outer.Inner inner = outer.new Inner();
inner.in();//这是内部类

}

}


```java
package OOP.demo8;

public class test {
    //局部内部类
    public void method(){
        class Inner{
            public void in(){

            }
        }
    }
}

package OOP.demo8;

public class wen {
    public static void main(String[] args) {
        //匿名内部类
         new Apple().eat();
        User user = new User() {
            @Override
            public void hello() {

            }
        };

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


    interface User{
        void hello();

    }
}

源代码

GitHub:https://github.com/YixinWen/java.git (javaSE 分支)
Gitee(码云):https://gitee.com/wenyixin666/java.git (javaSE 分支)

落月归山河
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java面向对象重点知识
blotemj.blog.csdn.net
08-16 310
第一天 1类和对象 1)什么是对象 对象就是东西 万物皆对象(东西) 现实生活中是先有对象,后抽象出类型 2)java中的类和对象 先有类,后有对象 2.1)定义类 类中包含属性和方法 2.2)实例化对象 Dog d=new Dog(); 2.3)使用对象 使用对象的引用打.调用属性和方法 d.name="xxx" ...
面向对象上（重点）
black_mamba123的博客
09-24 294
关键字this: 关键字：this 1.this可以理解为： 当前对象 或 当前正在创建的对象 2.可以调用的结构：属性、方法、构造器 3.this调用属性、方法： 在方法中：我们可以在方法中通过"this.属性"或者"this.方法"的方法，表示调用当前对象的指定属性或方法。但是通常情况下，我们都省略了"this."。但是如果方法的形参和当前对象的属性名相同的情况下，我们必须
面向对象一些重点
wobushizhainan的博客
09-21 337
1.成员变量和局部变量的区别 2.构造方法：用于给对象中的属性就行初始化 3.static关键字的特点 4. 在静态方法中是没有this关键字的 5.静态变量和成员变量的区别 6. A:Math 类概述 7.封装的概述 8.继承(extends) 9.this和super都代表什么 10.继承中构造方法的关系 11.final关键字 12.多态(polymorphic)概述 13.多态中的成员访问特点 14. 抽象 15.A:常见问题1： 16.接口 17.抽象类和接口的区
面向对象重点概述
xiaowei_liudan的博客
09-13 118
重载（Override） 方法的重载是指同一个类中，同名方法，参数不同，与返回值无关。 子类从父类继承的同名方法也可以和子类本身的同名方法构成重载。 public class OverrideTest { public static void main(String[] args) { People p = new People(); p.show(); Student s = new Student(); s.show(); ...
面向对象的知识要点
kerry0071的专栏
06-03 1189
1、面向对象技术的基本概念 对象、类和继承 2
php面向对象重点知识分享
10-16
在本篇文章里小编给大家整理的是关于php面向对象哪些重点的内容，有需要的朋友们学习参考下。
面向对象重点复习
12-16
这是我所总结的关于大学进行面向对象考试的重点总结，欢迎大家前来与我交流。
面向对象技术引论重点整合
07-02
面向对象技术引论，期末重点知识整合，高效复习
c++面向对象程序设计语言重点难点复习题及答案.doc
06-27
c++面向对象程序设计语言重点难点复习题及答案。
面向对象关键知识点汇总
weixin_33781606的博客
03-16 118
面向对象关键知识点汇总 先来了解一些基础概念，才能更好的理解知识。 对象的定义 ECMA-262把对象定义为：“无序属性的集合，其属性可以包含基本值、对象或者函数。 数据属性 4个特性 [[Configurable]]:默认true 表示能否通过delete删除属性从而重新定义属性，能否修改属性的特性。 [[Enumerable]]: 默认true 表示能否通过for-in 循环返回属性 ...
面向对象要点总结
feyily的博客
12-22 307
第二章 面向对象设计原则 软件的可维护性和可复用性 软件的复用(Reuse)或重用拥有众多优点，恰当的复用还可以改善系统的可维护性。 复用的目标在于实现支持可维护性的复用 可维护性复用都是以面向对象设计原则为基础的 重构(Refactoring)是在不改变软件现有功能的基础上，通过调整程序代码改善软件的质量、性能，使其程序的设计模式和架构更趋合理，提高软件的扩展性和维护性。 面向对象设计原则 ...
面向对象知识点全方位梳理
Helltaker的博客
08-05 681
面向对象知识点整理归纳面向对象的基本概念定义类创建和使用对象对象数组方法方法的返回值方法的调用带参数的方法方法传参方法重载构造方法构造方法重载类方法 面向对象的基本概念 1.面向对象 Java是一种面向对象的语言，比较符合人类认识现实世界的思维方式。 它的基本思想是把问题看成是由若干个对象组成，对象间相互独立，但又可以相互配合、连接和协调。 具有系统结构较稳定、子系统相对独立、软件可重用性、可维护性和可扩展性强的特点。 面向对象的三大特征：封装、继承和多态。 2.对象 对象是用来描述客观事物的一个实体 对象
面向对象知识点总结
lz1170063911的博客
06-29 5754
面向对象知识点总结 面向对象与面向过程有什么区别？答：面向过程：强调的是每一个功能实现的具体步骤。面向对象：基于面向过程，强调的是对象，然后由对象去调用功能。举例：洗衣服面向过程：把衣服脱下--找一个盆--放点洗衣粉--加点水--把衣服扔进去--搓一搓--清洗衣服--拧干--晾起来面向对象：把衣服脱下--打开全自动洗衣机--扔进去--一键即可--晾起来 （毕向东）面向对象其实是一种思考问题的思想，...
面向对象知识点整理
仰起脸笑得像满月
12-07 6047
面向对象考试简述题整理 概述 1、  什么是面向对象？ 从程序设计方法的角度看，面向对象是一种新的程序设计范型(paradigm)，其基本思想是使用对象、类、继承、封装、聚合、关联、消息、多态性等基本概念来进行程序设计。 面向对象方法是一种运用对象、类、继承、封装、聚合、关联、消息、多态性等概念来构造系统的软件开发方法。 2、 面向对象基本思想。 从现实世界中客观存在的事物出发来建立软
Java面向对象知识点总结
buaa_shang的专栏
11-29 1万+
一、类和对象 （1）类：类是模子，确定对象将会拥有的特征(属性)和行为(方法)。 类的特点：类是具有相同属性和方法的一组对象的集合。 （2）对象 创建对象：类名 对象名 = new 类名() 使用对象：对象.属性   /   对象.方法名() （3）成员变量与局部变量 成员变量：在类中定义，用来描述对象将要有什么。（作用域在整个类内部都是可见的） 局部变量：在类的方法中定义，在方法
面向对象方法学的四个要点
热门推荐
斜阳雨陌
03-10 1万+
面向对象方法学的要点面向对象方法学的出发点和基本原则，是尽可能模拟人类习惯的思维方式，使开发软件的方法与过程尽可能接近人类认识世界解决问题的方法与过程，也就是使描述问题的问题空间(也称为问题域)与实现解法的解空间(也称为求解域)在结构上尽可能一致。面向对象方法把对象作为由数据及可以施加在这些数据上的操作所构成的统一体。对象与传统的数据有本质区别，它不是被动地等待外界对它施加操作，相反，它是进行处理
基于springboot的青年公寓服务平台源码数据库
最新发布
s123456sj的博客
06-16 554
本青年公寓服务平台分为管理员还有用户两个权限，管理员可以管理用户的基本信息内容，可以管理房屋投诉信息以及房屋投诉的租赁信息，能够与用户进行相互交流等操作，用户可以查看房屋信息，可以查看房屋投诉以及查看管理员回复信息等操作。
【Java02】Java中数组的定义与初始化
饮冰室
06-10 572
推荐第一种方式。这种方式容易让人理解，数据类型是type[]，对象名称是arrayName。第二种方式有些老旧了。由于数组是一种引用变量（也就是一个指针），所以定义的时候还没有指向任何有效的内存空间，因此在定义数组的时候不能指定数组的长度，也不能直接使用。必须进行初始化。可以使用var让系统自动推断变量类型，既可以用于静态初始化，也可以用于动态初始化。
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] CPU算力分配(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-11 346
### 问题描述 K小姐是某公司运营部门的主管,最近她需要对公司的两组服务器进行算力分配。每组服务器有多个算力不同的 $CPU$,其中 $A$ 组第 $i$ 个 $CPU$ 的运算能力为 $A[i]$,而 $B$ 组第 $i$ 个 $CPU$ 的运算能力为 $B[i]$。一组服务器的总算力是各 $CPU$ 的算力之和。 为了让两组服务器的算力相等,K小姐允许从每组各选出一个 $CPU$ 进行一次交换。她希望从 $A$ 组服务器中选出算力尽可能小的 $CPU$ 来交换,你能帮她计算出应该选择哪两个 $CP
python 面向对象的理解
07-08
面向对象是一种编程范式，它将程序设计的重点放在了对象的概念上。在面向对象编程中，程序被组织成一个个相互独立的对象，这些对象通过消息传递的方式进行交互。每个对象都有自己的状态（属性）和行为（方法），并且...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值