面向对象编程(oop)

面向对象编程(oop)

  1. 初识面向对象(先有类再有对象)

    • 面向对象是框架

      本质：以类的方式组织代码，以对象形式封装数据

      抽象：抽取出相似的部分

    • 面向过程是流程

      • 属性+方法=类(类是抽象的，必须实例化)
        public String st(){
        return "hello";
    }                                      //除了void以外的其他类大多都有返回值

    public void ms(){
        return;
    }                                     //void没有返回值，如果写return直接为return；就可以

  2. 方法回顾和加深

    return a>b ? a:b;     // a>b吗，成立则返回a，否则就返回b

    修饰符：public，private，static等

    break：跳出switch循环，结束整个循环

    return：表示方法结束

    Continue：方法暂时性的结束

    参数列表：（参数类型，参数名）（... 可变常参数）

    抛出异常：throw

    分屏：右击项目标签——点击split right（左右进行分屏）

  3. 对象的创建分析

    • 两个静态类可以相互调用，两个不同类型的类进行调用需要转换new如下：

      public static void main(String[] args) {    // static是实例化的
public void main(String[] args) {           // 没有经过实例化的(类值不存在)
d1 D1=new d1();                    //实例化的类不能调用没实例化的类，两个都没实例化的类可以相互调用，new可转实例化
new d1().say()
D1.say

      package oop;

public class d2 {
    public static void main(String[] args) {      // 静态类是经过实例化的，没有实例化的类在调用的时候需要new
        new d1().say();                           //new一个d1调用d1里面的say属性值
    }
}


package oop;

public class d1 {
    public void say(){                            // 非静态的类没有经过实例化，
        System.out.println("说话ba");
    }

} 

说话ba
      • 形参
      int[] a={1,5,9,3,4,7,8};
public static void s(int[] a){
      • 值传递(传值给形参)
          public static void main(String[] args) {
        int a=5;
        System.out.println(a);
        d3.change(a);                        // 调用change方法
        System.out.println(a);
    }
    public static void change(int a){
        a=10;
    }


5
5
      • 引用传递(传地址给形参)
      package oop;

public class d1 {
    public static void main(String[] args) {
        change l = new change();    // 调用的class.change中的值
        System.out.println(l.name); // 值返回null
        d1.c(l);                    // 调用new change()--值是null，但change g的值为"秦江"
        System.out.println(l.name); //返回具体地址为"秦江"
    }
    public static void c(change g){
        g.name="秦江";
    }
}
class change{
    String name;                  // String默认值是null

}

null
秦江
    
    
package oop;
public class d3 {
    public static void main(String[] args) {
        dog a = new dog();
        System.out.println(a.name);        // 输出的是a对象下面name的值
    }
}
class dog{
    String name="hello";
        }    



      package oop;

public class Application {
    public static void main(String[] args) {
        Student a=new Student();
        Student b=new Student();
    a.name="小红";
    a.age=18;
    b.name="大明";
    b.age=90;
        System.out.println(a.name);
        System.out.println(a.age);
        System.out.println(b.name);
        System.out.println(b.age);
    }
}


package oop;

public class Application {
    public static void main(String[] args) {
        Student a=new Student();
        Student b=new Student();
    a.name="小红";
    a.age=18;
    b.name="大明";
    b.age=90;
        System.out.println(a.name);
        System.out.println(a.age);
        System.out.println(b.name);
        System.out.println(b.age);
    }
}


小红
18
大明
90
      • 创建与初始化对象
        1. 必须和类的名字相同
        2. 必须没有返回值，也不能写void
      1. 使用new方法的时候必须要有构造器
      2. 用来初始化值（一旦使用了无参构造就不要删除了，让它空着）
      package oop;

public class Application {
    public static void main(String[] args) {
        person s=new person();              // 在person类中新建了一个对象
        System.out.println(s.name);
    }
}



package oop;

public class person {
    String name;
    public person(){                       // 无参构造,实例化初始化对象的值(构造器)
        this.name="nihao";
    }
}


nihao

      package oop;

public class Application {
    public static void main(String[] args) {
        person s=new person("kaungshen");              // 在person类中新建了一个对象
        System.out.println(s.name);
    }
}



package oop;

public class person {
    String n;
    public person(){             // 无参构造,实例化初始值
    }
    public person(String name){  // 在无参基础上进行有参构造的时候，无参构造不可删
        this.n=name;
    }
}

kaungshen

      属性的定义：修饰符 属性类型 属性名 = 属性值

      对象的创建和使用：

      • 要有new，构造器: person K1=new person( ) ;
      • 对象的属性 : K1.name=" " ;
      • 对象的方法：K1.sleep( ) ;

      类：

      • 静态属性：属性
      • 动态行为：方法

  4. 面向对象的三大特征

    • 封装：将一个东西封存起来

      • “高内聚，低耦合”

        高内聚：内部数据自己完成，不允许外部干涉

        低耦合：仅需要少量的方法给外部使用

      • 属性私有(privte)，get--获取/set--设置 ( )

    package oop;

import java.util.Arrays;

public class Student {
    //名字
    private String name;      // private 私有化
    // 学号
    private int id;
    // 性别
    private char sex;
    public String getName(){
        return this.name;
    }
    public void setName(String name){
        this.name=name;
    }

}


    public class Student {
    //名字
    private String name;      // private 私有化
    // 学号
    private int id;
    // 性别
    private char sex;
    private int age;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age<100) {
            this.age = age;
        }else {
            this.age=3;
        }
    }
    public String getName(){
        return this.name;
    }
    public void setName(String name){
        this.name=name;
    }
    public Student() {
        this.name = name;
        this.age = age;
}
}
     

            
package oop;

public class Application {
    public static void main(String[] args) {
        Student s1=new Student();              // 在person类中新建了一个对象
        s1.setName("nihao");
        s1.setAge(9000);
        System.out.println(s1.getName());
        System.out.println(s1.getAge());
    }
}

            
3

    • 继承：子类继承父类(java单继承，有多态)如果存在继承关系，父类中的class不能加public

      public class Student extends person {     // person是父类，student是子类
}

      object是祖宗类

      extends : 表示继承 相当于 is a

      super：指向父类的字符串

      1. super调用父类的构造方法，必须在构造方法的第一个
      2. super只能出现在sout的上方
      3. super和this不能同时出现

      • this：调用子类对象

        super：父类对象的引用

      • 前提：1. this没有继承也可以使用

        ​ 2.super只能在继承条件下使用

      • this( ) ：默认调用的本类构造

        super( ) ：默认调用父类构造

      package oop;

public class Student extends person {
    private String say="nihao";
    public void hi(String say) {
        System.out.println(say);       // nihao
        System.out.println(this.say);  // hhhh
        System.out.println(super.say); // 说了一句话
    }
}



package oop;

public  class person {
    protected String say="说了一句话";
}




package oop;

public class Do {
    public static void main(String[] args) {
        Student Student = new Student();
        Student.say("hhhh")
    }
}

      父子类代码调用及运行：

      package d5.oop;
public class Student extends Person {       // 子类代码
    public Student() {
        System.out.println("Student");
    }
}



package d5.oop;                              // 父类代码
class Person {
    public Person() {
        System.out.println("person");
    }
}




package d5.oop;                                 // 运行代码
class Do {
    public static void main(String[] args) {
        Student student = new Student();
    }
}



person
student
      • super--可以调private值（必须放在子类，放sout上面，构造参数最好有参无参都写，this跟super不能同时出现）
          public Student(String A) {
        super();                            // 不管是super还是this都要放在System.out.println的前边
        this.B=A;
        System.out.println("nihao");
    }
      • 不加static字符类之间的调用 **注：person中的class前面不能加public ** （进行重写了）
      package d5.oop;

public class Student extends Person {
    public void hello(){
        System.out.println("nihao");
    }
}
class S{
    public void hello(){
        System.out.println("hhj");
    }
}


package d5.oop;                                  // 运行代码

public class Do {
    public static void main(String[] args) {
        Student a=new Student();
        a.hello();
        S b = new S();
        b.hello();
        Person m = new Student();               // 父类的引用指向子类
        m.hello();
    }
}



package d5.oop;

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


nihao
hhj
nihao
      • 加static字符之间的调用（没有进行重写）
      package d5.oop;

public class Student extends Person {
    public static void hello() {
        System.out.println("iiii");
    }
}
class S{
    public void hello(){
        System.out.println("hhj");
    }

}


package d5.oop;

public class Do {
    public static void main(String[] args) {
        Student a=new Student();
        a.hello();
        S b = new S();
        b.hello();
        Person m = new Student();
        m.hello();
    }
}

package d5.oop;

class Person {
    public static void hello(){
        System.out.println("lll");
    }
}


iiii
hhj
lll

      注：有静态类的时候调用的是类的方法，没有静态类的时候调用的是对象的方法

      在运用构造器的时候要么调用父类--super，要么调用子类--this

      this：指向子类的字符串

    • 多态：不同的人有不同的表现形态

      方法重写是方法名参数列表都不变（方法重写不等于方法重载）[重写是方法的重写，与属性值无关]

      方法重载是方法名不变参数列表改变[重载是复用]

      重写 : (快捷键：alt+enter override）

      1. 方法名必须相同
      2. 参数列表想同
      3. 方法体不同
      4. 修饰符范围可以扩大但不能缩小 ：public>protected>default>private
      5. 抛出异常只能缩小不能扩大 ： ClassNotFandException—>Exception

    • ![](E:\屏幕截图 2025-01-25 142150.png)

    • 在重写时如果两个类方法不一样则不能进行重写,不能调用子类独有的方法（如上图）

  • 多态：

  1. 多态是方法的多态，属性没有多态

  2. 父类和子类有联系如果内部方法不同也是不能相互转换

  3. 存在的条件：继承关系，方法需要重写，父类的引用指向子类对象

  4. 不能进行重写赋值 (没有多态) ：

    static方法属于类，不属于实例 final 在常量池里面(断子绝孙) private 方法

instanceof ：类型转换（强制转换，自动转换）

  1. 判断一个对象是什么类型

  2. 输出：
true
true
true
false
    • System.out.println(x instanceof y); // 看x跟y之间是否存在父子关系,存在返回true，否则返回false
    1. 强制转换：** * **（只能父类的引用指向子类的对象，不能子类的引用指向父类）父类—子类
            Person a=new Student();            // 高转低
        Student a1 = (Student) a;          // 将person强转Student类型
                                                  父类      子             
       ((Student)a).go();                  //强制转化为Student类型并调用Student类中的go方法    
        

        Student m=new Student()
        Person k=m;                        // 从低到高
        k.hello();

// 低转高时，子类已经继承了父类的所有，删去子类后可以转向父类。高转低时，需要重新开辟属于子类的空间，进行强制转换

  3. static关键字:（输出的时候最先输出）

    package d5.oop;

public class Student{
    static {
        System.out.println("静态代码块");//静态代码块(最先执行)    静态类代码
    }
    public Student() {               
        System.out.println("构造方法");//构造代码块(最后执行)    构造的无参
    }
    public static void main(String[] args) {
        new Student();
    }
    {
        System.out.println("匿名代码块");//匿名代码块(第二个执行的)   赋初始值
    }
}


静态代码块
匿名代码块
构造方法
    
    
    
package d5.oop;

public class Student{
    static {
        System.out.println("静态代码块");//静态代码块(最先执行)
    }
    public Student() {
        System.out.println("构造方法");//构造代码块(最后执行)
    }
    public static void main(String[] args) {
        new Student();
        System.out.println("代码块");//匿名代码块(第二个执行的)
    }
}


静态代码块
构造方法
代码块
    
// 注意匿名代码块跟运行下的代码块输出顺序不一样

    在调用构造无参函数的时候一定要先new一个一个无参函数

  4. 抽象类 和 接口(类是单继承，接口是多继承)

    package d5.oop;

public abstract class Student{           // 抽象类
    public abstract void doSomething();  // 抽象方法
}
    • abstract：抽象类中可以写普通方法

    ​ 抽象方法必须在抽象类中

    ​ 不能new只能靠子类去实现约束 (存在构造器)

    ​ 存在意义：节省代码的开发

    Person：抽象

    Student：接口

    teacher : 类

    • 接口（接口里面的方法可以不写public）：

    impement : 一个类要实现一个接口 (重写)

    interface：定义一个接口

    在接口里面定义常量必须定义静态常量如：public static final int j=33;

    接口不能被实例化，接口中没有构造方法

    通过implements可以实现多个接口，实现多个接口的同时必须要将接口进行重写

    package d5.oop;

public interface teacher {
    
    void time();
}


package d5.oop;

public class UserSeverletmp implements Student,teacher {
    @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 d5.oop;

public interface Student{
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}
    • 在接口中定义一个常量：
    package d5.oop;

public interface teacher {
    public static final int j=33;
    void time();
}
    1. 内部类及oop实战
    • 成员内部类：
    package d9;

public class Outer {
    private int id=6952256;                      // 内部类可以获得外部类的私有属性
    public void out(){
        System.out.println("这是外部类的方法");
    }
    public class Inper{                          // 在public后面不可以加static，否则将不能调用私有属性
        public void in(){
            System.out.println("这是内部类的方法");
        }
        public void getID(){
            System.out.println(id);
        }
    }
}


package d9;

public class hello {
    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inper inper = outer.new Inper();
        inper.in();
        inper.getID();
    }
}


这是内部类的方法
6952256                                 // ** 一个java类文件只能有一个public文件，但是可以有多个class文件**
    • 静态内部类：
    public class User {
    private String name;
    private int age;

    // 封装静态内部类的 Builder实例
    public static class Builder {
        private String name;
        private int age;

        public Builder setName(String name) {
            this.name = name;
            return this;
        }
    }
}
    • 局部内部类：
    package d5.oop;

public class teacher {
    public void hello(){
        class in{
            public void i(){
                
            }
        }
    }
}
    • 匿名内部类：
    package d5.oop;

public class teacher {
    public static void main(String[] args) {
        apple apple = new apple();             // 有名字的初始化类
        new apple().eat();                     // 没有名字的初始化类
        new UserService(){                     // 创建一个新类的时候必须要在调用之前重新new一个对象

            @Override
            public void hello() {

            }
        };
    }
}
class apple{
    public void eat(){
        System.out.println("1");
    }
}
interface UserService{                        // 创建接口的时候必须要进行重写
   void hello();
}


1
    
// 创建接口的时候必须要进行重写，创建一个新类的时候必须要在调用之前重新new一个对象

  5. 重点：alt+insert(生成构造器)，alt+enter(自动导入包，纠正错误)

    声明类的关键词：class

    声明接口的关键词：interface

posted @   FoxDusk  阅读(13)  评论(0)  编辑  收藏  举报
相关博文：
·  JAVA数组
·  （基础+运算符+流程控制）相关案例和重点
·  面向对象编程 OOP
·  面向对象编程
·  面向对象编程
阅读排行：
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· Manus的开源复刻OpenManus初探
· AI 智能体引爆开源社区「GitHub 热点速览」
· 三行代码完成国际化适配，妙~啊~
· .NET Core 中如何实现缓存的预热？
点击右上角即可分享
微信分享提示
SQL AI 助手