JAVA面向对象

1. 什么是面向对象

1.1面向对象与面向过程的区别 :

• 共同点 : 一种思想,思维方式,思考问题的角度

• 异同点 :

面向过程 : "我该如何实现?,然后一步一步实现",我面向实现过程

面向对象 : "我该找谁实现?",我只关注对象,不关心对象的实现过程

1.2面向对象优点 :

1.面向对象可以将复杂的问题简单化

2.面向对象更贴合管理者思考角度,面向过程贴合于执行者的思考角度

1.3如何使用面向对象思想进行编程 :

将程序与生活紧密联系

类 : 抽取了一系列对象的共性-->图纸|模板|实体类

对象 :描述现实生活中真实存在的事物|实例

先有类,在根据类创建对象

2. 实体类 :

2.1分析 :

1.一系列对象(手机)都有哪些共同属性|特点|特征? 名词 ---> 成员变量 : 定义在类中方法外

颜色 品牌 价格 尺寸 .....

2.一些列对象都有哪些共同的功能|能力? 动词 ---> 成员方法 : 定义在类中方法外(不被static修饰的方法)

打电话....

2.2语法 :

public class 类名{
//成员
//属性
修饰符 数据类型 变量名;

//功能
修饰符 返回值类型|void 方法名(参数列表){
实现功能代码;
}
}

public class Class001_Phone {
    //属性 :  颜色   品牌    价格    尺寸
    public String color;
    public String brand;
    public int price;
    public double size;

    //功能 : 打电话
    public void call(){
        System.out.println("从前有一个长的像电话,出门就被打了...");
    }
}

2.3 调用类的成员变量和成员方法

1.导包 : 指明要使用的类型的位置

import 权限定名;

不需要导包的类 :

1.java.lang包下的类

String System Math...

2.同包类

2.创建对象 new

引用数据类型 变量名|对象名|引用 = new 引用数据类型();

        Class003_Angel angle1=new Class003_Angel();

实体类可以根据需求创建多个对象

        Class003_Angel angle1=new Class003_Angel();
        Class003_Angel angle2=new Class003_Angel();
        Class003_Angel angle3=new Class003_Angel();
        Class003_Angel angle4=new Class003_Angel();
        Class003_Angel angle5=new Class003_Angel();                   

3.使用对象

使用属性 : 为属性赋值|获取属性的值

对象.变量名

使用功能 : 调用方法

对象.方法名(实参)

public class Class002_PhoneTest {
    public static void main(String[] args) {
        //1.导包-->同步类
        //2.创建手机对象
        Class001_Phone phone = new Class001_Phone();
        //3.使用
        //为属性赋值
        phone.color = "白色";
        phone.size = 6.0;
        phone.brand ="华为";
        phone.price =6999;

        //获取属性值
        System.out.println(phone.color);
        System.out.println(phone.size);
        System.out.println(phone.price);
        System.out.println(phone.brand);

        //调用功能
        phone.call();
        phone.call();
        phone.call();
    }
}

注意 : 成员是属于对象的,需要跟随对象使用成员(成员变量|成员方法)

成员变量只声明不赋值存在默认值 : 整数0 小数0.0 布尔:false 字符:空字符 引用数据类型:null

2.4构造器

构造器|构造方法|构造函数 :

特殊方法

2.4.1作用 : 为对象初始化信息(不是用来创建对象的)-->为对象的属性赋值

2.4.2使用 : 跟随new一起使用

定义 :
修饰符 类名(参数列表){
为属性的赋值语句;
}

    //空构造
    public Dog(){
        System.out.println("空构造");
    }
    //带参构造
    public Dog(String dogName){
        System.out.println("带参构造1");
        name = dogName;
    }

2.4.3注意 :

• 构造器也能构成重载,根据需求进行的定义

public Dog(String dogName){
        System.out.println("带参构造1");
        name = dogName;
}
public Dog(String dogName,String dogType,String dogColor){
        System.out.println("带参构造2");
        name = dogName;
        type = dogType;
        color = dogColor;
}

• 没有显示定义构造器,编译器会默认提供一个空构造

• 如果存在显示定义的构造器,编译器不会提供任何构造器

• 以后定义实体类,至少提供一个空构造

• 以后定义的实体类,空构造需要手动提供

2.5 this 关键字

2.5.1this定义 :

指代当前对象(构造器中指代当前new的对象|在成员方法中指代调用成员方法的对象)

1)在构造器的首行通过this(参数)调用本类中的其他构造器

2)区分同名的成员与局部变量问题

如果存在同名问题,默认指代局部,因为就近原则

如果想要指代成员,需要通过this.进行调用

如果不存在同名问题,局部有就找局部

成员有就找成员,默认省略this.

 public Student(String name,int no,int grade){
        this.name=name;
        this.no=no;
        this.grade=grade;
    }

2.5.2注意 : 多个构造器之间不能相互调用

this不能使用在static方法中

2.6 static 静态的

成员修饰符,只能修饰成员不能修饰局部的成员修饰符

static修饰成员变量--> 静态变量|类变量

static修饰成员方法--> 静态方法|类方法

static修饰块

public String i = "实例变量"; //实例变量
public static String j = "静态变量";  //静态变量

2.6.1 静态变量与静态方法的使用方式 :

1)通过类名调用

类名.静态变量名

类名.静态方法名(参数)

//测试静态与成员的使用方式
        //静态
        System.out.println(j);
        System.out.println(Class001_Static.j);
        Class001_Static cs = new Class001_Static();
        System.out.println(cs.j);
        testStatic();
        Class001_Static.testStatic();
        cs.testStatic();

      

2)通过对象调用

对象.静态变量名

对象.静态方法名(参数)

  //成员
        //System.out.println(Class001_Static.i);
        System.out.println(cs.i);
        cs.test();

2.6.2成员变量 :

被static修饰的成员变量 --> 静态变量|类变量

不被static修饰的成员变量 -->成员变量|实例变量

2.6.3成员方法 :

被static修饰的成员方法 --> 静态方法|类方法

不被static修饰的成员方法 -->成员方法|实例方法

2.6.4注意 :

1. 成员是属于对象的,需要跟随对象进行使用

成员变量在对象的堆内存中,有对象,才有堆内存,就有成员变量,有多少对象,就有多少块对象的堆内存,就有多少分成员变量

2. 静态的是属于类的,需要跟随类名使用,也可以跟随对象使用

静态变量在静态区,是独一份的,被所有对象共享的

2.6.5 加载初始顺序 : 先静态后成员

静态内容在类第一次加载到内存之后就会初始化

成员成员在执行到new对象的时候,才会开辟对象的堆内存,在会存在成员变量

2.6.6总结 :

在成员方法(非静态)中,可以直接调用静态,可以直接调用非静态(实例)

在静态方法中,可以直接调用静态,需要通过对象调用成员

3. 块Block{ }

3.1 自成作用域

• 变量的作用域是从变量声明开始到包裹着它最近的回花括号结束

• 在块中定义的变量是局部变量只在花括号中有效

 {
        int i=0;//变量作用域开始
        System.out.println("局部代码块");
}//变量作用域结束

3.2块的分类及其特点

3.2.1普通代码块|局部代码块

• { }定义在局部位置

• 跟随方法的调用执行

3.2.2 构造块|成员代码块

• 定义在成员位置

• 跟随new一起执行

• 做成员的初始，先于构造器的统一初始

3.2.3 静态块

• static{ }定义在成员位置

• 类第一次加载时就加载静态代码块

• 作用：初始化加载配置，静态成员初始化

public class Class001_Block {
    //成员
    static int i = 10;

    //静态块
    static{
        System.out.println("静态块1");
    }
    static{
        System.out.println("静态块2");
    }
    static{
        System.out.println("静态块3");
    }


    //构造器
    public Class001_Block(){
        System.out.println("空构造...");
    }

    public Class001_Block(boolean flag){
        System.out.println("带参构造...");
    }

    //构造块|成员代码块
    {
        System.out.println("构造块1");
    }
    {
        System.out.println("构造块2");
    }
    {
        System.out.println("构造块3");
    }


    public static void main(String[] args) {
        System.out.println("我是main方法");
        //局部
        int i =1;

        //普通语句块|局部代码块
        {
            i =2;
            System.out.println(i); //2
        }

        System.out.println(i);  //2

        new Class001_Block();
    }
}

3.3注意

• 统一作用域范围内,变量不能同名

• 构造块会被编译到要执行的构造器内部,构造器代码的上面,先于构造器代码执行执行

• 静态块在第一次加载完成之后执行,并且只执行一次

• 如果存在多个块,从上倒下依次执行

4. 包和导包

4.1 包机制 : 文件夹

• 1)提供了多重命名空间

• 2)管理众多的资源

4.2 定义 :

公司域名倒着写+功能名字|模块名字

4.3 位置 :

包信息存在java文件的首行 package com.yjxxt.package05;

package->import->class

4.4导包 : 指明要使用的类型的位置

不需要导包的类型 : 1)java.lang 2)同包下的类型

4.4.1.使用的位置指明类型的权限定名(包名.类名),只在当前一次有效

 java.util.Scanner sc = new java.util.Scanner(System.in);

4.4.2.需要通过import进行导包

• import 包名.类名;

import java.util.Scanner

• import 包名.*; --> 模糊导入,模糊匹配当前包下的所有类型,只会影响编译效率,不会影响运行效率

import java.util.*;

• import static 包名.类名.静态变量|方法; 只导入静态内容

import static java.lang.Math.PI;
import static java.lang.Math.round;
import static java.lang.Math.*;//静态变量也支持模糊导入

4.5注意 :

先建包再建类

了解jdk中常用的包信息