跟着狂神学java(1)--面向对象

用户756283469

已于 2023-11-15 13:28:08 修改

阅读量93

点赞数

分类专栏： java 文章标签： java jvm 开发语言

于 2022-08-18 13:12:44 首次发布

本文链接：https://blog.csdn.net/qq_66417858/article/details/126320603

版权

java 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

java的核心思想就是OOP（面向对象编程）

什么是面向对象

面向对象的本质就是：以类的方式组织代码，以对象的形式封装数据
在这里插入图片描述

在这里插入图片描述

回顾方法的定义

package kuang.java1.oop;

import java.io.IOException;

//方法一定是在类里面的
//Demo01就是一个类，是用class修饰的
public class Demo01 {
    //main方法
    public static void main(String[] args) {

    }
    /*
    修饰符 返回值类型 方法名字（参数）{
          //方法体
          return 返回值;
    }
     */
    public String sayHello(){
        return "hello";
    }
    public void hello(){
        return;
    }
    public int max(int a,int b){
        return a>b?a:b;
    }
    //数组下标越界：Arrayindexoutofbounds
    public void readFile(String file) throws IOException{

    }
}

在这里插入图片描述

回顾方法的调用

在这里插入图片描述
a和b都是静态，a调用b，ok

此情况不行：

两种情况：

值传递和引用传递：

类与对象的创建

package kuang.java1.oop.Demo02;
//学生类
public class Student {
    //属性：字段
    String name;//未赋值默认为null
    int age;//0
    //方法
    public void study(){
        System.out.println(this.name+"在学习");
    }
}

package kuang.java1.oop.Demo02;
//一个项目有一个main方法
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(xiaoming.name);
    }
}

构造器

package kuang.java1.oop.Demo02;

public class Person {
    //一个类即使什么都不写，它也会存在一个方法
    //显示的定义构造器
    String name;
    //作用
    //1.使用new关键字，本质是在调用构造器
    //2.用来初始化值
    public Person(){
    }
    //有参构造：一旦调用了有参构造，
    //无参就必须显示定义
    public Person(String name){
        this.name = name;
    }
    //alt+insert 生成构造器
}

package kuang.java1.oop.Demo02;
//一个项目有一个main方法
public class Application {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);
    }
}

alt+insert 构造器选时按住ctrl可以多选
在这里插入图片描述
构造器：
1.和类名相同
2.没有返回值
作用：
1.使用new关键字，本质是在调用构造器
2.用来初始化值
注意：
1.定义有参构造之后，如果想使用无参构造，显示的定义一个无参
快捷键：
Fn+alter+insert

创建对象内存分析

在这里插入图片描述

小结类与对象

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

封装

package kuang.java1.oop.Demo04;

public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("qin");
        System.out.println(s1.getName());
    }
}

package kuang.java1.oop.Demo04;

//private :私有
public class Student {
    //属性私有
    private String name;
    private int id;
    private char sex;
    //提供一些可以操作这个属性的f方法
    //提供public的get，set方法
    //get获得这个数据
    public String getName(){
        return this.name;
    }
    //set 给这个数据设置值
    public void setName(String name){
        this.name = name;
    }
}

1.封装（数据的隐藏）
(1)该暴露给用户的暴露给用户，该隐藏的程序细节隐藏。程序设计要追求“高内聚，低耦合”，高内聚：类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
(2) 通常，应禁止直接访问一个对象中数据的实际表示，而应该通过接口来访问，这称为信息隐藏。
记住：属性私有，get/set
2.快捷键：alt+insert 自动生成get set 方法
3.封装的意义：
(1)提高程序的安全性，保护数据
(2)隐藏代码实现细节
(3)统一接口
(4)系统可维护增加
方法名和参数列表相同则为同一个方法

继承

1.本质:是对某一批类的抽象，从而实现对现实世界更好的建模。
2. extends是“扩展”，子类是父类的扩展。
3.java中只有单继承，没有多继承。
4.继承是类与类之间的一种关系，除此之外，类和类之间的关系还有依赖，组合，聚合等。继承关系的两个类，一个为子（派生类），另一种为父类（基类）。子类继承父类，使用关键字extends来表示。子类和父类之间，从意义上来讲应具有"is a"的关系。
5.快捷键：Ctrl+H 打开了
在这里插入图片描述
在java中，所有的类都默认直接或者间接继承Object类
子类继承父类，就会拥有父类的全部方法

Super详解

在这里插入图片描述

私有的东西无法被继承

在这里插入图片描述
super 注意点：
1.super 调用父类的构造方法，必须在构造方法的第一个
2.super必须只能出现在子类的方法或者构造方法中
3. super 和this 不能同时调用构造方法
this:
1.代表的对象不同：
this ：本身调用者这个对象
super ：代表父类对象的引用
2.前提:
this ：没有继承也可以使用
super ：只能在继承条件才可以使用
3.构造方法
this ()；本类的构造
super ()：父类的构造

方法重写

在这里插入图片描述

静态方法和非静态方法有区别
静态方法：方法的调用只和左边定义的数据类型有关
非静态方法：重写
重写的关键词是public，不能是私有的
重写：
需要有继承关系，子类重写父类的方法
1.方法名必须相同
2.参数列表必须相同
3.修饰符：范围可以扩大但不能缩小，public>Protected>private
4.抛出的异常：可以被缩小但不能扩大：ClassNotFoundException–>Exception(大)

重写,子类的方法和父类必须一样，方法体不同
为什么需要重写：
1.父类的功能子类不一定需要或者不一定满足
alt+insert：Override

多态

1.动态编译：类型：可扩展性
2.对象能执行哪些方法，主要看对象左边对象的类型，和右边关系不大
3.子类能调用的方法都是自己的或者继承父类的，父类虽然可以指向子类，但是不能调用子类独有的方法
4.高转低，也有强制转换，父类转化为子类
5.同一方法可以根据发送对象的不同而采取多种不同的行为方式
一个对象的实际类型是确定的，但可以指向对象的引用类型有很多
注意事项：
1.多态是方法的多态，属性没有多态
2.父类和子类有联系，String Person类型转换异常 ClassCastException
3.存在条件：有继承关系，方法需要重写，父类的引用指向子类对象
Father f1 = new Son();
不能重写的方法：
1.static 方法，属于类，不属于实例
2.final 常量池
3.private

package kuang.java1.oop.Demo07;

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

package kuang.java1.oop.Demo07;

public class Student extends Person{
    @Override
    public void run() {
        System.out.println("son");
    }
    public  void eat(){
        System.out.println("eat");
    }
}

package kuang.java1.oop.Demo07;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        //一个对象的实际类型是确定的
        //可以指向的引用类型就不确定了:
        //父类的引用指向子类
        //Student能调用的方法都是自己的或者继承父类的
        Student s1 = new Student();
        //父类型可以调用子类，但是不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();
        s2.run();
        //对象能执行哪些方法，主要看左边的类型，和右边关系不大
        //子类重写父类的方法，执行子类的方法
        s1.run();
        s1.eat();
        //s2.eat();错误写法
    }
}

instanceof和类型转换

package kuang.java1.oop.Demo07;


public class Teacher {
    public static void main(String[] args) {
        //Object > String
        //Object > Person > Student
        //Object > Person > Teacher
        Object object = new Student();
        //System.out.println(X instanceof Y);存在父子关系编译通过
        System.out.println(object instanceof Student);//ture
        System.out.println(object instanceof Person);//ture
        System.out.println(object instanceof Object);//ture
        System.out.println(object instanceof Teacher);//false 注意是object，小写的o对象
        System.out.println(object instanceof String);//false
        System.out.println("=================");
        Person person = new Student();
        System.out.println(person instanceof Student);//ture
        System.out.println(person instanceof Person);//ture
        System.out.println(person instanceof Object);//ture
        //System.out.println(person instanceof Teacher);false
        //System.out.println(person instanceof String);false
    }
}

1.判断两个类是否存在父子关系
System.out.println(X instanceof Y)能不能编译通过就看X和Y是否存在父子关系(结果是true/false)
X和Y所指的类型有关系也通过
Object >String
Object>Person>Teacher
Object>Person>Student
2.类型转换
父为高，子为低
3.父类引用指向子类的对象
子类转换为父类，向上转型，自动
父类转换为子类，向下转型，需要强制转换，会丢失一些方法
方便方法调用，减少重复的代码，简洁

package kuang.java1.oop.Demo07;

public class Application {
    public static void main(String[] args) {
        //类型转化：父与子
        // 高                  低
        Person obj = new Student();
        //student将这个对象转换为Student类型，我们就可以使用Student类型的方法
        Student student = (Student) obj;
        student.go();
        //((Student) obj).go();
        Person person = student;
        //子类转换为父类可能会丢失自己本来一些方法
    }
}

static关键字

静态属性
在这里插入图片描述

静态方法
在这里插入图片描述
静态代码块

package kuang.java1.oop.Demo08;

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 person1 = new Person();
        System.out.println("=============");
        Person person2 = new Person();
    }
}

在这里插入图片描述
其他知识：

final修饰的类不能被继承，没有子类

抽象类

特点：不能new出来(抽象不能实例化)，只能靠子类去实现，约束
有抽象方法必须在抽象类中，抽象类可以写普通方法
抽象的抽象：约束
在这里插入图片描述
存在的意义：提高开发效率

接口

1.普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有
接口：只有规范，自己无法写方法，专业的抽象，只能约束，约束和实现分离，面向接口编程
2.接口就是规范，定义的是一组规则，接口本质就是契约，就像法律一样，制定好大家都要遵守，是面向对象的精髓，是对对象的抽象
3.声明类的关键字是class，声明接口的关键字是interface
4.接口中所有定义都是抽象的，接口中的方法不写默认public
5.接口都需要有实现类，实现了接口中的类，就需要重写接口中的方法
作用：
1.约束
2.定义一些方法，让不同的人实现。。可使多人用不同的实现方式实现一个接口
3.方法public abstract ；常量 public static final int AGE=99
4.接口不能实例化，接口中没有构造方法
5.接口可以实现多个，implements
6.必须重写接口中的方法