[JAVA-5]面向对象编程

思想

什么是面向对象

方法详解

package com.oop;

import java.io.IOException;

//demo01 类
public class demo01 {
    //main方法
    public static void main(String[] args) {

    }
    
    //return 结束方法，返回一个结果
    public String  sayHello(){
        return "hello world";
    }
    //完整的方法，抛出异常
    public void readFile(String fileName) throws IOException {

    }
}

package com.oop;

//学生类
public class Student {
    //非静态方法
    public void say(){
        System.out.println("学生说话了");
    }
    //静态方法
    public static void eat(){
        System.out.println("学生偷吃了");
    }
}

package com.oop;

public class demo02 {
    public static void main(String[] args) {
        //类外
        //非静态方法，在不同类中用new构建对象调用
        Student student = new Student();
        student.say();

        //静态方法，直接用类调用
        Student.eat();
    }
    //类内
    //1.同一个类中都是非静态方法，可以直接互相调用
    //2.同一个类中都是静态方法，可以直接互相调用
    public void a(){
        b();
    }
    public void b(){}
    //3.同一个类中,一个非静态方法可以直接调用静态方法
    //4.同一个类中，一个静态方法不可以直接调用非静态方法
    //原因：static静态方法是和类一起加载的，他的时间片特别早
    //      非静态方法是类实例化 之后才存在的
    public  void a1(){
        b();
    }
    public static void b1(){}

}

值传递和引用传递

package com.oop;

//值传递,JAVA都是值传递
public class demo03 {
    public static void main(String[] args) {
        int a=1;
        System.out.println(a);//1
        change(a);
        System.out.println(a);//1
    }
    //返回值为空
   public static void change(int a){
        a=10;
	}
}

package com.oop;

//引用传递:传递的是对象，本质还是值传递
public class demo04 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);//null
        change(person);
        System.out.println(person.name);//叶说喜欢你
    }
    public static void change(Person person){
        person.name="叶说喜欢你";
    }
}
//一个类里面只能有一个public class，可以有无数个class
//定义了一个类person,里面有一个属性：name。
class Person{
    String name;//null
}

类和对象的关系

package com.oop.Demo;

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

    //使用new关键字，本质是在调用构造器
    //无参构造
    public Student(){
    }

    //有参构造
    //一旦定义有参构造，无参就必须显示定义
    //alt+insert快捷构造
    public Student(String name){
        this.name=name;
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //方法
    public void study(){
        System.out.println(this.name+"正在学习");
    }

}

package com.oop.Demo;

//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        //类：抽象的，实例化
        //类实例化后会返回一个对象
        //student对象就是Student类的一个具体实例！
        Student student = new Student();
    }
}

创建对象内存分析

封装

package com.oop.demo04;

//类 private:私有

public class Student {
    //属性私有
    private String name;//姓名
    private int num;//学号
    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 (getter和setter)自动生成get和set
    //可以在此处加入数据验证，进行安全性的保护
    public void setAge(int age) {
        if (age>100||age<0){
            System.out.println("输入年龄不合法");
            return;
        }
        this.age = age;
    }

    public int getAge() {
        return age;
    }
}

继承

object类

package com.you.love.you;

//在Java中，所有的类，都是默认直接或间接继承object
//Person人 :父类
public class Person {
    //public
    //protected
    //default
    //private:私用的东西无法被继承
    protected String name = "ye";
    private int money=1_0000_0000;
    public static void say(){
        System.out.printf("说了一句话");
    }

    public int getMoney() {
        return money;
    }
    public void print(){
        System.out.println("Person");
    }
}

package com.you.love.you;

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

    //ctrl+H
    //继承树关系

    //隐藏代码：调用了父类的无参构造
    //super调用父类的构造器，必须要在子类构造器的第一行

    private String name="zhenyuan";

    public void test(String name){
        System.out.println(name);//叶震源
        System.out.println(this.name);//zhenyuan
        System.out.println(super.name);//ye
    }

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

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

super

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IjqJaPuQ-1656333740675)(C:UsersscarecrowAppDataRoamingTyporatypora-user-imagesimage-20220627151255284.png)]

私有无法被继承

构造先调用父类的构造

重写

静态

A,B都删除static后出现o

非静态

重写：需要有继承关系，子类重写父类的方法！
1.方法名必须相同
2.参数列表必须相同
3.修饰符：范围可以扩大，但不能缩小：public>protected>default>private
4.抛出的异常范围可以缩小但不能放大

重写：子类的方法和父类相同，方法体不一样

为什么要重写
1.父类的功能子类不一定需要，或者不一定满足

多态

instanceof 类型判断

static

静态代码块

静态代码块只执行一次，赋初始值

抽象类

抽象的子类必须实现抽象类的方法

接口

…(img-sX2IW8wX-1656333740696)]

静态代码块只执行一次，赋初始值

[外链图片转存中…(img-xleaXXkz-1656333740696)]

抽象类

[外链图片转存中…(img-USOPh5ud-1656333740697)]

[外链图片转存中…(img-56tQeNgN-1656333740698)]

抽象的子类必须实现抽象类的方法

接口

[外链图片转存中…(img-gicTYpxa-1656333740698)]

[外链图片转存中…(img-kgDfueMo-1656333740699)]

[外链图片转存中…(img-eze7UtKs-1656333740700)]

[外链图片转存中…(img-8VI8E4ue-1656333740700)]