Java面向对象

1、面向对象

1.1 定义

思想、思维方式 、思考问题的角度

1.2 优点

复杂的问题简单化，更贴近现实生活中人类的思维角度

1.3 面向对象与面向过程的区别

①面向过程就是分析出解决问题所需要的步骤，然后用函数实现、调用，关注过程；
②面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为，关注结果。
③面向过程适用于执行者,面向对象适用于管理者

2、类

2.1 类的定义 :

​ public class 类名{
​ //1.属性-> 成员变量
​ 修饰符 数据类型 变量名 = 赋值;
​ 修饰符 数据类型 变量名;
​ …
​ //2.功能-> 成员方法(不被static修饰)
​ public void|返回值类型 方法名(参数列表){
​ 实现功能的代码;
​ [return 返回值;]
​ }
​ …
​ }

2.2 用例

public class Class_Car {
   
    public String brand;
    public String color;
    public double price;
    public void drive(){
   
        System.out.println("一辆"+price+"的"+color+"的"+brand+"即将开始旅程");
    }
}

3、对象

3.1 导包

	指明要使用类型的位置
 		注意：不需要导包的类型: 1)java.lang下  2)同包下的类

3.2 创建对象

​ 引用数据类型 变量|引用 = new 引用数据类型();

​ new关键字具有创建对象的能力

3.3 使用属性|功能

​ 引用.属性
​ 引用.功能名字(参数列表)

3.4 用例

public class Class_CarTest{
   
    public static void main(String[] args){
   
        //创建对象
        Class_Car car=new Class_Car();
        //赋值
        car.brand="奔驰";
        car.color="黑色";
        car.price=500000;
        //调用
        car.drive();
    }
}

***注意：***
	1）new关键字创建对象的步骤:
			①在堆中为对象开辟空间，同时成员变量跟随对象进入堆内存，并赋默认值
			②调用构造器为对象初始化信息
			③将地址返回给引用
 	2）成员变量只声明不赋值存在默认值  
     		整数0  小数0.0   boolean:false   char:空字符   引用数据类型: null
  3）先有类才能创建对象,有了对象才有了成员变量,才能使用成员

4、构造器（构造函数、构造方法）

4.1 作用

​ 为对象初始化信息(为对象的成员变量赋值)

4.2 使用

​ 跟随new关键字一起使用,不能单独调用

4.3 定义

	修饰符 类名(参数列表){  }

4.4 用例

public class Class03_ComputerTest {
   
    public static void main(String[] args){
   
        //创建对象的同时为成员变量赋值
        Computer c=new Computer("联想",5000);
        c.run();
    }
}
class Computer{
   
    String brand;
    double price;
    //带参构造器
    public Computer(String pcbrand,double pcprice){
   
        if(pcprice<0){
   
            System.out.println("价格不合法无法初始化...");
            return;
        }
        brand=pcbrand;
        price=pcprice;
    }
    public void run(){
   
        System.out.println("一台"+brand+"电脑正在运行");
    }
}

注意:
①构造器不能定义void|返回值
②构造器也是特殊的方法,具有方法重载的特性->构造器的重载
③如果一个类中没有显示的定义构造器,编译器会自动默认提供一个空构造(没有参数的构造器)
④如果存在显示定义的构造器,编译器不会再为类型提供任何构造器了,包括空构造
⑤构造器中可以存在return,根据需求定义,实现提前结束构造器,但是不能带出返回值
⑥构造器帮助实现,在通过new关键字创建对象的同时为对象初始化信息
⑦ 以后定义模板类,至少提供一个空构造,按需提供带参构造

5、局部变量和成员变量的区别

5.1 使用

​ 1）局部变量需要声明且初始化之后才能被正常使用

​ 2）成员变量可以声明之后直接使用，不同的数据类型作为成员变量Java都会给一个默认值

​ （所有的整数 都是 0 byte、short、int 、long

​ 所有的浮点数 都是 0.0 float double

​ boolean类型的默认值是 false

​ char类型的默认值是 空格

​ 所有引用类型的默认值都是 null ）

5.2 位置

​ 1）局部变量是在方法中或者时代码块中

​ 2）成员变量而言声明在类中方法外

5.3 作用域

​ 1）局部变量而言，在声明开始都 方法或者时代码块结束为止

​ 2）成员变量，整个类中都有效

5.4 调用方式

​ 1）局部变量而言，在方法中直接通过变量名直接使用

​ 2）成员变量而言： 在当前成员变量前加static修饰 此时可以直接在static修饰的方法中直接使用

6、this关键字

6.1 this.

​ 指代当前new的对象

​ 区分局部与成员同名问题

​ 默认就近原则

​ 存在同名问题,指代成员需要通过this.调用

​ 不存在同名问题时候,指代成员直接使用省略this.

6.2 this(参数列表)

​ 在构造器的首行用来调用本类中其他构造器

​ 注意:

​ 1）不能多个构造器之间通过this相互调用

​ 2）this存储指代对象的地址

​ 3）在构造器中遇到this指代对象,默认代表当前new的对象

​ 4）在成员方法中的this默认指代调用成员方法的对象

​ 5）this不能使用在static修饰的方法中

6.3 用例

public class Class04_This {
   
    public static void main(String[] args){
   
        //匿名对象 : 只能在当前行使用一次
        new People("张三",12,true).info();
        People p=new People("lisi",18);
        System.out.println(p);
        p.info();
    }
}
class People{
   
    public String name;
    public int age;
    public boolean sex;
    //两个参数的构造器
    public People(String name,int age){
   
        this();
        this.name=name;   //在构造器中遇到this指代对象,默认代表当前new的对象
        this.age=age;
        System.out.println(name+"……"+age+"……");
    }

    public People(){
   
        System.out.println("空参");
    }
    //三个参数的构造器
    public People(String name,int age,boolean sex){
   
        //this(参数列表)：调用同类
        this(name,age);
        this.sex=sex;
        System.out.println(name+"……"+age+"……"+sex);
    }
    //在成员方法中的this默认指代调用成员方法的对象
    public void info(){
   
        String name = "xixihaha";
        System.out.println(name+"-->"+this.age+"--->"+sex);
    }
}

7、static

7.1 定义

​ static 静态的 成员修饰符: 只能修饰成员不能修饰局部！！！
​ 修饰变量 : 静态变量|类变量
​ 修饰方法 : 静态方法|类方法
​ 修饰块 : 静态块
​ 修饰类 : 静态内部类

7.2 静态变量与静态方法的使用:

​ 1)类名.静态变量名
​ 类名.静态方法名(参数列表)
​ 2)对象.静态变量名
​ 对象.静态方法名(参数列表)
​ 注意:
​ 1）静态的是属于类的！！
​ 2）成员是属于对象的,只能跟随对象使用！！
​ 3）成员变量存在与对象的内存空间中,有多少对象的堆内存空间,就存在多少份成员变量
​ 4）静态的变量是独一份的,当前类的多个对象共享的,存在与静态区中
​ 5） 先静态后成员！！
​ 6）在静态内容中使用: 只能直接使用静态内容,不能直接使用成员内容,需要跟随对象使用成员
​ 7）在成员内容中使用: 可以直接使用成员,可以直接使用静态

7.3 用例

public class Class01_Static {
   
    static int i=5;//静态变量
    int j=3;//成员变量
    public static void main(String[] args) {
   
        //局部变量
        int i=1;
        //类名调用静态内容
        System.out.println(Class01_Static.i);
        Class01_Static.test1();
        //对象
        Class01_Static st=new Class01_Static();
        //只能通过对象调用成员
        System.out.println(st.j);
        st.test2();
        //对象调用静态内容
        System.out.println(st.i);
        st.test1();
    }
    //静态方法
    public static void test1(){
   
        System.out.println("这是一个静态方法");
    }
    //成员方法
    public void test2(){
   
        System.out.println("这是一个成员方法");
    }
}

8、block块

8.1 定义

​ { } : 自成作用域

8.2 分类

​ 1）局部代码块：定义在方法中或语句块中

​ 2）构造块：定义在类中方法外

​ 3）静态块：定义在类中方法外

​ 4）同步块

​ 注意：

​ 1）构造块中的代码会先于构造器中的代码之前执行,在编译期间构造块中的代码会被编译到要执行的构造器代码的最上面

​ 2）如果存在多个构造块,从上到下一次执行

​ 3）静态块会在类第一次加载完成之后进行执行,并且只执行一次

​ 4）如果存在多个静态块,从上到下一次执行

​ 5）构造块作用 : 为成员提供默认初始化

​ 6）静态块作用 : 1)为静态内容提供默认的初始 2) 基础设置等的加载(数据库的驱动…)

8.3 用例

public class Class02_Block {
   
    static int i=8;
    //静态块：类第一次加载时执行
    static{
   
        System.out.println("我是静态块");
    }
    //构造块：跟随new一起使用
    {
   
        System.out.println("我是构造块");
    }
    //构造器
    public Class02_Block(){
   
        System.out.println("我是构造器");
    }
    public static void main(String[] args){
   
        //局部代码块：跟随方法的调用
        {
   
            System.out.println("我是局部代码块");
        }
        System.out.println(i);
        new Class02_Block();
    }
}

9、debug

​ 调试工具

9.1 作用

​ 1.追踪程序的执行流程
​ 2.定位异常出现的位置
​ 3.观察程序执行过程中变量的变化情况
​ 4.根据追踪程序的执行流程学习第三方框架的源码

9.2 步骤

​ 1、设置断点
​ 在行号的后面鼠标单击设置断点
​ 2、Debug运行
​ 3、debug运行模式下进行调试
​ Step over F8 : 下一步跳过|略过
​ 如果下一步是方法的调用,不会跟随方法的调用执行,直接进入下一步
​ Step into F7 : 步入 | 下一步进入
​ 如果下一步是自定义方法的调用,跟随方法的调用执行每一步
​ Step out shift+f8 : 下一步调出
​ 如果在方法的内部,下一步直接调出到方法调用处
​ Force step into alt+shift+f7 : 下一步强制进入
​ 如果下一步是方法的调用,包括jdk源码方法的调用,强制进入,跟随执行
​ Run to Cursor alt+F9 : 直接运行到鼠标光标所在位置

10、package和import

10.1 包机制

​ 文件夹
​ 帮助管理众多的资源
​ 提供了多重命名空间

10.2 包信息

​ 存在与java文件的最上面首行,标识当前类型所在的包路径

10.3 导包

​ 指明要使用类型的位置
​ 如果要使用其它类型,可能涉及到导包问题

10.4 不需要导包的类

​ 1)java.lang包下的内容
​ 2)同包类

10.5 导包的方式

​ 1.使用的位置指定类型的全限定名 : 包名.类名
​ 只能在当前位置使用一次,简单方便,但是使用频繁的话建议使用import导包
​ 2.import关键字进行导包
​ 定义语法 : import 包名.类名;
​ 位置: 类的上面,package信息下面
​ 3.模糊匹配
​ 模糊匹配当前报下要使用的所有类型
​ 只会降低编译效率,不会降低运行效率
​ 4.静态导入 import static
​ 导入一个类型中的静态内容
​ 注意:
​ 以后项目中需要先定义包后定义类型

10.6 用例

package com.oop01;
import java.util.*;
import static java.lang.Math.PI;
import static java.lang.Math.round;
public class Class04_Import {
   
        public static void main(String[] args) {
   
            Scanner sc2 = new Scanner(System.in);
            Random ran = new Random();
            ArrayList list = new ArrayList();
            System.out.println(PI);
            System.out.println(round(1.4));
        }
    }

11、private

11.1 定义

	private 私有的,成员修饰符(只能修饰成员不能修饰局部)

​ 数据的安全隐患问题时 解决 : private 私有的

​ 一旦被private关键字修饰的成员只能在当前类中使用
​ 私有的属性需要配合一对公共的访问方式

	 设置器 setter : 成员方法,为私有属性设置值

​ 访问器 getter : 成员方法,获取私有属性的值

11.2 用例

public class Class05_Private {
   
    public st