Hi~

2021-10-20  2021-10-20    4153 字   9 分钟

面向对象

常见的编程思想

面向过程：Procedure Oriented：pop 解决问题的方法与步骤。

面向对象： Object Oriented ：oop 找"对象"解决问题。

面向过程是实现面向对象的基础

面向对象步骤

1.抓 特征:

​ “静态特征”: 属性：实质全局变量 。身高 体重 毛色 姓名

​ “动态特征”: 行为。功能。方法。函数。method

2.面向对象更适用于复杂问题的解决，而面向过程更适用于简单问题的解决。

​ 例如：面向对象类比盖饭，面向过程 类比蛋炒饭

​ 耦合

3.总结：

​ 面向对象思想：

​ 1> 找"对象"。类 –》 创建对象。

​ ① java或别人提供了，直接用

​ ② 没提供，自己写，再用

面向对象代码：

package com.demo1;
/**
1.猫捉老鼠的场景: 
	① 猫看见老鼠 
	② 老鼠跑
	③ 猫追逐 
	④ 猫抓住老鼠
2.对象: 
	猫
	老鼠 
3.类：
	猫
	老鼠
抓 特征:
	"静态特征": 属性：实质全局变量 。身高 体重 毛色 姓名 
	"动态特征": 行为。功能。方法。函数。method 
4.面向对象更适用于复杂问题的解决，而面向过程更适用于简单问题的解决。
	例如：面向对象类比盖饭，面向过程 类比蛋炒饭 
	耦合 
5.总结：
	面向对象思想：
    1> 找"对象"。类 --》 创建对象。
    	① java或别人提供了，直接用
        ② 没提供，自己写，再用
*/
public class 面向对象版猫捉老鼠 {
    public static void main(String[] args) {
        // 创建： new 类名()
        Cat cat = new Cat(); 
        Cat cat1 = new Cat(); 
        Mouse mouse = new Mouse(); 
        //实现功能 对象名称.方法(参数) 
        cat.seeMouse(); 
        cat1.seeMouse(); 
        mouse.mouseRun(); 
        cat.catRun(); 
        cat.catchMouse(); 
    } 
}
class Cat{
    String color ;//属性 毛色 
    public static void seeMouse(){
        System.out.println("猫看见老鼠");
    }
    public static void catRun(){ 
        System.out.println("猫追逐");
    }
    public static void catchMouse(){
        System.out.println("猫抓住老鼠"); 
    } 
}

class Mouse{ 
    public static void mouseRun(){
        System.out.println("老鼠跑"); 
    } 
}

面向过程代码

package com.demo1; 
/**
1.猫捉老鼠的场景:
① 猫看见老鼠 
② 老鼠跑 
③ 猫追逐 
④ 猫抓住老鼠 
*/ 
public class 面向过程版猫捉老鼠 {
    public static void main(String[] args) {
        seeMouse();
        mouseRun(); 
        catRun(); 
        catchMouse();
    }
    public static void seeMouse(){
        System.out.println("猫看见老鼠");
    }
    public static void mouseRun(){ 
        System.out.println("老鼠跑");
    }
    public static void catRun(){
        System.out.println("猫追逐"); 
    }
    public static void catchMouse(){
        System.out.println("猫抓住老鼠");
    }
}

类和对象

概念

1.类：模板 蓝图 设计稿 。抽象的概念

抽象是从众多的事物中抽取出共同的、本质性的特征

2.猫–》共性 凡是符合这种特征。

3.类：具有共性特征的事物的抽象。

4.对象：由类创建，具体的事物。

对象的内存图

单个对象的内存图

步骤：

​ 1.将对象的内存图.class加载到方法区，找到其中的main方法开始压栈执行。

​ 2.加载Person类到方法区，在main方法中为p引用变量开辟空间。

​ 3.在堆中以Person类为模板，创建Person对象，为Person中的属性name和age赋默认值，这个过程称为默认初始化。

​ 4.将创建完毕的对象的内存地址值赋给引用变量p。

​ 5.p.name p.age根据p找到堆中的对象进行赋值操作。

​ 6.show方法压栈执行，show方法中默认会带有一个隐式指针，存放该方法由哪个对象执行。

总结：

① 创建的对象在堆中存放，对象的属性也是在堆中存放。

② 类的加载只加载一次 ，首先去方法区中查找是否存在，存在，直接用，不存在，才会去硬盘上 加载该类

创建两个对象的内存图

总结:

① 凡是new操作，都会在堆中创建新的对象。

② 属性属于不同对象的，每个对象都有自身的属性，只能改变自身的属性，不能改变其它对象的属 性

值传递和引用传递

值传递

引用传递

无论是值传递还是引用传递，实质都是值传递，在参数传递的过程中，对于基本数据类型来说，传递的 值，而对于引用数据类型来说，传递的的地址值。

匿名对象

概念

1.匿名对象：没有名字的对象

2.好处：

​ ① 简化书写

​ ② 节省内存空间：垃圾回收机制：自动回收。

3.注意：

​ ① 对于匿名对象来说，同一个对象，调用属性或方法，只能调用一次。

代码

package com.demo; 
/**
1.匿名对象:
2.好处：
① 简化书写
② 节省内存空间：垃圾回收机制：自动回收。 
3.注意： 
① 对于匿名对象来说，同一个对象，调用属性或方法，只能调用一次。 
*/
public class 匿名对象 {
    public static void main(String[] args) { 
        new B().fun();
        new B().fun();
        B b = new B(); 
        b.fun(); 
        System.out.println(2222); 
    }
}
class B{
    public void fun(){ 
        System.out.println("1111"); 
    }
}

构造方法

概念

constructor ：构造器

作用

① 创建对象时，调用的方法。

​ 格式：

​ new 构造方法(参数)

​ ② 初始化

​ 注意：

​ 初始化 可以是 属性，也可以调用其它方法。

细节

1.构造方法的声明：

​ 格式:

​ [权限修饰符] 类名(参数列表){

​ }

2.注意：

​ ① 一个类中，如果没有显式的声明构造方法，java编译器会自动添加一个无参空构造。

​ ② 一个类中，如果显式声明了构造方法，编译器就不会添加

代码

package com.demo; 
/** 
1.构造方法的声明： 
格式: 
[权限修饰符] 类名(参数列表){ } 
2.注意：
① 一个类中，如果没有显式的声明构造方法，java编译器会自动添加一个无参空构造。
② 一个类中，如果显式声明了构造方法，编译器就不会添加。 
*/
public class 构造方法 { 
    public static void main(String[] args) {
        /* 
        C c = new C(); 
        c.name = "zs"; 
        c.age = 19;
        */
        C c1 = new C("张三",19); 
        System.out.println(c1.name); 
    }
}
class C{
    String name; int age; 
    /*public C(int a){ }*/
    public C(String name,int age){
        this.name = name;
        this.age = age;
    }
    public void fun(){
        System.out.println("这是C中的一个一般方法。"); 
    }
    //方法
    public void C(){} 
}

构造方法与一般方法的区别

1.写法上：

​ 构造方法：没有返回值类型的，连void也没有。

​ 一般方法：必须有返回值类型。

2.调用方式上：

​ 构造方法：new使用，创建对象时才会被调用。

​ 一般方法： (除static修饰)在创建对象后，被对象调用。

3.使用次数上：

​ 构造方法： 对同一个对象来说，只能使用一次。

​ 一般方法： 对同一个对象来说，可以使用无数次。

构造方法的重载形式

格式：

​ [权限修饰符] 类名(参数){}

根据参数的不同，可以有不同的构造方法，这种叫做构造方法的重载的形式。

成员变量与局部变量

概念

成员变量： 属性，全局变量，类中 方法外

局部变量： 方法中。

成员变量与局部变量重名问题

① 当成员变量与局部变量同名时，由于就近原则，局部优先，使用的是局部变量，如果想使用成员变 量，需要在成员变量的名称前面加this。格式：this.成员变量名称。

② this的用法之一： 代表当前类的当前对象。this一般不用区分的时候，可以省略，必须要与局部 变量区分的，必须带。

成员变量与局部变量的区别：

1.位置：

​ 成员变量：类中方法外

​ 局部变量：方法中

2.内存中的位置：

​ 成员变量：堆中对象里

​ 局部变量：栈中方法里

3.生命周期：

​ 成员变量： 随着对象的存在而存在，随着对象的消亡而消亡

​ 局部变量： 随着方法的压栈而存在，随着方法的弹栈而消亡。

静态

概念

静态： static

总结：

​ ① 对于静态修饰的成员，用static进行修饰的成员，存放在方法区的静态区中。

​ ② 静态成员随着类的加载而加载，并且只加载一次。

​ ③ 静态成员特点：实例共享。即所有的对象共享该成员。

​ 实例：就是对象

静态成员格式

① 凡是static修饰的 ，都是静态成员。

② 调用格式：

​ 类名.属性名称/方法名称(参数)

③ 静态成员又叫类成员，属性被称为类属性，方法被称为类方法。

静态成员与非静态成员之间的调用关系

1.静态成员与非静态成员之间的调用关系:

​ ① 静态成员与静态成员之间：

​ 静态成员调用静态成员：直接调用。

​ ② 非静态成员与非静态成员之间:直接调用。

​ ③ 非静态成员调用静态成员：直接调用

​ ④ 静态成员调用非静态成员：不能直接调用。

​ 要想使用:

​ 可以添加为静态

​ 创建对象，保证非静态成员存在，才可以使用。

总结：

静态成员中调用非静态，不能直接调用的

代码

package com.demo;
/**
（***）1.静态成员与非静态成员之间的调用关系:
① 静态成员与静态成员之间： 
1>静态成员调用静态成员：直接调用。 
② 非静态成员与非静态成员之间:直接调用。
③ 非静态成员调用静态成员：直接调用 
④ 静态成员调用非静态成员：不能直接调用。 
要想使用: 
1> 可以添加为静态
2> 创建对象，保证非静态成员存在，才可以使用。 
总结：静态成员中调用非静态，不能直接调用的。
*/ 
public class 静态成员与非静态成员之间的调用关系 {
    public static void main(String[] args) {
        静态成员与非静态成员之间的调用关系 m = new 静态成员与非静态成员之间的调用关系(); 
        m.fun1(); 
    }
    public void fun1(){} 
}
class C{
    int a ; 
    static int b;
    public void fun(){
        a = 10; 
        b = 30; 
    }
    public static void sfun(){
        b = 5;
        //C c = new C(); 
        c.a = 15; 
    }
}

静态成员与非静态成员区别:

1.写法：

​ 静态成员： static修饰

​ 非静态成员： 没有static修饰

2.内存中的位置：

​ 静态成员： 方法区的静态区中

​ 非静态成员：

​ 属性： 堆中的对象里

​ 方法： 方法区的非静态区

3.调用：

​ 静态成员： 类成员。

​ 类名.属性/方法(参数)

​ 非静态成员: 实例成员

​ 对象名称.属性/方法(参数)

4.生命周期:

​ 静态成员: 随着类的加载而加载，随着类的消亡而消亡

​ 非静态成员: 随着对象的加载而加载,随着对象的消亡而消亡。

JavaBean

javaBean：符合某种规范的java的类，

规范：

​ ① 必须有getter与setter方法。

​ ② 必须有无参构造器。如果显式声明了其它构造，没有无参的话，需要手动添加。

初始化问题

1.默认初始化:开辟空间，赋默认值。

2.显式初始化：直接在声明属性时 为属性赋值

3.构造初始化:在构造方法中为属性赋值。

​ 顺序：

​ 默认初始化 –> 显式初始化 –> 构造初始化

代码

package com.demo;
/**
1.默认初始化 
.显式初始化 
3.构造初始化
顺序：默认初始化 --> 显式初始化 --> 构造初始化 
*/ 
public class 初始化顺序 { 
    public static void main(String[] args) { 
        D d = new D(15); 
    } 
}
class D{
    int a = setA();//显式初始化
    public D(int a ){ 
        // System.out.println(this.a);
        this.a = a;//构造初始化 
        // System.out.println(this.a); 
    }
    public int setA(){ 
        System.out.println(a); return 1;
    }
}

包（package）

  • 功能

    分类管理Java文件

  • 命名规则

    原则：全球唯一

    公司域名的倒置+项目名称+模块名称+包的功能名称

  • 包的分隔符

    用点进行分割，每个点表示一层

  • 包的声明：表明该类在哪个包下。如果没有package声明，z在src下

    package 包的路径；

    注意：

    包的声明只能有一个

权限修饰符

四种权限

  • public

    公开的,在整个项目中都可以访问

  • protected

    受保护的，在当前和其他包的子类

  • default/friendly

    这种就是省略不写，表示该种，没有权限修饰符的 专门词

    默认的 本包可以访问

  • private

    私有的 本类可以访问

avatar
青山
悟已往之不谏 知来者之可追
一言
今日诗词
站点信息
本站访客数 :
本站总访问量 :