本文详细介绍了Java中的类，包括类的定义、成员变量（全局变量）、局部变量、静态成员变量与实例变量的区别。同时阐述了如何编写Java类、方法的类型（实例方法、静态方法、构造方法）以及方法重载的概念。此外，还探讨了对象的创建、作用及对象如何访问类中的元素。最后，总结了静态成员变量与实例变量的内存分配和访问特点。
活动地址：CSDN21天学习挑战赛
Java类
一、关于类是什么
1.类 —> 类型 —> 数据类型 —> 复合数据类型 —> 自定义复合数据类型
为什么有复合数据类型？
基本数据类型就8种，在开发中远远不够，所以我们就需要一个可以根据自己
的需求随时能制作出一个自己需要的数据类型。
2.类 —> 具有共同性质的一组事物的群体。 人类
在java中用来描述具有共同性质的一组事物的自定义的复合数据类型 —> 类。
复合数据类型的本质 —> 【根据自己的需求制作自己需要的数据类型的模式/规则/公式】
二、如何编写一个Java类
通过class关键字来创建一个类
例如:
public class Hello{
}
public — 访问限制修饰符【对类的访问权限】
class — 创建类的关键字【类的标志】
Hello — 类名【首字母大写】
{} — 类体
格式:
访问限制修饰符 class 类名{}
例如：
public class Student{ }
class User{ }
三、Java类中可以编写什么
描述一组事物的共同性质
例如：
杯子共同性质—>名字、形状、大小、颜色、装东西
名字，形状，大小，颜色-----是杯子的基本属性
装东西 —> 是杯子的基本功能
通过事物的基本属性和基本功能来描述具有共同性质的一组事物。
基本属性 — 变量
基本功能 — 方法
变量 — 是用来在类中描述事物的基本属性
方法 — 是用来在类中描述事物的基本功能
四、Java类中变量的分类及其基本特征
变量—保存数据
1. 数据类型【不一定就是之前的基本数据类型，也有可能是自定义的复合数据类型】
2. 变量名称【合法标识符–全字母小写】
3. 初始值
4. 作用域
按照在类中编写变量的位置划分：
1. 成员变量【全局变量】—> 类中方法外
(1) 可以使用访问限制修饰符,也可以不使用。
(2)可以不用赋予初始值，系统自动赋予默认值，也可以根据需要自己设置一个初始值。
(3)可以在本类中的任意一个方法中被使用
2. 局部变量-----------------------方法里/方法参数
(1)不能使用访问限制修饰符。
(2)必须设置初始值
(3)只能在本方法中使用。
例如:
public class Student{
public int stuid1; //可以使用访问限制修饰符
int stuid2; //也可以不使用限制修饰符[缺省的访问限制修饰符]
public String stuname1; //可以不用赋予初始值，系统自动赋予默认值
public String stuname2="zhangsan";//也可以根据需要自己设置一个初始值。
//成员变量【全局变量】---可以在本类中的任意一个方法中被使用
public void testMethod1(){
System.out.println("stuid1=="+stuid1);
System.out.println("stuname2=="+stuname2);
}
public void testMethod2(){
System.out.println("stuid1=="+stuid1);
System.out.println("stuname2=="+stuname2);
}
//......
public void testMethod_n(){
System.out.println("stuid1=="+stuid1);
System.out.println("stuname2=="+stuname2);
}
}
public class Person{
//方法1--testMethod1
public void testMethod1(){
//public char sex; //不能使用访问限制修饰符。
//char sex; //必须设置初始值
char sex=’男’; //局部变量
//只能在本方法中使用
System.out.println(“sex==”+sex);
}
//方法2--testMethod2
public void testMethod2(){
//只能在本方法中使用,超出本方法就不能使用
//System.out.println(“sex==”+sex);
}
}
五、什么是成员变量的隐藏
在同一个类中成员变量与某一个方法中的局部变量的名称相同，当我们在方法中使用这个成员变量的时候，得到的结果是局部变量的值，此时就是方法中的局部变量将类中成员变量的值隐藏了，这就是成员变量的隐藏。
例如：
public class User{
//成员变量
public String username=”zhangsan”;
public void testMethod1(){
//局部变量
char username=’A’;
//成员变量的隐藏
//成员变量的隐藏与变量数据类型无关，只与变量名称有关。
System.out.println(“username==”+username); //username==A
//如果我们需要强制使用被隐藏的成员变量，该怎么办？
//通过this访问被隐藏的成员变量
System.out.println(“username==”+this.username); //username==zhangsan
}
}
六、静态成员变量与实例变量的区别
静态成员变量与实例变量 —> 都是成员变量【全局变量】
1.可以使用访问限制修饰符,也可以不使用。
2.可以不用赋予初始值，系统自动赋予默认值，也可以根据需要自己设置一个初始值。
3.可以在本类中的任意一个方法中被使用
成员变量【全局变量】可以分为2种
按照成员变量【全局变量】是否使用static关键字
静态成员变量【类变量】—> 使用static关键字修饰的成员变量【全局变量】
实例变量 —> 没有使用static关键字修饰的成员变量【全局变量】
static关键字 —> 静态的 —> 提前分配存储数据的内存空间
没有使用static关键字修饰的元素，是在程序运行时分配存储数据的内存空间。
使用static关键字修饰的元素，是在程序运行前分配存储数据的内存空间。
例如：
public class TestClass{
public int classid=1001; //实例变量
public static String classname=”java班”; //静态成员变量【类变量】
static String classcode=”20200728”;//静态成员变量【类变量】
}
区别:
| 静态成员变量【类变量】 | 实例变量 |
|---|---|
| 有static 关键字修饰 | 没有static 关键字修饰 |
| 程序运行前分配数据的内存空间【早】 | 程序运行时分配数据的内存空间【晚】 |
| 可以在多个同类对象之间共享数据值 | 不能在多个同类对象之间共享数据值 |
| 共同点： | |
| 都是成员变量【全局变量】 |
总结
Java类中的方法
一、Java类中方法的表现形式及其基本特征
Java类中方法是为了描述具有共同性质的一组事物的基本功能/行为。
Java类中方法的表现形式
1. 实例方法
实例方法格式：
访问限制修饰符 方法的返回值数据类型 方法的名称（参数列表）{方法体}
1. 访问限制修饰符 —> public / 缺省的
2. 方法的返回值数据类型
返回值 —> 方法执行结果
数据类型 —> 基本数据类型【复合数据类型】
有返回值 —> 方法体中的最后一句话是“return”,方法的返回值数据类型一定是结果值的具体数据类型
没有返回值 —> 方法体中的没有“return”,方法的返回值数据类型void代替。
3. 方法的名称 —> 合法的标识符【首字母小写，从第二个单词开始首字母大写】
4. 参数列表
参数 —> 引入本方法以外的数据进入本方法进行运算【找帮手】局部变量
列表 —> 可以有多个
没有参数的时候 —>（）中的内容是空的
5. 方法体 —> 方法的身体【具体执行代码】
例如：
public void test1(){ } --- 没有返回值，没有参数的实例方法
public int test2(){ return 12;}---返回值为int,没有参数的实例方法
public void test3(int a){ } ---- 没有返回值,有参数1个int型参数的实例方法
public String test4(UserBean user){ return “hello”;}---返回值为String的，有一个UserBean参数的实例方法。
public Student test5(UserBean user,int num,char value){ return null;}
2. 静态方法
实例方法的访问限制修饰符后面加上static关键字的方法就是静态方法【类方法】
没有static关键字的方法就是实例方法
静态方法格式：
访问限制修饰符 static 方法的返回值数据类型 方法的名称（参数列表）{方法体}
例如：
public static void test1(){ } --- 没有返回值，没有参数的静态方法【类方法】
public static int test2(){ return 12;}---返回值为int,没有参数的静态方法【类方法】
public static void test3(int a){ } ---- 没有返回值,有参数1个int型参数的静态方法【类方法】
public static String test4(UserBean user){ return “hello”;}---返回值为String的，有一个UserBean参数的静态方法【类方法】。
public static Student test5(UserBean user,int num,char value){ return null;}
3. 构造方法
实例方法格式中去掉方法的返回值数据类型，方法的名称是类名这种方法就叫构造方法。
构造方法格式：
访问限制修饰符 类名（参数列表）{方法体}
例如：
public class Person{
public Person(){ } --- 无参数的构造方法
public Person(int num){ } --- 有一个int型参数的构造方法
public Person(UserBean user){ } ---有一个UserBean 型参数的构造方法
public Person(UserBean user,int num,char value){}
}
构造方法作用就是将来为了创建对象用的。
当一个类创建好以后，会有一个默认的无参数构造方法存在，只是没有显式写出罢了。
当这个类中出现一个有参数的构造方法时，我们就需要将这个默认的无参数构造方法
显式写出,如果没有显式写出这个默认的无参数构造方法，那么这个默认的无参数构造方法将会被有参数的构造方法覆盖。
public class Student{
//存在一个默认的无参数构造方法
public Student(){}
public Student(String name){}
}
二、方法重载
在同一个类中方法的名称相同，参数不一样，这种现象就叫方法重载。
注意：方法重载与方法的返回值类型没有关系
例如：
public class UserBean{
public void test1(){}
public int test1(int num){return 0;}
}
参数不一样—先看个数，后看类型
例如：
public class UserBean{
public void test1(int num){}
public int test1(int num1 ,double num2){return 0;} // int double
public int test1(double num2,int num1 ){return 0;} // double int
}
构造方法、实例方法、静态方法都是可以重载的
三、同一个Java类中方法与变量的调用关系
在用一个类中：
构造方法中可以访问实例变量/类变量/局部变量
构造方法中访问实例变量默认this.实例变量,this可以被省略。
构造方法中访问类变量默认类名.实例变量,也可以this.类变量,类名/this可以被省略
构造方法中访问局部变量直接变量名称
实例方法中可以访问实例变量/类变量/局部变量
实例方法中访问实例变量默认this.实例变量,this可以被省略。
实例方法中访问类变量默认类名.实例变量,也可以this.类变量,类名/this可以被省略
实例方法中访问局部变量直接变量名称
静态方法中可以访问类变量/局部变量，不可以访问实例变量
静态方法中访问类变量默认类名.类变量,类名可以被省略
静态方法中不能有this
静态方法中访问局部变量直接变量名称
为什么静态方法中不可以访问实例变量变量？
静态方法内存分配时机早于实例变量的内存分配时机，静态方法访问实例变量的时候，实例变量是不存在。
public class Person{
public int perid=1001;//实例变量
public static String pername="zhangsan";//类变量
//构造方法中可以访问实例变量/类变量/局部变量
public Person(){
char sex='男';//局部变量
//构造方法中访问实例变量默认this.实例变量，this.可以被省略
System.out.println("构造方法中访问实例变量有this.===="+this.perid);
System.out.println("构造方法中访问实例变量没有this.===="+perid);
//构造方法中访问类变量默认类名.实例变量,也可以this.类变量,类名./this.可以被省略
System.out.println("构造方法中访问类变量有this.===="+this.pername);
System.out.println("构造方法中访问类变量有类名.===="+Person.pername);
System.out.println("构造方法中访问类变量没有类名./this.===="+pername);
//构造方法中访问局部变量直接变量名称
System.out.println("构造方法中访问局部变量===="+sex);
}
//实例方法中可以访问实例变量/类变量/局部变量
public void testMehodl(){
char sex='男';//局部变量
//实例方法中访问实例变量默认this.实例变量,this可以被省略。
System.out.println("实例方法中访问实例变量有this.===="+this.perid);
System.out.println("实例方法中访问实例变量没有this.===="+perid);
//实例方法中访问类变量默认类名.实例变量,也可以this.类变量,类名/this可以被省略
System.out.println("实例方法中访问类变量有this.===="+this.pername);
System.out.println("实例方法中访问类变量有类名.===="+Person.pername);
System.out.println("实例方法中访问类变量没有类名./this.===="+pername);
//实例方法中访问局部变量直接变量名称
System.out.println("实例方法中访问局部变量===="+sex);
}
//静态方法中不可以访问实例变量变量
//静态方法中不能有this.
//静态方法中可以访问类变量/局部变量
public static void testStaticMehtod(){
char sex='男';//局部变量
//System.out.println("静态方法中访问实例变量有this.===="+this.perid);
//System.out.println("静态方法中访问实例变量没有this.===="+perid);
//静态方法中访问类变量默认类名.实例变量,类名可以被省略
//System.out.println("静态方法中访问实例变量有this.===="+this.perid);
System.out.println("静态方法中访问类变量有类名.===="+Person.pername);
System.out.println("静态方法中访问类变量没有类名.===="+pername);
//静态方法中访问局部变量直接变量名称
System.out.println("静态方法中访问局部变量===="+sex);
}
}
public class TeseMain{
public static void main(String args[]){
Person per1=new Person();
per1.testMehodl();
per1.testStaticMehtod();
}
}
运行结果
四、同一个Java类中方法与方法的调用关系
在用一个类中：
构造方法中可以访问其他的构造方法/实例方法/类方法
构造方法中访问其他的构造方法new 其他的构造方法;
构造方法中访问实例方法默认this.实例方法,this可以被省略
构造方法中访问类方法默认类名.类方法,也可以this.类方法，类名/this可以省略
实例方法中可以访问构造方法/其他实例方法/类方法
实例方法中访问构造方法默认new 构造方法
实例方法中访问其他实例方法默认this.其他实例方法,this可以被省略
实例方法中访问类方法默认类名.类方法,也可以this.类方法，类名/this可以省略
静态方法中可以访问构造方法/其他的静态方法，不可以访问实例方法
静态方法中访问构造方法new 构造方法
静态方法中不能有this
静态方法中访问类方法默认类名.类方法,类名可以省略
public class Person{
public Person(){
System.out.println("构造方法");
}
public void student(){
System.out.println("实例方法");
}
public static void stuSta(){
System.out.println("静态方法");
}
//构造方法中可以访问其他的构造方法/实例方法/类方法
public Person(int ag){
new Person();
this.student();
student();
Person.stuSta();
this.stuSta();
stuSta();
}
//实例方法中可以访问构造方法/其他实例方法/类方法
public void stuStatic(){
new Person();
this.student();
student();
Person.stuSta();
this.stuSta();
stuSta();
}
//静态方法中可以访问构造方法/其他的静态方法，不可以访问实例方法
public static void stuStal(){
new Person();
//student();//不可以访问实例方法
//this.stuSta();//静态方法中不能有this
Person.stuSta();
stuSta();
}
}
public class DiaoYong{
public static void main(String args[]){
Person per1=new Person(4);
per1.stuStatic();
per1.stuStal();
}
}
运行结果：
总结
Java类中的对象
一、什么是对象
1.对象是由我们自己创建的类来创建出来的。
2.对象就是类的实例【可以真正使用类的数据，可以调用类中元素的数据】
例如：修建大楼是绘制的设计图纸就是类，根据设计图纸修建起来的真实的可以住人的大楼就是对象。
3.一个类可以创建出多个对象
二、如何创建对象
1.保证用来创建对象的类是存在
2.需要通过类中提供的构造方法创建对象
格式 ： new 构造方法( [参数值] );
例如：
public class Person{
public Person(){
System.out.println("Person类无参数构造方法");
}
public Person(String value){
System.out.println("Person类有参数构造方法，参数是--value=="+value);
}
}
public class Test1{
public static void main(String args[]){
//创建Person类的对象
//格式: new 构造方法([参数值])
//new Person();//Person类的对象
//new Person("javase");
//为了以后方便使用对象，我们就把这个对象保存在变量
Person per1=new Person();
}
}
三、创建好的对象的有何作用
创建好的对象可以访问/调用类中的元素【变量/方法】，至于创建好的对象可以访问/调用类中的那些元素，那些元素不能访问/调用，就得看类中元素的访问限制修饰符。
四、对象的具体用法
变量的访问
1. 实例变量 —>【对象.实例变量】
2. 静态成员变量 —>【对象.静态成员变量/类名.静态成员变量】
以上的访问是在public修饰符的作用下操作的。
例如:
public class Student{
//实例变量
public int stuid=1001;
public int stuage;
//静态成员变量
public static String stuname="zhangsan";
public static String stuaddress;
}
public class Test2{
public static void main(String args[]){
//访问实例变量---【对象.实例变量】
//创建Student类的对象
Student stu1=new Student();
System.out.println("stuid=="+stu1.stuid);
//赋值
stu1.stuage=23;
System.out.println("stuage=="+stu1.stuage);
//访问类变量--【对象.类变量/类名.类变量】
Student stu2=new Student();
System.out.println("stuname=="+stu2.stuname);
System.out.println("stuname=="+Student.stuname);
//stu2.stuaddress="西安";
//System.out.println("stuaddress=="+stu2.stuaddress);
//System.out.println("stuaddress=="+Student.stuaddress);
Student.stuaddress="北京";
System.out.println("stuaddress=="+stu2.stuaddress);
System.out.println("stuaddress=="+Student.stuaddress);
}
}
方法的访问
1. 构造方法 —> new 构造方法();
2. 实例方法 —>【对象.实例方法】
3. 静态方法 —>【对象.静态方法/类名.静态方法】
例如:
public class Dog{
//实例方法
public void dogTest1(){
System.out.println("Dog类中的实例方法");
}
//类方法
public static void dogStatic(){
System.out.println("Dog类中的类方法");
}
}
public class Test3{
public static void main(String args[]){
//实例方法--【对象.实例方法】
Dog dog1=new Dog();
dog1.dogTest1();
//静态方法--【对象.静态方法/类名.静态方法】
Dog dog2=new Dog();
dog2.dogStatic();
Dog.dogStatic();
}
}
有参数的方法访问，需要注意的是参数的传递
例如：
public class Cat{
//实例方法
public void catTest1(int age,double height){
System.out.println("Cat类中的实例方法--参数1--age=="+age+",参数2--height=="+height);
}
//类方法
public static void catStatic(Dog dog){
System.out.println("Cat类中的类方法--参数--dog=="+dog);
}
}
public class Test4{
public static void main(String args[]){
//实例方法--【对象.实例方法】
Cat cat1=new Cat();
cat1.catTest1(5,12.5);
//类方法
Cat.catStatic(new Dog());
//上面的方法在调用的时候传递的参数是具体的数据值
//我们在访问的时候可以传递保存数据值的变量
int age=3;
double hei=6.7;
cat1.catTest1(age,hei);
Dog dog=new Dog();
cat1.catStatic(dog);
}
}
总结: 先看【有没有/有几个/什么类型】，再传【匹配类型/匹配个数/值【变量】】
有返回值的方法访问，需要注意的是接收方法的返回值结果【类型匹配】
例如：
public class Cat{
//实例方法
public int catTest2(int num1,double num2){
int res=0;
res=(int)(num1+num2);
return res;
}
//类方法
public static Student catStatic2(Dog dog){
//return new Student();
Student stu=new Student();
return stu;
}
}
public class Test4{
public static void main(String args[]){
//访问有返回值和参数的方法
Cat cat2=new Cat();
int val=cat2.catTest2(12,12.5);
System.out.println("catTest2的运行结果=="+val);
Student stu=Cat.catStatic2(new Dog());
System.out.println("catStatic2的运行结果=="+stu.stuid);
}
}
总结：方法的调用【1.要什么，传什么；2.给什么，收什么】
五、对象的内存分配原理
对象是通过类的构造方法创建
类是一种自定义的复合数据类型
六、类与对象的关系
类是创建对象的模板；对象是类的具体表现
七、静态成员变量【类变量】与实例变量的区别
共同点：都是成员变量【全局变量】
| 静态成员变量【类变量】 | 实例变量 |
|---|---|
| 有static 关键字修饰 | 没有static 关键字修饰 |
| 程序运行前分配数据的内存空间【早】 | 程序运行时分配数据的内存空间【晚】 |
| 可以在多个同类对象之间共享数据值 | 不能在多个同类对象之间共享数据值 |
| 可以使用对象访问,也可以类名访问 | 只能对象访问 |
| 例如： |
public class Pig{
public String pigname="佩奇";
}
public class Test5{
public static void main(String args[]){
Pig pig1=new Pig();
pig1.pigname="乔治";
System.out.println("pig1=="+pig1.pigname);
Pig pig2=new Pig();
System.out.println("pig2=="+pig2.pigname);
}
}
实例变量的数据值是不能再同类对象之间共享。
public class Pig{
public static String pigname="佩奇";
}
public class Test5{
public static void main(String args[]){
Pig pig1=new Pig();
pig1.pigname="乔治";
System.out.println("pig1=="+pig1.pigname);
Pig pig2=new Pig();
System.out.println("pig2=="+pig2.pigname);
}
}
类变量的数据值是能在同类对象之间共享。
总结
扫一扫
868
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
