Java面向对象

已于 2022-04-18 17:33:22 修改
阅读量404 收藏 3
点赞数
分类专栏： Java 文章标签： java 多态 封装
于 2021-01-12 16:38:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53693783/article/details/112535245
版权

面向对象

参考尚硅谷宋红康老师的视频 底部有链接

1.类与对象

类：相当于图纸

​ 属性：这一类事物拥有的共同属性

​ 动作：这一类事务共同执行的功能

​ 对象：使用类创建的具体的某一个东西

代码里面：

类要用class来定义

1. 属性：

​ 不同点：

1.声明的位置不同

1.1. 写在方法里或者方法的形参的变量，叫做局部变量，是方法的属性

1.2. 写在类里面的变量，叫做成员变量，就是类的属性

  1. 关于权限修饰符的不同

    2.1 属性：可以在声明属性时，指明其权限修饰符

    ​ 常见的权限修饰符 public private 缺省 protect

    2.2 局部变量：不可以使用权限修饰符。

    2.3 默认初始化值得情况

    ​ 属性： 类的属性，根据其类型，都有默认的初始化值。

    ​ 整型（byte、short、int、long）：0；

    ​ 浮点型（float、double）0.0

    ​ 字符型（char）：0

    ​ 布尔型（boolean）：false

    ​ 引用数据类型（类、数组、接口）：null

    ​ 局部变量：没有默认的初始化值

    ​ 特别的：形参在调用时，赋值即可。

    ​ 2.4 在内存中加载的位置

    ​ 属性：加载到堆空间中

    ​ 局部变量：加载到栈空间中

​ 相同点：

	1. 定义变量的格式：数据类型 变量名=变量值；
	2. 先声明，后使用；
	3. 变量都有其对应的作用域
	4.

2. 方法：

  1. 方法的声明：

​ 权限修饰符 返回值类型 方法名（形参列表）{

​ 方法体；

}

  1. 说明：

    2.1 权限修饰符：常见的权限修饰符 public private 缺省 protect

    2.2 返回值类型：有返回值and没有返回值

    ​ 如果方法有返回值，则必须在方法声明时指定返回值类型，同时方法中要使用return来 指定类型的变量或常量。

    ​ 如果方法没有返回值吗，则方法声明时，用void来表示。通常，没有返回值中就不用 return。但是，如果使用的话，只能“return；”，表示结束此方法

​ 成员方法：在类里面的方法（不写static的方法）

​ 创建对象：类 引用 = new 类（）；

如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性（非static）

意味着：如果我们修改一个对象的属性a，则不影响另外一个对象属性的值。

public class Car {

    //成员变量
    String color;//车的颜色
    int speed;//车的颜色
    int seat;//车的座位

    //成员方法
    public void run(){
        System.out.println("车能跑");
    }

    public static void main(String[] args) {
        //int a=10;//局部变量

        //创建对象
        Car car=new Car();

        //让车跑
        //对象或者引用.方法()
        car.run();//,表示调用  “的”

        //car.pailiang=1.5; //类中没有定义的内容不可以使用

        car.color="绿色";
        car.speed=100;
        car.seat=7;
    }
}

2.this关键字

this：表示当前类的对象

this可以在方法内部获取到对象中的属性信息

this还可以区分局部变量和成员变量

public class Car {

    String color;
    int speed;
    int seat=5;

    public void run(){

        //默认会有一个this：当前正在执行方法的对象

        //获取到车的颜色和座位
        //System.out.println(this);
        System.out.println(this.color);
        System.out.println(this.speed);
        System.out.println("车能跑");
    }

    public void fly(String color){
        System.out.println(this.color+"的颜色的车会飞，飞在"+color+"颜色的云彩里");//如果不加this，访问的也是成员变量
        //变量的查找顺序：先找自己的方法内，如果自己没有，就去this里面找。

    }

    public static void main(String[] args) {
       /* Car c=new Car();
        c.color="红色";
        c.speed=150;

        c.run();//在调用方法的时候，Java会自动的把对象传递给方法，在方法中由this来接收对象
        //System.out.println(c);
        Car c2=new Car();
        c2.color="绿色";
        c2.speed=180;
        c2.run();
*/
       Car c=new Car();
       c.color="绿色";

       c.fly("黑色");
    }
}

3.构造方法

在创建对象的时候，自动调用的方法，

语法：

public 类名(参数){
	
}

注意：

​ 1. 没有返回值这一项

  1. 在我们new对象的时候，自动调用构造方法

    作用：在创建对象的时候，给对象设置属性信息，

​ java会默认自动送给每一个类一个无参的构造方法，但是，如果自己写了构造方法，系统就不再赠送了。

4.方法的重载

1. 重载

  1. 定义：在同一个类中允许存在一个以上的同名方法，只需要他们的参数个数或者参数类型不同即可

    1. “两同一不同”：同一个类、相同的方法

      参数列表不同:参数个数不同，参数列表不同

  2. 判断是否重载：

    ​ 跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系

  3. 在通过对象调用方法时， 如何确定某一个指定的方法

    1. 方法名 ===》参数列表

2. 构造方法的重载

构造方法也是方法，也可以进行重载

作用：可以有更多的方式去创建对象

使用this可以访问其他的构造方法。

this()

public class DaXia {

    String name;
    String waihao;
    int age;
    String bangPai;

    public DaXia(String name,int age,String bangPai){
        this.name=name;
        this.age=age;
        this.bangPai=bangPai;
    }

    //构造方法也是方法，也可以进行重载
    //可以让我有更多的方式去创建对象
    public DaXia(String name,int age,String bangPai,String waihao){
        this(name,age,bangPai);//this还可以调用当前类中的其他的构造方法
        this.waihao=waihao;
    }
    
    public static void main(String[] args) {
        DaXia daXia=new DaXia("岳不群",18,"华山派");

        DaXia daXia1=new DaXia("武松",19,"梁山","行者");
    }

}

5.方法的封装

  1. 面向对象的特征一：封装与隐藏

    一. 问题的引入：

    ​ 当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。这里，赋值操作要受到属性的数据类型和存储范围的制约。除此之外，没有其他制约条件。但是，在实际问题中，我们往往需要给属性赋值加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制 条件的添加。（比如：setLegs()）同时，我们需要避免用户再使用"对象.属性"的方式对属性进行赋值。则需要将属性声明 为私有的(private).

    ==》此时，针对于属性就体现了封装性。

​ 二. 封装性的体现：

​ 我们将类的属性xxx私有化(private),同时，提供公共的(public)方法来获取(getXxx)和设置 (setXxx)此属性的值

​ 三. 封装性的体现，需要权限修饰符来配合。

  1. Java规定的4种权限（从小到大排列）：private、缺省、protected 、public

  2. 4种权限可以用来修饰类及类的内部结构：属性、方法、构造器、内部类

  3. 具体的，4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类

    修饰类的话，只能使用：缺省、public

总结：Java提供了4种权限修饰符来修饰类及类的内部结构，体现类及类的内部结构在被调用时的可见性的大小。

import java.util.Date;

public class Test {
    
    private String name;
    private String sex;
    private Date birthday;
    private double phone;

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

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

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public double getPhone() {
        return phone;
    }

    public void setPhone(double phone) {
        this.phone = phone;
    }
}

6.面向对象练习

  1. 用面向对象的思维来模拟LOL里的盖伦打架；

    public class Hero {
    String name;
    String skill_q;
    String skill_w;
    String skill_e;
    String skill_r;

    public Hero(String name,String skill_q,String skill_w,String skill_e,String skill_r){
        this.name=name;
        this.skill_q=skill_q;
        this.skill_w=skill_w;
        this.skill_e=skill_e;
        this.skill_r=skill_r;
    }

    public void fight(){
        System.out.println(this.name+"在打架");
    }

    public static void main(String[] args) {
        Hero h1=new Hero("盖伦","小宝剑","防御","电风扇","大宝剑");

        h1.fight();
    }
}

    1. 用面向对象的思维来完成植物大战僵尸

      植物.java

public class ZhiWu {
    String name;
    int hp;
    int attack;

    public ZhiWu(String name,int hp,int attack){
        this.name=name;
        this.hp=hp;
        this.attack=attack;
    }
    public void fight(JiangShi js){
        System.out.println(this.name+"正在打"+js.name);

        js.hp -=this.attack;
        System.out.println("僵尸的血量剩余"+js.hp);
    }
}

​ 僵尸.java

public class JiangShi {
    String name;
    int hp;
    int attack;

    public JiangShi(String name,int hp,int attack) {
        this.name = name;
        this.hp = hp;
        this.attack = attack;
    }
    public void eat(ZhiWu zw){
        System.out.println(this.name+"正在吃植物"+zw.name);
        zw.hp -=this.attack;
        System.out.println("植物的血量还有"+zw.hp);
    }
}

​ 场景.java

public class Client {

    //创建植物和僵尸
    public static void main(String[] args) {

        ZhiWu zhiWu=new ZhiWu("豌豆",1000,5);

        JiangShi jiangShi = new JiangShi("铁通僵尸",800,20);

        zhiWu.fight(jiangShi);

        jiangShi.eat(zhiWu);
    }
}

7.static关键字

static静态

在这里插入图片描述

有多少人就要改多少次

静态的内容在内存中是保留一份的，并且各个对象之间进行共享

使用p1.country=”民国“，不推荐这样使用静态变量

推荐使用类名去访问静态的内容

public class Person {

    String name;
    static String country="大清";//他是共享的
    String address;

    public Person(String name,String address){
        this.name=name;
        this.country=country;
        this.address=address;
    }
    public static void main(String[] args) {

        Person p1=new Person("张三","八大胡同");
        Person p2=new Person("李四","朝阳门");

        //大清亡了
        Person.country="民国";

        System.out.println(p1.country);
        System.out.println(p2.country);
    }

}

特点：

  1. 数据共享
  2. 属于类的 并不属于对象
  3. 优先于对象产生的

通用代码块，静态代码块

创建对象的过程:

1. 静态构造器
2. 通用构造器
3. 构造方法==》创建对象

public class Test {
    {
        System.out.println("通用代码块");
    }
    static{
        System.out.println("静态代码块");
    }
	
    public Test(){
        System.out.println("构造方法");
    }
    public static void main(String[] args) {
        new Test();
    }
}

由于创建对象的过程是在静态内容加载完成之后，在静态方法和静态块里不能使用this

可以在静态方法里直接调用静态的方法

public static void pen(){
        System.out.println("aaa");
    }
public static void main(String[] args) {
        pen();
}

静态内容使用类名去访问

8.方法的继承

继承：子类可以自动拥有父类中除了私有内容外的其他所有内容。子类是对父类的功能进行扩展

当出现x是一种y的时候，x就可以继承y

​ 黑熊怪是一种妖怪

public class HeiXiong extens YaoGuai（）{
}

在这里插入图片描述

  1. 好处：

    1.1 减少了代码的冗余，提高了代码的复用性

    1.2 便于功能的扩展

    1.3 为之后多态性的使用，提供了

  2. 格式：

    class A extends B{}

    2.1 体现：一旦子类A继承父类B以后，子类中就获取了父类B中的声明的所有的属性和方法

    特别的，父类中声明为private的属性和方法，子类继承父类后，仍然认为获取了父类中的私有的结构，只有因为封装性的影响，使得子类不能直接调用父类的结构而已。

    2.2 子类继承父类以后，还会声明自己特有的属性或方法；实现功能的拓展。

    子类和父类的关系，不同于子集和集合的关系

  3. Java关于继承性的规定

    1. 一个子类只能有一个父类

    2. Java单继承：一个父类可以派生出多个父类

    3. 子父类是相对的概念

    4. 子类直接继承的父类，称为：直接父类。间接继承的父类称为：间接父类

    5. 子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法。

在这里插入图片描述

9.super关键字

super：表示父类中的内容

this：表示自己类中的内容

用super和this来区分父类和子类中重名的内容

super关键字的使用

  1. super理解为：父类的

  2. super可以用来调用：属性、方法、构造器

  3. super的使用：调用属性和方法

    1. 我们可以在子类的方法或构造器中。通过使用"super.属性"或"super.方法"的方式，显式的调用父类中声明的属性或方法。但是，通常情况下，我们习惯省略"super."

    2. 特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用"super.属性"的方式，表明调用的是父类中声明的属性。

    3. 特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用"super.方法"的方式，表明调用的是父类中被重写的方法。

  4. super调用构造器

    1. 我们可以在子类的构造器中显式的使用"super(形参列表)"的方式，调用父类中声明的指定的构造器

    2. "super(形参列表)"的使用，必须声明在子类构造器的首行！

    3. 我们在类的构造器中，针对于"this(形参列表)"或"super(形参列表)"只能二选一，不能同时出现

    4. 在构造器的首行，没有显式的声明"this(形参列表)“或"super(形参列表)”，则默认调用的是父类中空参的构造器：super()

    5. 在类的多个构造器中，至少有一个类的构造器中使用了"super(形参列表)"，调用父类中的构造器创建对象的过程：先创建父类的对象，然后创建子类的对象在子类构造方法的第一行，会默认调用父类的构造方法

总结：

  1. super可以获取到父类中的内容

  2. 可以调用父类中的构造方法，必须写在子类构造方法的第一行，如果父类的构造方法是无参的，可以不写，如果父类没有无参的构造方法，必须要写super

10.方法的重写

1. 重写：

​ 子类继承父类后，可以对父类中的同名参数的方法进行覆盖操作

语法：子类和父类中的方法的声明完全一致

重写又被称为方法的覆盖

  1. 应用：重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名参数的方法时，实际执行的是子类重写父类的方法。

  2. 面试题：区分方法的重载和重写

    把他们的作用和定义说清楚和细节点说清楚

  3. 规定：

    1. 方法的声明：权限修饰符 返回值类型 方法名（形参列表）throws异常的类型{

      ​ //方法体

      ​ }

      约定：子类中的叫重写的方法，父类中的叫被重写的方法

      1. 子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同

      2. 子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符

        特殊情况：子类不能重写父类中声明private权限的方法

      3. 返回值类型：

        ​ 父类中被重写的返回值的类型是void，则子类重写的方法的返回类型只能是void

        ​ 父类被重写的方法的返回值类型是A类型，则子类重写的返回值类型可以是A类或者A类的子类

        ​ 父类被重写的方法的返回值类型是基本数据类型(比如：double)，则子类重写的方法的返回值类型必须是相同的基本数据类型(必须也是double)

      4. 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型

    子类和父类的同名同参数的方法要么都声明为非static的（考虑重写），要么都声明为static的（不是重写）

    Person.java

    public class Person {
    String name;
    int age;

    public Person(){

    }
    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }
    public void eat(){
        System.out.println("吃饭");
    }
    public void walk(int distance) {
        System.out.println("走了"+distance+"公里");
    }
}

    Student.java

    public class Student extends Person{

    String major;

    public Student(String major) {
        this.major = major;
    }

    public Student() {
    }

    public void study(){
        System.out.println("学习，专业是"+major);
    }

    //对父类中的eat方法进行了重写
    public void eat() {
        System.out.println("学生应该多吃有营养的东西");
    }
}

    PersonTest.java

    public class PersonTest {
    
    public static void main(String[] args){
        Student s =new Student("计算机科学与技术");
        s.eat();
        s.walk(10);
        s.study();
    }
}

2. 面试题：重载和重写

​ 说清他们的细节点和定义

​ 说清重写的权限修饰符、返回值类型是什么等等

11.多态

  1. 理解多态性：可以理解为一个事物的多种形态。

  2. 何为多态性：

    对象的多态性：父类的引用指向子类对象（或者子类的对象赋给父类的引用）

  3. 多态的使用：虚拟方法的调用

    ​ 有了以下这种多态的格式后，在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法

    ​ Father f=new Son();

    ​ 总结： 编译看左，执行看右

  4. 多态性的使用前提：

    1. 类的继承关系
    2. 要有方法的重写

  5. 对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）

12. 向下转型

  1. 有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法的，但是由于变量声明为父类类型，导致编译时，只能调用父类生命的属性和方法。子类特有的方法不能调用。

  2. 如何才能调用子类特有的属性和方法呢？

    ​ 向下转型：使用强制类型转换符

  3. 使用强转时，可能会出现ClassCastException的异常

14.instanceof关键字

  1. instanceof的使用： a instanceof A:判断对象a是否是A的实例。如果是，返回true；如果不是，返回false

  2. 使用情景：为了避免在乡下转型时出现ClassCastException的异常，我们在向下转型之前，先进行instanceof判断，一旦返回true，就进行向下转型。如果返回false，不进行向下转型。

  3. ==：对于引用类型来讲，比较的是两个引用数据类型变量的地址值是否相同

15.多态练习

/*
 * 练习：
 * 1.若子类重写了父类方法，就意味着子类里定义的方法彻底覆盖了父类里的同名方法，
 * 系统将不可能把父类里的方法转移到子类中：编译看左边，运行看右边
 * 
 * 2.对于实例变量则不存在这样的现象，即使子类里定义了与父类完全相同的实例变量，
 * 这个实例变量依然不可能覆盖父类中定义的实例变量：编译运行都看左边
 */
clas
class Base {
	int count = 10;

	public void display() {
		System.out.println(this.count);
	}
}

class Sub extends Base {
	int count = 20;

	public void display() {
		System.out.println(this.count);
	}
}

public class FieldMethodTest {
	public static void main(String[] args) {
		Sub s = new Sub();
		System.out.println(s.count);//20
		s.display();//20
		
		Base b = s;//多态性
		//==：对于引用数据类型来讲，比较的是两个引用数据类型变量的地址值是否相同
		System.out.println(b == s);//true
		System.out.println(b.count);//10
		b.display();//20
	}
}

16. static关键字

  1. static：静态的

  2. static可以用来修饰：属性、方法、代码块、内部类

  3. 使用static来修饰属性：

    1. 属性按是否使用static修饰，又分为：静态属性和非静态属性（实例变量）

       1. 实例变量：我们创建了类的多个对象，每个对象都独立拥有一套类中的非静态属性。当修改其中一个对象中的非静态属性时，不会导致其他对象中同样的属性值的修改。
 
 2. 静态变量：我们创建了多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过了的。

      1. static修饰属性的其他说明：

          	1. 静态变量随着类的加载而加载。可以通过“类.静态变量”的方式进行调用
  	2. 静态变量的加载早于对象的创建。
  	3. 由于类只会加载一次，则静态变量在内存中也会存在一份

  4. 使用static来修饰方法：静态方法

    1. 随着类的加载而加载，可以通过“类.静态方法”的方式进行调用

    2. 静态方法中，只能调用静态的方法或属性

      非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性

    3. static注意点：

       1. 在静态方法内，不能使用this关键字、super关键字。
 2. 关于静态属性和静态方法的使用，可以从生命周期的角度去理解

    4. 在开发中，如何确定一个属性是否要声明为static？

       1. 属性是可以被多个对象所共享的，不会苏浙对象的不同而不同的
 2. 类中的常量也常声明为static

    5. 在开发中，如何确定一个方法是否要声明为static？

       1. 操作静态属性的方法，通常就设置为static
 2. 工具类中的方法，习惯上声明为static

17.代码块

  1. 作用：用来初始化类或对象

  2. 代码块只能用static来修饰

  3. 分类：静态代码块和非静态代码块

  4. 静态代码块

    1. 内部可以有输出语句
    2. 随着类的加载而执行，而且只执行一次
    3. 作用：初始化类的信息
    4. 如果一个类中定义了多个的静态代码块，则按照声明的先后顺序执行
    5. 静态代码块的执行要优先于非静态代码块的执行
    6. 只可以调用静态的属性或方法，不能调用非静态代码块的结构

  5. 非静态代码块

    1. 内部可以有输出语句
    2. 随着对象的创建而执行
    3. 而且，每创建一次对象，就执行一次非静态代码块
    4. 作用：可以在创建对象时，可以对对象的属性进行初始化
    5. 可以调用静态的属性、静态的方法、非静态的属性、非静态的方法

  6. 对属性可以赋值的位置：

    1. 默认初始化
    2. 显示初始化 / 在代码块中赋值-
    3. 构造器中初始化
    4. 有了对象以后，可以通过“对象.属性”或者“对象.方法”的方式，进行赋值

    执行的先后顺序：1=>2=>3=>4

总结：由父及子，静态先行

18. final关键字

  1. final可以用来修饰的结构：类、方法、变量

  2. final用来修饰一个类：此类不能被其他类继承

  3. final用来修饰方法：不可以再被重写

  4. final用来修饰变量：此时的“变量”就称为是一个常量

    1. final修饰属性：可以考虑赋值的位置有：显示初始化、代码块中初始化、构造器中初始化
    2. final修饰局部变量：
      1. 尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。一旦赋值以后，就只能在方法体内使用此形参，但不能进行重新赋值。

    static final 用来修饰属性：称为全局常量

19. 抽象类和抽象方法

  1. abstract可以用来修饰的结构：类、方法

  2. abstract修饰类：抽象类

    1. 此类不能实例化
    2. 抽象类中一定有构造器，便于子类实例化调用（涉及：子类对象实例化的全过程）
    3. 开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作

  3. abstract修饰方法：抽象方法

     1. 抽象方法只有方法的声明，没有方法体
  
 2. ==包含抽象方法的类一定是个抽象类==。反之，抽象类中可以没有抽象方法
  
 3. 若子类重写了父类中的所有的抽象方法后，此子类可以实例化
  
    若子类没有重写父类中的所有的抽象方法，此子类也是一个抽象类，需要用abstract来修饰

  4. 使用的注意点：

    1. abstract不能用来修饰：属性、构造器等结构
    2. abstract不能用来修饰私有方法、静态方法、final的方法

20. 接口

1. 接口

  1. 接口是使用interface来定义

  2. 在Java中，接口和类是并列的两个结构

  3. 如何定义接口，定义接口中的成员

    1. JDK7及以前：只能定义全局常量和抽象方法
      1. 全局常量：public static final， 但是书写时，可以省略不写
      2. 抽象方法：public abstract的
    2. JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法。

  4. 接口中不能定义构造器，意味着接口不可被实例化

  5. Java开发中，接口通过让类去实现（implements）的方式来使用

    1. 如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化
    2. 如果实现类没有覆盖接口中的所有抽象方法，则此实现类仍为一个抽象类

  6. Java类可以实现多个接口—>弥补了Java的单继承的局限性

    ​ 格式： class AA extends BB implements CC,DD,EE

  7. 接口与接口之间可以继承，而且是多继承

  8. 接口的使用，

    1. 体现了多态
    2. 接口实际上，可以看作是一种规范
    3. 开发中，体会面向接口编程

2. 面试题：抽象类与接口有哪些异同？

https://www.bilibili.com/video/BV1Kb411W75N?p=1

昊94264
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
面向对象一（类 对象）
fangcatt的博客
08-12 477
面向对象和面向过程的区别 之前看了一个很好的描述，我们写代码就像是做饭，面向对象就像是盖浇饭，面向过程像是蛋炒饭。盖浇饭是我们做一份米饭，炒一份菜，想吃青椒肉丝盖浇饭就把青椒肉丝这个菜放在饭上，不想吃青椒肉丝了就可以直接把青椒肉丝从饭上剥掉，放上其他的菜上就好了。面向对象也是这样，我们把所有的功能单独的拿出来，如果需要就链接起来，不需要就断开，强调的是我用谁来做。蛋炒饭是在做饭的时候就直接把所有的菜都放进去，想吃腊肠炒饭就在炒饭的时候放腊肠进去，但是如果突然不想吃了，那就得一点一点的把腊肠挑出来。面向过程也
面向对象（一）
weixin_45739322的博客
10-13 111
面向对象 四大特性： 1.抽象：对同一类对象的共同属性和行为进行概括，形成类。 有：数据抽象（属性或状态）、代码抽象（某类对象的共有的行为特征或功能）。抽象的实现是：类 2.封装： 隐藏对象的属性和实现细节，仅对外提供公有的访问方式，将变化隔离，便于使用，提高复 用性和安全性。 3.继承： 提高代码的复用性，继承是多态的前提。 4.多态： 父类或接口定义的引用变量指向子类或具体实现...
java 对象共享_【Java并发编程实战】03对象的共享
weixin_29215391的博客
02-21 125
上一篇介绍了如何通过同步多个线程避免同一时刻访问相同数据，本篇介绍如何共享和发布对象，使它们被安全地由多个进程访问。1.可见性通常，我们无法保证执行读操作的线程能看到其他线程写入的值，因为每个线程都由自己的缓存机制。为了确保多个线程之间对内存写入操作的可见性，必须使用同步机制。public class NoVisibility {private static boolean ready;priva...
java 类里面对象共享_对象的共享
weixin_31500907的博客
02-28 1438
3 对象的共享3.1 可见性我们不仅希望防止某个线程正在使用对象状态而另一个线程在同时修改该状态，而且希望确保当一个线程修改了对象状态后，其他线程能够看到发生的状态变化。因此就需要通过显式的同步或者类库中内置的同步来保证对象被安全地发布。3.1.1 失效数据3.1.2 非原子的64位操作JVM允许将64位的读操作或写操作分解为两个32位的操作。当读取一个非volatile类型的long变量时，如果...
【C++学习笔记】面向对象设计的基本特点
C/C++攻城狮
06-07 229
0x00 前言 文章中的文字可能存在语法错误以及标点错误，请谅解； 如果在文章中发现代码错误或其它问题请告知，感谢！ 本文档为个人边学习边记录的C++笔记，非教程，笔记中会存在引用他人文章内容的部分，被引用的原文不会被特殊标记出来，但会在参考文档中给出原文链接。 0x01 面向对象设计基本特点 1.抽象 面向对象方法中的抽象，是指对具体问题（对象）进行概括，抽出一类对象的公共性质并加以描述的过程。一般来讲，对一个问题的抽象应该包括两个方面：数据抽象和行为抽象。 2.封装 封装就是将抽象得到的数据和行为（或功
java面向对象编程pdf
04-16
Java面向对象编程PDF 在这篇文章中，我们将对Java面向对象编程的基础知识进行总结和解释。面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它将程序设计看作是对象的交互，对象之间的关系和行为...
Java面向对象程序设计+源代码+课后习题答案)
10-31
Java面向对象程序设计是计算机科学中的一个重要领域，它基于面向对象编程（OOP）的概念，是一种强大的编程范式。在Java中，OOP的核心概念包括类、对象、封装、继承、多态等。这本书"Java面向对象程序设计"由耿祥义和...
java 面向对象 案例 合集
最新发布
07-18
java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 ...
JAVA面向对象
12-22
面向对象三大特征4. this关键字5. 构造方法6. 标准的类结构7. 匿名对象8. 对象数组9. ArrayList类10. ArrayList常用方法 1. 类的定义 成员变量 直接定义在类中，在方法外。 成员方法 不写static关键字。 public ...
JAVA面向对象程序设计(期末考试试题及答案)
06-16
JAVA面向对象程序设计知识点总结 JAVA面向对象程序设计是 Java 编程语言的核心 contents，涵盖了面向对象编程的基本概念、语法规则、编程技术和实际应用等方面的知识。本文总结了 JAVA面向对象程序设计的知识点，...
Java面向对象基础练习题
08-06
适合刚刚学习到面向对象三大特征的同学来巩固对知识的理解
Java面向对象程序设计
03-17
Java面向对象程序设计是计算机编程领域中的核心主题，它基于面向对象编程（OOP）理念，使得代码更具有模块化、可复用性和易于维护的特点。以下是对标题和描述中涉及的知识点的详细阐述： 1. **第1章：Java入门** -...
Java面向对象编程练习题.pdf
05-22
Java面向对象编程练习题 本资源摘要信息涵盖了 Java 面向对象编程的基础知识，通过三个练习题，展示了 Java 编程语言的基本概念和应用。 练习题 01: 类的成员变量 本练习题展示了 Java 中类的成员变量的概念。类 ...
Java面向对象逻辑思维导图
11-21
Java面向对象，自己学习整理的Java的面向对象的思维导图。
Java---多个类写在一个类文件中
diyinjiao1404的博客
08-13 790
可以将多个类写在一个类文件中，但只能有一个类是public类，而且该类的类名必须和类文件名一致。 默认修饰符的类只能在它所在包的范围内使用，出了本包无效。 如： -----Test.class开始 ----- public class Test{ //todo... } class Point{ //todo... } class Circle{ ...
Java的Object基类公共方法
xiaoma's Blog
10-02 495
object类除了object()构造方法外，还提供了11个成员方法：clone()，equals()、finalize()、getClass()、hashCode()、notify()、notifyAll()、toString()、wait()
Python快速入门（八）面向对象1：类、对象和封装
等待着冬天的风的博客
03-24 313
面向过程：简单的理解就是把完成某一个需求的所有步骤从头到尾逐步实现的过程。面向对象：简单的理解就是面向对象是更大的封装，根据 职责在一个对象中封装多个方法
java类与对象
yangxiaobai22的博客
11-01 171
java的类与对象 类与对象的定义 在C语言中强调的是实现的过程，分析步骤，逐步解决问题。在JAVA中关注的是对象，将事情分解成不同的对象，通过对象之间的交互来实现。 类是一类对象的统称，对象就是一个类的实例化。 类和类的实例化 我们在解决问题的时候不必过分的关注过程，只需要了解对象的功能，并且能够使用它的功能就可以了。一个类可以实例化无数个对象。 声明一个类就是创建一个新的数据类型，而类在java中属于引用类型， java使用class关键字来声明一个类 //创建类 class <clas
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值