| 📜个人简介 |
⭐️个人主页：摸鱼の文酱博客主页🙋♂️
🍑博客领域：java编程基础,mysql
🍅写作风格：干货,干货,还是tmd的干货
🌸精选专栏：【Java】【mysql】 【算法刷题笔记】
🎯博主的码云gitee，平常博主写的程序代码都在里面。
🚀支持博主：点赞👍、收藏⭐、留言💬
🍭作者水平很有限，如果发现错误，一定要及时告知作者哦！感谢感谢！
💛前言:
(文章目录带⭐️为需要重点掌握的)
准备好了吗? 我们要开始了!
面向对象--类和类的成员
)
👓认识面向对象
首先,上正菜🍔 前,先让我们来点开胃小菜🍟:先来认识一下面向对象是什么
上面是比较官方的对二者区别的阐述,但是我相信大家现在都有一种"听君一席话,如听一席话"的感觉.
还是没有理解.没关系.我举一个实际的例子来帮助大家理解上述内容:
一个经典的示例:把大象装进冰箱中
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 父类构造器（实参列表） |实现接口(){
//匿名内部类的类体部分
}
❄️匿名内部类的特点
💙小结
本篇主要介绍类和类的成员,其中有部分会涉及到后面的继承,关键字等的知识,会在后续更新的博客中具体讲解,还请大家继续关注.
如果本篇文章中有错误的地方还请在评论区指出,感谢感谢
