第五天：面向对象_假设student是一个类,则有:student stu = ne-CSDN博客

本文链接：https://blog.csdn.net/lhhzzy/article/details/114242323

面向对象

面向对象与面向过程

之前在网上看的很生动形象：就像肉包子，面向对象等于把包子皮和馅分开做了，要什么馅就用什么。而面向过程等于把馅和皮一起做，然后成了一个香喷喷、色泽均匀的玉米包，然后要换成香芋味的就要整个包子丢掉或者整个包子改动分离，天呐我的玉米包不需要了，我又得揉面粉和制造馅料了，如果我用面向对象就只需要做馅料，虽然不太好吃，但是起码口味我爱呀

类与对象

类：是指描述一类事物，或者看成是一个分类，例如人类、学生、星球类,

对象：是指具体的个体（也叫实例-instance）, 例如张三李四，旺财

对象的创建

如何创建对象：

首先要有类

public class Student {
    String name;
    int age;

}

类型变量名 = new 类名() 比如 Student stu = new Student();

public class Ckz5 {
    public static void main(String[] args) {
        Student stu = new Student();
       
    }
}

给对象赋值和取值：

赋值–>对象名.字段名比如 stu.name=”Xxxx”;

取值：–》对象名.字段名比如 stu.name

public class Ckz5 {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.name = "旺财";
        stu.age = 18;
        System.out.println(stu.name);
      
        System.out.println(stu);

    }
}

构造方法

概念

构造方法的结构和普通方法类似，但是和普通方法完全不同两个代码块；
构造方法也是方法，意味着使用了构造方法，方法会执行，也能完成功能
构造方法就是一个代码块【就是一个结构，构造方法和字段方法一样都是一个类中的成员之一】
构造方法也该存在于类的结构体中

写法

构造方法的名字和类名一致【包括大小写完全一致】
没有返回值类型
构造方法内部不需要返回任何的数据
其他的和普通方法类型，可以有修饰（public）,可以有形参列表，可以有方法体

特点

每一个类中都至少有一个构造方法;
如果没有看到（显示的），那么存在一个隐式的无参数的构造方法;
如果一个类中有显示的构造方法，那么隐式的就不存在了;

作用

① 通过调用构造方法可以创建对象

② 可以在创建对象的同时给对象的字段赋值

注意点

普通方法和构造方法是不同的两种结构
调用方法不一样
普通方法的调用： 3种

类名.方法名+参数列表

对象.方法名)

直接方法名

—》不适用于构造方法
构造方法的调用： 1（目前） new Xxx(…);

匿名对象

 public static void main(String[] args) {
        new Student().name="大娃";

        System.out.println(new Student().name);
        //输出的为null    这个输出语句中的new Student()其实就是匿名对象
    }

概念：

匿名对象，就是没有名字的对象[创建了一个对象而没有使用变量接收]
该对象存在于堆总处于游离状态：没有任何变量持有引用地址,指向他
但是匿名对象本质也是一个对象
1. int i = 10;//int数据类型 i变量值，具体的一个数据
2. Student stu = new Student();//Student数据类型 stu对象 new Student();堆中的一个对象
理解：
1. stu本质是一个变量，接收了引用地址，使用stu本质使用对象
2. stu变量值中即存放了一份数据，new Student()对象即，是Student类型的一个数据

使用场景

1.只使用一次(比如 new Student().eat())

2.可以作为一个方法的实际参数 test(Student stu) --> test(new Student())

static关键字

修饰作用的范围

1.普通方法：可以
2.字段[成员变量]

3.类[
外部类:不行：java规定
内部类：写在类里面的类叫做内部类]可以 java规定！面向对象最后阶段，看内部类
本质内部类还是一个类而已！
4.局部变量:不行
5.构造方法:不行

static类级别的修饰符理解

(1) static修饰的字段:应该通过类名.字段名访问

(2) static修饰的字段:应该通过类名.方法,该字段被该类的所有对象共享

对象级别

(1) 非static修饰的字段:对象名

(2) 非static修饰的字段及方法,当创建对象时候,独属于每一个对象,没有被该类的所有对象共享

\3. 静态上下文不予许访问非静态的变量及方法

class _00Hello{

int i = 10;

public static void main(String[] args){

   System.out.println(i);//静态的上下文，无法访问非静态的比变量i

     eat();//静态的上下文，访问非静态的变量

}

static void sleep(){

   eat();//静态的上下文无法访问非静态的方法

}

void eat(){

}

}

\4. 非静态上下文可以访问静态上下文:

class Student{

	static String name;

	static void eat(){//类级别

		System.out.println("吃学习......");

	}

	int age;//对象级别

	void run(){//对象级别

		System.out.println("顺拐.......");

    eat();

	}

包

*Java包概念****：包（package）是Java提供的一种区别类的名字空间的机制，是类的组织方式，是一组相关类和接口的集合，它提供了访问权限和命名的*管理机制****。

包作用

可以管理代码结构：

500W项目（1000个文件）不好查找
可以避免类名冲突的问题

一个项目中有可能多个类名一样

操作系统中同一个文件夹中不能存在相同名字的两个文件

使用包

包的声明

包命名规范：一般是公司域名反过来写 + 项目名+模块名字+子模块名

直接在顶部最开始位置申明

package cn.baidu.crm.oa.domain;
class Test{	
}

导包

import 包名.子包名.类名；
import 包名.子包名.*;//*通配符，通配该类所在的子包名
同一个类中用到了java.util.Date java.sql.Date 导入会区别不了二异，所以通过****完全限定名****的方式使用

java.lang这是Java规定的核心包，使用的时候会自动导入，所以不用手动导入

package cn.baidu;//import java.util.Arrays;//1)import 包名.子包名.类名；
import java.util.*;//2)通配符表示用到了util该子包下面的类  //imprt java.*;//错误方式，或者imprt *;也是错误方式！

class Test{
	public static void main(String[] args) {
		int[] arr = {1,5,3,4,7,9,8};
		//导入包之前:必须通过完全限定名的方式找到Arrays
		//java.util.Arrays.sort(arr);
		//System.out.println( java.util.Arrays.toString(arr) );
		//导入包之后:可以直接使用Arrays

		Arrays.sort(arr);
		System.out.println( Arrays.toString(arr) );
	//3)一个类中同时存在java.sql.Date  java.util.Date; 你直接new Date();会错误; 通过完全限定名的方式使用

		java.util.Date udate = new java.util.Date();
		java.sql.Date dat = new java.sql.Date(1L);
		
	//4)java.lang这是Java规定的核心包，使用的时候会自动导入，所以不用手动导入
		String name = "大娃";
		System.out.println(name);
	}
}

封装

概念：就比如笔记本，一个笔记本里面有显卡键盘啊摄像头啊，但是他们有一个整体就是笔记本，这个就是封装

在Java 中的体现及步骤

把类中的字段私有化；
给每一个字段都提供一组getter setter方法 (方法的规范写法)；setXxx

在测试类中尝试创建对象,并通过调用getter setter方法完成对字段的赋值和取值；

3) 提供一个无参数的构造方法

给对象的字段赋值一共有哪些方式：

直接访问字段赋值标准java类 X 字段一般都会给私有化（私有化访问不到）；
通过构造方法赋值只能够创建对象的时候赋初始值；
通过setXxx方法赋值 ****更灵活****；

this

this的概念：this指代当前对象，持有当前对象的地址

public class Ckz5 {
    public static void main(String[] args) {
        Student arr=new Student();
        arr.setAge(18);
        System.out.println(arr.getAge());
        //输出18
    }
}

public class Student {
    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    String name;
    int age;
    Student(){
        System.out.println("卧槽");
    };

}

继承

概念：

1) ****泛化****：在多个子类的基础上面抽取共有属性的行为到一个父类中去

2) ****特化****：在一个父类的基础上拓展子类特有的属性和行为，生成一个新的子类

原则：父类存放共性，子类存放特性

基本语法

class Animal{}

class Person extends Animal{} //目标就是为了继承到Animal,这个类型

A 就是B的父类; B是A的子类

继承的东西

(1) 非私有的字段及方法

(2) 父类特性

继承的特点

(1) 单继承

(2) 多重继承

(3) 没有显示的继承,那么隐式的继承Object

Object类

概念

每一个类都有一个直接父类,如果没有看到显示的继承代码,那么就隐式继承就Object
理解：Object是每一个类的，直接父类或者间接父类
Object所有类的根类,是一个非常重要的类,所有类的重要的公共的静态属性，及动态行为[方法]都被提取到了Object

1)Student s = new Student();
s.hashCode(); 可以的
2)String s2 = “等等”;
s2.hashCode();可以的
3)int[] arr = new int[6];
arr.hashCode();可以的
4)int i = 5；//基本类型数据不是对象
i.hashCode();//不可以的

里面的几个方法

String toString() 返回调用此方法的当前对象的字符串表示形式(把当前对象转成字符串)
boolean equals(Object obj) 比较两个对象是否相等(比较调用此方法的对象是否和传入的obj”相等”)
int hashCode() 通过对象结合算法得到一个int值
Class<?> getClass() 返回此 Object 的运行时类(获得一个对象的真正的类型)

经常需要覆写的方法

toString

String toString() 返回调用此方法的当前对象的字符串表示形式[把当前对象转成字符串]
明确什么是对象描述：静态描述，姓名年龄 …
实际打印地址值：不符合对于对象的描述
打印语句打印对象，实际在调用父类toString方法，打印的对象描述

父类toString方法返回结果，不符合子类需要打印对象描述的需求，所以覆写toString方法

覆写toString方法的意义及什么时候需要覆写toString

a) 意义：自定类创建的对象可以准确的打印对象描述

b) 什么时候需要覆写：自定义类需要打印对象描述的时候

什么时候需要覆写Object中的equals方法,及覆写的意义

(1) 什么时候需要覆写自定义类对象,相互之间需要比较对象的静态属性的时候!

(2) 覆写的意义:能够需求,正确的比较对象,静态属性

== 和 equals区别

== 比较运算符
1. 基本数据类型变量: 比较的就是值是否相等;
2. 引用数据类型变量: 比较的是对象的地址是否一样;（排除特殊 String）
equals 方法[最初定义在根类Object中的,比较对象是否相等]方法里面 ==
1. 基本数据类型 : 不能够使用! 基本数据类型不是对象,不能够调用Object中的方法
2. 引用数据类型 : 但是在Object的源码中定义的就是 == 进行比较比较
定义好的类没有覆写过equals方法，则会直接调用到了Object中的equals方法,那么本质还是在使用==比较
在实际开发中,自定义类：一般比较对象，都是通过对象的属性值进行比较,所以自定义类，会经常覆在自定义的类中写Object中的此方法,把自己的比较规则写在方法里面;
覆写equals方法的意义：定义类，覆写equals方法，自己制定规则，比较自定义类对象的静态属性