面向对象基本概念

最新推荐文章于 2023-09-04 13:37:31 发布
最新推荐文章于 2023-09-04 13:37:31 发布
阅读量141 收藏
点赞数 1
分类专栏： Java学习总结 文章标签： 多态 抽象类 interface 面向对象编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45623678/article/details/110748722
版权
基础一

源代码：

package cn.ecut.oop1;

/**
 * 学生类
 */
public class Student {
    //非静态方法 从属于对象
    public void say(){
        System.out.println("我是学生类的非静态方法");
    }
    //静态方法 从属于类 和类一起加载
    public static void print(){
        System.out.println("我是学生类的静态方法");
    }
}

package cn.ecut.oop1;

public class Test {
    //main方法
    public static void main(String[] args) {
        Student.print();
        //实例化
        Student s1=new Student();
        s1.say();

    }
}

运行结果：

我是学生类的静态方法
我是学生类的非静态方法
基础二

源代码：

package cn.ecut.oop2;

/**
 * 值传递
 */
public class Test1 {
    public static void main(String[] args) {
        int a=1;
        System.out.println(a);
        System.out.println(change(a));

    }
    public static int change(int a){
        a=10;
        return a;
    }
}

运行结果：

1
10
基础三

源代码：

package cn.ecut.oop2;
/**
 * 引用传递
 * 本质还是值传递
 */
public class Test2 {
    public static void main(String[] args) {
        Person person=new Person();
        System.out.println(person.name);
        change(person);
        System.out.println(person.name);
    }
    public static void change(Person person){
        person.name="Yu";
    }
}
class Person{
    String name;//默认null
}

运行结果：

null
Yu
基础四

源代码：

package cn.ecut.oop3;

/**
 * 学生类
 */
public class Student {
    //属性
    String name;
    int age;
    //方法
    public void study(){
        System.out.println(this.name+"在学习");
    }
}

package cn.ecut.oop3;

public class Test1 {
    public static void main(String[] args) {
        Student zhangsan=new Student();
        Student lisi=new Student();
        lisi.name="李四";
        lisi.age=22;
        zhangsan.name="张三";
        zhangsan.age=20;
        System.out.println(zhangsan.name);
        System.out.println(zhangsan.age);
        zhangsan.study();
        lisi.study();
    }
}

运行结果：

张三
20
张三在学习
李四在学习
构造器

源代码：

package cn.ecut.oop4;

public class Person {
/*
一个类即使什么都不写，它也会存在一个方法
 */
    String name;
    int age;
    //使用new关键字就会调用构造器
    //无参构造 默认构造器
    public Person(){
    }
    //有参构造 一旦定义了有参构造，无参就必须显示定义。
    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }
}

package cn.ecut.oop4;

public class Test1 {
    public static void main(String[] args) {
        Person person=new Person("张三",20);
        System.out.println(person.name);
    }
}

运行结果：

张三
note
package cn.ecut.oop4;

public class note {
    /*
    1、类与对象
        类是一个模板：抽象，对象是一个具体的实例
    2、方法
        定义、调用
    3、属性：字段 成员变量
        默认初始化：
            数字：0 0.0
            char:u0000
            boolean:false
            引用：null
    4、对象的创建和使用
        ①必须使用new关键字创造对象，构造器 Person person=new Person();
        ②对象的属性  person.name
        ③对象的方法：person.study()
    5、类：
        ①静态的属性：属性
        ②动态的属性：方法
    6、三大特点：封装、继承、多态
     */
}
封装

源代码：

package cn.ecut.oop5;

/**
 * 封装 属性私有get/set方法获取
 * 1、提高程序的安全性，保护数据
 * 2、隐藏代码的细节
 * 3、统一接口
 * 4、系统可维护性增加了
 */
public class Student {
    private String name;
    private int age;
    private char sex;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

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

    public char getSex() {
        return sex;
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex=" + sex +
                '}';
    }
}

package cn.ecut.oop5;

public class Test {
    public static void main(String[] args) {
        Student s1=new Student();
        s1.setName("Yu");
        s1.setAge(20);
        s1.setSex('男');
        System.out.println(s1.toString());
    }
}

运行结果：

Student{name='Yu', age=20, sex=男}
继承一

源代码：

package cn.ecut.oop6;

/**
 * 继承 extends的意思是扩展。子类是父类的扩展
 * ①私有的东西无法继承
 * ②JAVA中只有单继承，没有多继承。
 */
public class Person {
    protected String name="YYW";
}

package cn.ecut.oop6;

public class Student extends Person{
    private String name="鱼";

    public void text(String name) {
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
}

package cn.ecut.oop6;

public class Test {
    public static void main(String[] args) {
        Student s1=new Student();
        s1.text("Yu");
    }
}

运行结果：

Yu
鱼
YYW
继承二

源代码：

package cn.ecut.oop6;

public class Person2 {
    protected String name="YYW";
    public void print(){
        System.out.println("Person2");
    }
}

package cn.ecut.oop6;

public class Student2 extends Person2{
    private String name="Yu";
    public void print(){
        System.out.println("Student2");
    }
    public void test(){
        print();
        this.print();
        super.print();
    }
}

package cn.ecut.oop6;

public class Test2 {
    public static void main(String[] args) {
        Student2 s2=new Student2();
        s2.test();
    }
}

运行结果：

Student2
Student2
Person2
继承三

源代码：

package cn.ecut.oop6;

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

/**
 * super与this的不同：
 * 1、代表的对象不同：
 *    this:本身调用者这个对象
 *    super:代表父类对象的应用
 * 2、前提：
 *    this:没有继承也可以使用
 *    super:只有在继承条件下才可以使用
 * 3、构造方法：
 *    this():本类的构造
 *    super():父类的构造
 */
public class Person3 {
    public Person3(){
        System.out.println("我是Person3无参构造方法");
    }
    public void print(){
        System.out.println("Person3");
    }
}

package cn.ecut.oop6;

public class Student3 extends Person3 {
    public Student3(){
        //隐藏代码：默认调用父类的无参构造方法
        //super();
        System.out.println("我是Student3无参构造方法");
    }

}

package cn.ecut.oop6;

public class Test3 {
    public static void main(String[] args) {
        Student3 s3=new Student3();

    }
}

运行结果：

我是Person3无参构造方法
我是Student3无参构造方法
继承四

源代码：

package cn.ecut.oop6;

public class Person4 {
    public void test(){
        System.out.println("我是父类中的方法");
    }

}

package cn.ecut.oop6;

public class Student4 extends Person4{
    public void test(){
        System.out.println("我是子类的方法");
    }
}

package cn.ecut.oop6;

/**
 * 重写：需要有继承关系，子类重写父类的方法！
 * 1、方法名必须相同
 * 2、参数列表必须相同
 * 3、修饰符：范围可以扩大但不能缩小：public>protected>Default>private
 * 4、抛出的异常，可以被缩小，旦不能扩大
 * 5、只有方法体不同
 */
public class Test4 {
    public static void main(String[] args) {
        Student4 s4=new Student4();
        s4.test();
        //父类的引用指向了子类
        Person4 p4=new Student4();
        p4.test();//因为子类重写了test方法,所以调用子类的方法，如果没重写则调用父类
    }
}

运行结果：

我是子类的方法
我是子类的方法
多态一

源代码：

package cn.ecut.oop7;

/**
 * 多态
 * 1、同一个方法可以根据发送对象的不同而采用多种不同的行为方式
 * 2、一个对象的实际类型是确定的，旦可以指向对象的引用的类型有很多
 * 多态的存在的条件
 * 1、有继承关系、
 * 2、子类重写父类方法
 * 3、父类引用指向子类对象
 * 注意：多态是方法的多态，属性没有多态
 */
public class Person1 {
    public void run(){
        System.out.println("father");
    }
    public void add(){
        System.out.println("父类的add方法");
    }
}

package cn.ecut.oop7;

public class Student extends Person1{
    @Override
    public void run() {
        System.out.println("son");
    }
    public void print(){
        System.out.println("我是子类独有的方法");
    }
}

package cn.ecut.oop7;

public class Teacher1 extends Person1 {

}

package cn.ecut.oop7;

import cn.ecut.oop4.Person;

public class Test1 {
    public static void main(String[] args) {
        //Student子类型能调用的都是自己的方法或者继承父类的
        Student s1=new Student();
        //Person父类型，可以指向子类，但是不能调用子类独有的方法
        //不能调用Student子类独有的print()方法
        Person1 p1=new Student();
        s1.run();//子类调用自己重写的方法
        s1.add();//子类调用继承父类的方法,该方法没有重写
        s1.print();//子类调用自己独有的方法
        p1.run();//父类调用子类重写的方法
        p1.add();//父类调用自己方法,如子类重写了该方法，则调用子类重写的方法，如run()方法
        System.out.println("====================================");
        /*
        Object>String
        Object>Person>Student
        Object>Person>Teacher
         */
        Object object=new Student();
        Teacher1 t1=new Teacher1();
        System.out.println(object instanceof Student);
        System.out.println(object instanceof Teacher1);
        System.out.println(object instanceof Person1);
        System.out.println(object instanceof Object);
        System.out.println(object instanceof String);
        System.out.println("====================================");
        Person1 person=new Person1();
        System.out.println(person instanceof Object);
        System.out.println(person instanceof Person1);
        System.out.println(person instanceof Teacher1);
        System.out.println(person instanceof Student);
        //System.out.println(person instanceof String);  编译报错！同级别
        System.out.println("====================================");
        Student student=new Student();
        System.out.println(student instanceof Object);
        System.out.println(student instanceof Person1);
        System.out.println(student instanceof Student);
        //System.out.println(person instanceof String);  编译报错！同级别
        //System.out.println(student instanceof Teacher1); 编译报错！同级别
    }
}

运行结果：

son
父类的add方法
我是子类独有的方法
son
父类的add方法
====================================
true
false
true
true
false
====================================
true
true
false
false
====================================
true
true
true
多态二

源代码：

package cn.ecut.oop7;

/**
 * 加载顺序：
 * 静态>匿名>构造
 */
public class Person2 {
    public static void main(String[] args) {
        Person2 person2=new Person2();
    }

    {
        System.out.println("匿名代码块");
    }
    static{
        System.out.println("静态代码块");
    }
    public Person2(){
        System.out.println("构造方法");
    }
}

运行结果：

静态代码块
匿名代码块
构造方法
静态导入包

源代码：

package cn.ecut.oop7;

/**
 * 静态导入包
 */
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Student2 {
    public static void main(String[] args) {
        System.out.println(random());
        System.out.println(PI);
    }
}

运行结果：

0.4422312524381393
3.141592653589793
对象类型转换

源代码：

package cn.ecut.oop7;



/**
 * 对象引用类型之间的转换
 * 父——子  子——父
 * 把子类转换成父类，向上转型
 * 把父类转换成子类，向下转型，需要强制转换
 */
public class Test2 {
    public static void main(String[] args) {
        Student student=new Student();
        student.print();
        Person1 person1=student;//子类转为父类,可能丢失自己独有的方法，person1没有print()方法，类似于数据类型的精度丢失。
        Student student2=(Student) person1;//父类转为子类，需要进行强制类型转换。
        student2.print();
    }
}

运行结果：

我是子类独有的方法
我是子类独有的方法
抽象类

源代码：

package cn.ecut.oop8;

/**
 * 抽象类 abstract
 * 1、abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法，如果修饰类，那么该类就是抽象类
 * 2、抽象类中可以没有抽象方法，但是抽象方法的类一定要声明为抽象类
 * 3、抽象类不能使用new关键字来创建对象，它是用来让子类继承的。
 * 4、抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的。
 * 5、子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。
 */
public abstract class Person1 {
    public abstract void run();
}

package cn.ecut.oop8;

public class Student1 extends Person1{

    @Override
    public void run() {
        System.out.println("实现父类的抽象方法");
    }
}

package cn.ecut.oop8;

public class Test1 {
    public static void main(String[] args) {
        Student1 student=new Student1();
        student.run();
    }
}

运行结果：

实现父类的抽象方法
接口

源代码：

package cn.ecut.oop9;

/**
 * 接口
 * 1、接口就是规范，定义的是一组规则。
 * 2、接口的本质是契约，就像法律。
 * 普通类：只有具体实现
 * 抽象类：具体实现和规范（抽象方法）
 * 接口：只有规范
 */
//interface关键字
public interface UserService {
    //常量：public static final
    int AGE=20;
    //接口中的所有定义的方法其实都是抽象的 public abstract
    void add(String name);
    void query(String name);
    void update(String name);
    void delete(String name);
}

package cn.ecut.oop9;

/**
 * 抽象类：extends
 * 接口：implements 实现了接口的类，就需要重写接口中的方法
 * 抽象类只能单继承 接口可以实现多继承
 */

/**
 * 接口作用：
 * 1、约束作用
 * 2、定义一些方法，让不同的人实现
 * 3、public abstract
 * 4、public static final
 * 5、接口不能被实例化，接口中没有构造方法
 * 6、implements可以实现多个接口
 * 7、必须要重写接口中的方法
 */
public class UserServiceImpl implements UserService{
    @Override
    public void add(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void delete(String name) {

    }
}
内部类
①成员内部类

源代码：

package cn.ecut.oop10;

/**
 * 内部类：在一个类的内部再定义一个类
 * 1、成员内部类
 * 2、静态内部类
 * 3、局部内部类
 * 4、匿名内部类
 */
//①成员内部类
public class Outer1 {
    private int id=10;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    //成员内部类可以访问外部类的私有属性
     class Inner1{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        public void getID(){
            System.out.println(id);
        }
    }
}

package cn.ecut.oop10;

public class Test1 {
    public static void main(String[] args) {
        Outer1 outer = new Outer1();
        //通过外部类来实例化内部类
        Outer1.Inner1 inner = outer.new Inner1();
        inner.getID();
    }
}

运行结果：

10
②静态内部类

源代码：

package cn.ecut.oop10;

//②静态内部类
public class Outer2 {
    public int age=20;
    private int id=10;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    //静态内部类无法访问外部类所有属性
     static class Inner2{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        public void getID(){
            System.out.println("无法获取外部类的属性");
        }
    }
}

package cn.ecut.oop10;

public class Test2 {
    public static void main(String[] args) {
        Outer2 outer2=new Outer2();
        //静态内部类实例化
        Outer2.Inner2 inner2=new Outer2.Inner2();
        inner2.in();
    }
}

运行结果：

这是内部类的方法
③局部内部类

源代码：

package cn.ecut.oop10;

//③局部内部类
public class Outer3 {

    public void method(){
        class Inner3{
            public void in(){
                System.out.println("我是局部内部类的方法");
            }
        }
        //在方法内实例化局部内部类，下面两行不能在局部内部类之前声明
        Inner3 inner3=new Inner3();
        inner3.in();
    }

}

package cn.ecut.oop10;

public class Test3 {
    public static void main(String[] args) {
        Outer3 outer3=new Outer3();
        outer3.method();

    }

}

运行结果：

我是局部内部类的方法
④匿名内部类
package cn.ecut.oop10;

//④匿名内部类
public class Test4 {
    public static void main(String[] args) {
        //没有名字初始化类，不用讲实例保存在变量中
        new Person().study();
        UserService userService=new UserService() {
            @Override
            public void add() {
                System.out.println("add...");
            }
        };
    }

}
class Person{
    public void study(){
        System.out.println("Studing");
    }
}
interface UserService{
    public void add();
}

运行结果：

Studing
yu&2022
关注
专栏目录
面向对象的基本概念
weixin_71643873的博客
07-19 789
httpshttpshttpshttpshttpshttpshttpshttpshttps。
15.面向对象
qq_40521306的博客
07-05 102
面向对象 //实例化这个类new //对象类型 对象名 = 对象值 Student student = new Student(); student.say(); Java的方法的参数是值传递 类是一种抽象的数据结构 类是一个模板：抽象，对象是一个具体的实例 以类的方式组织代码，以对象实例化 构造器 1.和类名相同 1.没有返回值 作用： 1.new 本质调用无参构造器 2.初始化对象的值 注意点： 一个类即使什么都不写，它也会存在一个方法 //1.使用new关键字，本质是在调用构造器 //用来初始化值 p
面向对象基本定义及概念
relax
08-15 6736
面向对象的基本特征 抽象： 抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。 继承： 继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始
面向对象定义
a296191519的专栏
09-04 83
面向对象的编程的核心思想是，将程序中的实体、数据和功能抽象为单独的对象，并在这些对象之间建立联系。面向对象：易复用，已维护，易扩展，面向对象封装、继承、多态的特性，让其可以设计出低耦合的系统，是系统更加灵活，更易于维护，缺点就是性能比面向过程差。面向过程：性能比面向对象好，因为类的调用需要实例化，开销比较大，比较消耗资源。缺点就是不易维护，不易复用，不易扩展。面向对象的底层其实还是面向过程，把面向过程抽象成类，然后封装，方便我们使用就成为了面向对象。
第04章 面向对象（上） 01 面向对象基本概念
最新发布
09-12
面向对象编程（Object-Oriented Programming，简称...以上是面向对象基本概念的概述，学习这些概念有助于理解和应用Java中的面向对象编程。在实际开发中，熟练掌握这些知识能帮助我们编写出更加高效、易于维护的代码。
面向对象基本概念面向对象基本概念
12-15
面向对象基本概念,面向对象基本概念,面向对象基本概念
2面向对象基本概念1
08-03
本模块主要介绍了面向对象的基本概念和原理，以及如何使用统一建模语言（UML）来表示这些概念。 首先，我们讨论了模型在系统设计中的重要性。模型可以帮助我们可视化理想中的系统，使我们能够清晰地表达出对系统...
系分 - 面向对象的方法【概念】
初八
01-02 1199
面向对象的方法（OO，Object-Oriented）是一种基于对象模型的程序设计方法，包括面向对象的分析（OOA，Object-Oriented Analysis）、面向对象的设计（OOD，Object-Oriented Design）、面向对象的程序设计（OOP，Object-Oriented Programming），是目前应用范围最广的设计方法。
面向对象之方法的定义
qq_38787854的博客
07-29 751
方法：即功能，封装了一段逻辑代码。 方法的定义：      固定语法：      修饰词  返回值类型  方法名(形式参数){         逻辑代码      } 方法的位置：      在类体中，与main方法是并列关系（在main方法外，类里），类体中可以有      多个方法。 修饰词：     (1)public--公共的         (2)protected--受保护的  ...
Java面向对象基本概念及基本概念
数据装修师
05-14 634
Java面向对象基本概念及基本概念 面向对象的思想总结 系统以对象为中心来组织 对象相互间发送消息 相关的属性和行为被统一到对象上 关注的焦点是对象及对象的职责 使得系统构建更容易，易维护，易扩展，易复用 解决问题的方式更接近人的思维方式，使人更容易理解 面向对象基本概念 面向对象基本概念抽象 abstract对象 object类 class 抽象（abstract） 从事物中舍弃...
浅谈面向对象的基本概念
php_Alen的博客
02-23 712
面向对象的三大特性：封装、继承、多态 面向对象类的封装、实例化 面向对象最常用的构造方法和析构方法的使用
面向对象的基本概念（前篇）
JDBC400451的博客
07-15 327
面向对象（基础部分） 一、对象（objecrt） 两方面含义： 1、客观世界中的实体 2、可标识的存储区域 二、类（class） 1、类：具有共同属性和行为的对象集合 （1）属性：变量（字段） （姓名、年龄等） （2）行为：函数（方法） 2、类与对象的关系 （1）类是对象的抽象（模板） （2）对象是类的实例 三、面向对象的三大特征 封装、继承、多态 1、封装 （1）模块化：将属性和行为都封装在类中 （2）信息隐蔽：将类的细节部分隐藏起来，用户只通过受保护的接口访问某个类 2、继承 （1）继承性：父类和子类之
Java面向对象基本概念和特征：类、对象、继承、封装、多态等。
除了这些基本概念和特征，面向对象编程还包括其他重要的概念和技术，如抽象、接口、消息传递、关联和聚合等。抽象是指将事物的共性提取出来形成抽象类或接口，用于定义具体对象的共同行为。接口是一种具有定义行为的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值