5.面向对象_super(); } public static void main(string[] args) -CSDN博客

本文链接：https://blog.csdn.net/m0_46347709/article/details/123192272

本文深入探讨了面向对象编程的核心概念，包括类与对象的创建，封装、继承和多态的原理及应用。通过示例代码展示了值传递与引用传递的区别，并介绍了构造器的作用。此外，还涵盖了抽象类、接口、内部类、异常处理以及静态代码块等相关知识点，旨在帮助读者全面理解面向对象编程的本质和实践技巧。

摘要由CSDN通过智能技术生成

面向编程的本质

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

抽象的编程思想

三大特性：封装，继承，多态

值传递

按值传递重要特点：传递的是值的拷贝，也就是说传递后就互不相关了。
示例如下：

public class TempTest {  
private void test1(int a){  
a = 5;  
System.out.println("test1方法中的a="+a);  
}  
public static void main(String[] args) {  
TempTest t = new TempTest();  
int a = 3;  
t.test1(a);//传递后，test1方法对变量值的改变不影响这里的a  
System.out.println(”main方法中的a=”+a);  
}  
} 

运行结果是：
test1方法中的a=5  
main方法中的a=3

引用传递

传递的是值的引用，也就是说传递前和传递后都指向同一个引用（也就是同一个内存空间）。
示例如下：

public class TempTest {  
private void test1(A a){  
a.age = 20;  
System.out.println("test1方法中的age="+a.age);  
}  
public static void main(String[] args) {  
TempTest t = new TempTest();  
A a = new A();  
a.age = 10;  
t.test1(a);  
System.out.println(”main方法中的age=”+a.age);  
}  
}  
class A{  
public int age = 0;  
}  
运行结果如下：

test1方法中的age=20  
main方法中的age=20

Aplication类

//一个项目应该只有一个测试类
public class Application {
    public static void main(String[] args) {

        //类是抽象的，实例化
        //类实例化后会返回一个自己的对象
        //student对象就是一个Student类的具体实例

        Student xiaoming = new Student();
        Student xiaohong = new Student();

        xiaoming.name="小明";
        xiaoming.age=3;
        xiaohong.name="小红";
        xiaohong.age=3;

        System.out.println(xiaohong.age);
    }
}

Student类

//学生类
public class Student {
    //属性：字段
    String name; //null
    int age;  //0

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

构造器（构造方法）

必须与类的名字相同
必须没用返回类型，也不能解void
创建对象的时候必须要调用

一个类即使什么都不写，它也会存在一个方法(构造器)

public class Person {

    String name;

    //实例化初始值
    //1.使用new关键字，必须要有构造器
    //2.用来初始化值
    public Person(){
        this.name = "qiuhan";
    }

    //有参构造：一旦定义了有参构造，无参就必须显示定义
    public Person(String name){
        this.name = name;
    }![762fe773265c2811edd53d70dcc35a8](../../../../系统缓存/WeChat Files/762fe773265c2811edd53d70dcc35a8.jpg)

}

快捷键:Alt + insert 生成无参/有参的构造器

创建对象内存分析

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-REDHZzMv-1646053456931)(…/…/…/…/系统缓存/WeChat Files/762fe773265c2811edd53d70dcc35a8.jpg)]

面向对象小结

类与对象

类是一个模板，是抽象的，对象是具体的
对应的引用：栈–>堆
属性：字段Field 成员变量

默认初始化

封装

追求：高内聚 类的內部数据操作细节自己完成，不允许外部干涉

低耦合 仅暴露少量的方法给外部使用

每个模块之间相互联系的紧密程度，模块之间联系越紧密，则耦合性越高，模块的独立性就越差！反之同理；

一个模块中各个元素之间的联系的紧密程度，如果各个元素（语句、程序段）之间的联系程度越高，则内聚性越高，即‘高内聚’ ！

如: 一个项目中有20个方法调用良好，但是要修改了其中一个，另外的19个都要进行修改，这就是高耦合！独立性太差！

属性私有：创建成员函数 get/set (alt+insert)

继承

继承的本质是对某一批类的抽象，从而对现实世界更好的建模

java中只有单继承，没有多继承

继承是类和类之间的一种关系，除此之外还有依赖，组合，聚合等

Alt+f4：显示族谱

super : 父节点的方法和属性(只有public和protected)

super(“name”); 调用父类的有参，如果父类只定义有参构造函数

//若Person是Student的父类
public Student(){
  //隐藏代码:调用了父类的无参构造（当new Student的时候）
  super();//调用父类构造器，必须要在子构造器的第一行
  System.out.println("Student无参执行了");
}

super注意点

super调用父类的构造方法，必须在构造方法的第一个
super必须只能出现在子类的方法或者构造方法中
super和this不能同时调用构造方法

vs this:

对象不同
前提不一样 this在没继承的时候也可以使用
构造方法: this() 本类的构造

super() 父类的构造

//静态方法：方法的调用只和定义的数据类型有关
        //静态方法和非静态的方法区别很大！
        A a = new A();
        a.test();
        //父类的引用指向子类
        B b = new A();//子类重写了父类的方法,只与非静态有关,只能是public
        b.test();

重写：需要有继承关系，子类重写了父类的方法

方法名必须相同
参数列表必须相同
修饰符：范围可以扩大 public > protected > Default > private
抛出的异常：范围可以被缩小，但不能扩大: ClassNotFoundException–> Exception(大)

为什么需要重写？

父类的功能，子类不一定需要，或者不一定满足！

Alt + Insert : override

多态

定义：同一个方法可以根据发送对象的不同而采用多种不同的行为方式

多态是方法的多态，属性没有多态
父类和子类才有联系 Person s1 = new student(); 类型转换异常：ClassCastExpetion！
存在条件：继承关系，方法需要重写,父类引用指向子类对象！ Father f1 = new Son();
static 方法，属于类，它不属于实例
final 常量
private方法不可以重写

X instanceof Y ：看x和y是否有继承关系

//高              低
Person obj = new Student();
//student将这个对象转换为Student类型，我们就可以使用Student类型方法了
Student student = (Student) obj;
student.go();

父类引用指向子类的对象
把子类转换为父类，向上转型
把父类转换为子类，向下转型：强制转换
方便方法的调用，减少重复的代码！简洁

Static

public class Person {
    {
        System.out.println("匿名代码块");
    }
    //静态代码块只执行一次
    static {
        System.out.println("静态代码块");
    }

    public Person() {
        System.out.println("构造方法");
    }

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

结果：静态代码块
     匿名代码块
     构造方法
     ===============
     匿名代码块
     构造方法
     
//静态导入包
import static java.lang.Math.PI;
import static java.lang.Math.random;

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

        System.out.println(random());
        System.out.println(PI);
    }
}

抽象类abstract

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

接口

只有规范！自己无法写方法专业的约束！约束和实现分离：面向接口编程

作用：

约束
定义一些方法，让不同的人实现
方法都是public abstract
常量都是public static final
接口不能被实例化，接口没有构造方法
implements可以实现多个接口
必须要重写接口中的方法~

public interface UserService {
    //静态常量
    public static int age = 99;

    //接口中的所有定义都是抽象的public abstract
    public abstract void run(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}
public class UserServiceImpl implements UserService,TimeService{

    @Override
    public void run(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}

内部类

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

Outer outer = new Outer();
    //通过这个外部类进行实例化内部类
    Outer.Inner inner = outer.new Inner();
    inner.getID();

异常

Exception

软件程序在运行过程中，非常可能遇到很多异常问题

异常指程序运行中出现的不期而至的各种状况：文件找不到，网络连接失败

public static void main(String[] args) {
        int a = 1;
        int b = 0;
        
        //假设要捕获多个异常：从小到大  ctrl+alt+t
        try{//监控区域
            if(b==0){
                throw new ArithmeticException();//主动抛出异常
            }
            
            System.out.println(a/b);
        }catch (ArithmeticException e){//catch中是想要捕获异常的内容
            System.out.println("危险危险");
        }finally {//处理善后工作
            System.out.println("finally");
        }
    }
    
    public void test(int a,int b) throws ArithmeticException{
        if (b==0){
            throw new ArithmeticException();
        }
    }