📜个人简介

⭐️个人主页：摸鱼の文酱博客主页🙋‍♂️
🍑博客领域：java编程基础,mysql
🍅写作风格：干货,干货,还是tmd的干货
🌸精选专栏：【Java】【mysql】【算法刷题笔记】
🎯博主的码云gitee，平常博主写的程序代码都在里面。
🚀支持博主：点赞👍、收藏⭐、留言💬
🍭作者水平很有限，如果发现错误，一定要及时告知作者哦！感谢感谢！

💛前言:

(文章目录带⭐️为需要重点掌握的)

准备好了吗? 我们要开始了!
在这里插入图片描述

面向对象--类和类的成员

💛前言:
👓认识面向对象
👓理解类和对象
- 类的实例化
🌟 1.属性(变量)
🌟 2.方法
🌟 3.构造器
🌟 4.代码块
🌟 5.内部类

)

👓认识面向对象

首先,上正菜🍔 前,先让我们来点开胃小菜🍟:先来认识一下面向对象是什么

上面是比较官方的对二者区别的阐述,但是我相信大家现在都有一种"听君一席话,如听一席话"的感觉.
还是没有理解.没关系.我举一个实际的例子来帮助大家理解上述内容:
一个经典的示例:把大象装进冰箱中

在这里插入图片描述
OK,看完上述例子,相信各位聪明的小伙伴已经初步认识了什么是面向对象.😎

我们还要理解一下面向对象的两个要素:类和对象
很多小伙伴在学习java过程中对类和对象的理解不够,导致对后面的学习造成影响.所以我们需要先来关注一下类和对象:

👓理解类和对象

❓那么到底应该怎么理解这两个概念呢?

类的实例化

语法格式

// 创建类
class <class_name>{
	field;//成员属性
	method;//成员方法
}
// 实例化对象
<class_name> <对象名> = new <class_name>();

示例:

class Person {
    public int age;//属性
    public String name;
    public String sex;
    public void eat() {//方法
        System.out.println("吃饭!");
    }
    public void sleep() {
        System.out.println("睡觉!");
    }
}
public class 类和对象 {
    public static void main(String[] args) {
        Person person = new Person();//通过new实例化对象
        //产生多个对象
        Person person2 = new Person();
        Person person3 = new Person();
    }
}

在这里插入图片描述

class Person{}

像这样,其实就已经是一个person类了.但是这个类内部什么都没有,只是一个空壳,没有灵魂
我们要对他进行设计,从而让它有一定作用.

在这五类之中,最为基础,重要的就是:属性(Field 也叫做变量,也有叫字段或域的)， (成员)方法(Method).

🌟 1.属性(变量)

💙变量分类:

🌀局部变量

在这里插入图片描述

❄️声明格式

❄️特点

示例:

class Person {
    public String name;
     public void eat() {//方法
     	int a = 10;
     	int b;
        System.out.println("吃饭!");
    }
}

在这里插入图片描述

❄️小结

在这里插入图片描述

🌀成员变量

声明格式:

根据声明时有无"static"修饰,还可以分为:普通成员变量(不用static修饰)和静态成员变量

接下来会根据普通成员变量(也叫做实例变量)和静态成员变量(也叫做类变量)的相同点和不同点来介绍.

▶️相同点

示例:

class Person {
    private static String name;//静态成员变量
    public  int age;//普通成员变量
}
class Animal{
    public String a_name;
}
public class 类和对象 {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.age   //age是Person类中定义的,只能被Person类的对象调用
    }
}

在这里插入图片描述

▶️不同点

1️⃣.声明方式不同

2️⃣.调用方式不同

class Person {
    public static int age;//静态成员变量
    public String name;//普通成员变量   
}
public class 类和对象 {
    public static void main(String[] args) {
        Person person = new Person();//通过new实例化对象
        System.out.println(person.sex);//对象.实例变量
        System.out.println(person.age);//对象.类变量
        System.out.println(Person.age);//类.类变量
        System.out.println(Person.name);//不能直接类.实例变量
    }
}

在这里插入图片描述

3️⃣.生命周期不同

在这里插入图片描述

4️⃣.与对象关系不同

示例:

class Person {
    public static String name;//静态成员变量
    public  int age;//普通成员变量
    public String sex;
}
public class 类和对象 {
    public static void main(String[] args) {
        Person person1 = new Person();//通过new实例化对象
        person1.name = "张三";
        person1.age=10;
        System.out.println(person1.name);
        System.out.println(person1.age);
        System.out.println("=========================================");
        Person person2 = new Person();
        System.out.println(person2.name);
        System.out.println(person2.age);

    }
}

在这里插入图片描述

5️⃣.存储空间不同

💙匿名对象

💙关于对象数组

class Student{
	int number;//学号
	int state = 1;//年级
	int score;//成绩
}
public class 对象数组 {
    public static void main(String[] args) {
        Student[] stus = new Student[5];
		stus[0] = new Student();
        System.out.println(stus[0].state);//1
        System.out.println(stus[1]);//null
        System.out.println(stus[1].number);//报错,此时的stus[1]还未实例化对象,为null
        stus[1] = new Student();
		System.out.println(stus[1].number);//0
    }
}

⭐️成员变量和局部变量的区别

在这里插入图片描述

💙小结

在这里插入图片描述

🌟 2.方法

💙什么是方法

💙方法的声明格式

根据声明时有无"static"修饰,可以将方法分为普通成员方法(不用static修饰)和静态成员方法

💙方法的分类

	无返回值	有返回值
无形参	void 方法名（） {}	返回值的类型方法名（） {}
有形参	void 方法名（形参列表)	返回值的类型方法名（形参列表） {}

💙方法的调用

⭐️方法的重载

🌀重载的概念

🌀重载的特点

示例:

public class OverLoading {
    public void max(int a, int b) {
        // 含有两个int类型参数的方法
        System.out.println(a > b ? a : b);
    }

    public void max(double a, double b) {
        // 含有两个double类型参数的方法
        System.out.println(a > b ? a : b);
    }

    public void max(double a, double b, int c) {
        // 含有两个double类型参数和一个int类型参数的方法
        double max = (double) (a > b ? a : b);
        System.out.println(c > max ? c : max);
    }

    public static void main(String[] args) {
        OverLoading ol = new OverLoading();
        System.out.println("1 与 5 比较，较大的是：");
        ol.max(1, 5);
        System.out.println("5.205 与 5.8 比较，较大的是：");
        ol.max(5.205, 5.8);
        System.out.println("2.15、0.05、58 中，较大的是：");
        ol.max(2.15, 0.05, 58);
    }
}

在这里插入图片描述

💙可变形参的方法

//JDK 5.0以前： 采用数组形参来定义方法，传入多个同一类型变量
public static void test(int a ,String[] books);
//JDK5.0： 采用可变个数形参来定义方法，传入多个同一类型变量
public static void test(int a ,String…books);

class TestOverload{
    public void test(String[] msg){
        System.out.println("含字符串数组参数的test方法 ");
    }
    public void test1(String ... books){
        System.out.println("****形参长度可变的test1方法****");
    }
    public void test1(String book){
        System.out.println("****与可变形参方法构成重载的test1方法****");
    }
}

public class 可变个数形参的方法 {
    public static void main(String[] args){
        TestOverload to = new TestOverload();
        to.test(new String[]{"aa"});//将执行第一个test方法
        to.test1("aa" , "bb");//下面将执行第一个test1方法
        to.test1("a");//下面将执行第二个test1方法
        to.test1();//下面将执行第一个test1方法
    }
}

在这里插入图片描述

⭐️方法参数的值传递机制

⭐️方法的参数传递

public static void main(String[] args) {
	int x = 5;
	System.out.println("修改之前x = " + x);// 5
	change(x);// x是实参
	System.out.println("修改之后x = " + x);// 5
	}
public static void change(int x) {
	System.out.println("change:修改之前x = " + x);
	x = 3;
	System.out.println("change:修改之后x = " + x);
}

在这里插入图片描述

public static void main(String[] args) {
	Person obj = new Person();
	obj.age = 5;
	System.out.println("修改之前age = " + obj.age);// 5
	// x是实参
	change(obj);
	System.out.println("修改之后age = " + obj.age);// 3
}
public static void change(Person obj) {
	System.out.println("change:修改之前age = " + obj.age);
	obj.age = 3;
	System.out.println("change:修改之后age = " + obj.age);
}

class Person{
	int age;
}

在这里插入图片描述

public static void main(String[] args) {
	Person obj = new Person();
	obj.age = 5;
	System.out.println("修改之前age = " + obj.age);// 5
	// x是实参
	change(obj);
	System.out.println("修改之后age = " + obj.age);// 5
}
public static void change(Person obj) {
	obj = new Person();
	System.out.println("change:修改之前age = " + obj.age);
	obj.age = 3;
	System.out.println("change:修改之后age = " + obj.age);
}

class Person{
	int age;
}

在这里插入图片描述

💙方法的递归

1️⃣.方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执
行无须循环控制。
2️⃣递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死
循环

⭐️方法的重写

🌀定义:

💙小结

在这里插入图片描述

🌟 3.构造器

💙 语法格式：

⭐️ 构造器的特征

💙 构造器的作用

💙 构造器重载

public class Person { //构造器重载举例
	private String name;
	private int age;
	private Date birthDate;
	public Person(String n, int a, Date d) {
	name = n;
	age = a;
	birthDate = d;
}
public Person(String n, int a) {
	name = n;
	age = a;
}
public Person(String n, Date d) {
	name = n;
	birthDate = d;
}
public Person(String n) {
	name = n;
	age = 30;
	}
}

代码示例:

class Person {
	private String name;//实例成员变量
	private int age;
	private String sex;
	//默认构造函数 构造对象
	public Person() {
		this.name = "caocao";
		this.age = 10;
		this.sex = "男";
}
	//带有3个参数的构造函数
	public Person(String name,int age,String sex) {
		this.name = name;
		this.age = age;
		this.sex = sex;
	}
	public void show(){
		System.out.println("name: "+name+" age: "+age+" sex: "+sex);
	}
}
public class Main{
	public static void main(String[] args) {
		Person p1 = new Person();//调用不带参数的构造函数 如果程序没有提供会调用不带参数的构造函数
		p1.show();
		Person p2 = new Person("zhangfei",80,"男");//调用带有3个参数的构造函数
		p2.show();
	}
}

在这里插入图片描述

💙小结

在这里插入图片描述

⛽️属性赋值过程:

截止到目前，我们讲到了很多位置都可以对类的属性赋值。现总结这几个位置，并指明赋值的先后顺序。

🌟 4.代码块

前两种方式前面已经学习过了, 接下来我们介绍第三种方式, 使用代码块初始化

💙什么是代码块

💙 分类

🌀构造块

示例:

class Person{
	private String name;//实例成员变量
	private int age;
	private String sex;
	public Person() {
		System.out.println("I am Person init()!");
	}
	//实例代码块
	{
	this.name = "bit";
	this.age = 12;
	this.sex = "man";
	System.out.println("I am instance init()!");
	}
	public void show(){
			System.out.println("name: "+name+" age: "+age+" sex: "+sex);
	}
}
public class Main {
	public static void main(String[] args) {
	Person p1 = new Person();
	p1.show();
	}
}

在这里插入图片描述

🌀静态代码块

示例:

class Person{
    private String name;//实例成员变量
    private int age;
    private String sex;
    private static int count = 0;//静态成员变量 由类共享数据 方法区
    public Person(){
        System.out.println("I am Person init()!");
    }
        //实例代码块
    {
    this.name = "bit";
    this.age = 12;
    this.sex = "man";
    System.out.println("I am instance init()!");
    }
    //静态代码块
    static {
        count = 10;//只能访问静态数据成员
        System.out.println("I am static init()!");
    }
    public void show(){
        System.out.println("name: "+name+" age: "+age+" sex: "+sex);
    }
}
public class 类和对象 {
    public static void main(String[] args) {
        Person p1 = new Person();
        Person p2 = new Person();//静态代码块是否还会被执行？
    }
}

在这里插入图片描述

🌀非静态代码块

public class 类和对象 {
    public static void main(String[] args) {
        { //直接使用{}定义，普通方法块
            int x = 10 ;
            System.out.println("x1 = " +x);
        }
        int x = 100 ;
        System.out.println("x2 = " +x);
    }
}

在这里插入图片描述

💙小结

在这里插入图片描述

🌟 5.内部类

💙什么是内部类

💙内部类分类

🌀成员内部类

❄️作为类的成员的角色

示例:

class Outer {
	private int s;
	public class Inner {
		public void mb() {
			s = 100;
			System.out.println("在内部类Inner中s=" + s);
		}
	}
	public void ma() {
		Inner i = new Inner();
		i.mb();
	}
}
public class InnerTest {
	public static void main(String args[]) {
		Outer o = new Outer();
		o.ma();
	}
}

在这里插入图片描述

❄️作为类的角色

示例:

public class Outer {
	private int s = 111;
	public class Inner {
		private int s = 222;
		public void mb(int s) {
			System.out.println(s); // 局部变量s
			System.out.println(this.s); // 内部类对象的属性s
			System.out.println(Outer.this.s); // 外部类对象属性s
	}
}
public static void main(String args[]) {
		Outer a = new Outer();
		Outer.Inner b = a.new Inner();
		b.mb(333);
	}
}

在这里插入图片描述

❗️注意

🌀局部内部类

❄️声明局部内部类

class 外部类{
		方法(){
		class 局部内部类{
		}
	} 
	{
		class 局部内部类{
		}
	}
}

❄️使用局部内部类

❄️局部内部类的特点

🌀匿名内部类

❄️声明匿名内部类

new 父类构造器（实参列表） |实现接口(){
	//匿名内部类的类体部分
}

❄️匿名内部类的特点

💙小结

在这里插入图片描述

本篇主要介绍类和类的成员,其中有部分会涉及到后面的继承,关键字等的知识,会在后续更新的博客中具体讲解,还请大家继续关注.
如果本篇文章中有错误的地方还请在评论区指出,感谢感谢

在这里插入图片描述

听说你还不懂面向对象?--史上最硬核,面向对象从入门到精通(一)

💛前言:

面向对象--类和类的成员

👓认识面向对象

👓理解类和对象

类的实例化

🌟 1.属性(变量)

💙变量分类:

🌀局部变量

❄️声明格式

❄️特点

❄️小结

🌀成员变量

▶️相同点

▶️不同点

💙匿名对象

💙关于对象数组

⭐️成员变量和局部变量的区别

💙小结

🌟 2.方法

💙什么是方法

💙方法的声明格式

💙方法的分类

💙方法的调用

⭐️方法的重载

🌀重载的概念

🌀重载的特点

💙可变形参的方法

⭐️方法参数的值传递机制

⭐️方法的参数传递

💙方法的递归

⭐️方法的重写

💙小结

🌟 3.构造器

💙 语法格式：

⭐️ 构造器的特征

💙 构造器的作用

💙 构造器重载

💙小结

⛽️属性赋值过程:

🌟 4.代码块

💙什么是代码块

💙 分类

🌀构造块

🌀静态代码块

🌀非静态代码块

💙小结

🌟 5.内部类

💙什么是内部类

💙内部类分类

🌀成员内部类

❄️作为类的成员的角色

❄️作为类的角色

❗️注意

🌀局部内部类

❄️声明局部内部类

❄️使用局部内部类

❄️局部内部类的特点

🌀匿名内部类

❄️声明匿名内部类

❄️匿名内部类的特点

💙小结