Java中的类和对象_1
一 、类是什么？
1.类--类型--数据类型---复合数据类型---自定义复合数据类型
为什么有复合数据类型？
答：基本数据类型就8种，在开发中远远不够，所以我们就需要一个可以根据自己的需求随时能制作出一个自己需要的数据类型。
复合数据类型的本质---【根据自己的需求制作自己需要的数据类型的模式/规则/公式】
2.类--具有共同性质的一组事物的群体。 人类 [物以类聚人以群分]
所以综上所述：在java中用来描述具有共同性质的一组事物的自定义复合数据类型---类。
二 、如何编写一个Java类？
通过class关键字来创建一个类
例如:
public class HelloWorld{
}public---访问限制修饰符【对类的访问权限】（public---公用的/公开的）
class---创建类的关键字【类的标志】
HelloWorld--类名【首字母大写】
{}----类体
格式:
访问限制修饰符 class 类名{}
例如：
//1
public class Student{ }
//2
class User{ } //不写访问限制修饰符不等于没有---缺省访问控制修饰符三、Java类体中可以编写什么？
描述一组事物的共同性质
杯子--名字
形状
大小
颜色
装东西
名字，形状，大小，颜色-----基本属性
装东西---基本功能
事物的基本属性和基本功能来描述具有共同性质的一组事物。
基本属性------变量
基本功能-----方法
变量--是用来在类中描述事物的基本属性
方法--是用来在类中描述事物的基本功能
四 、Java类中变量的分类及其基本特征？
变量---保存数据
1.数据类型【不一定就是之前的基本数据类型，也有可能是自定义的复合数据类型】
2.变量名称【合法标识符--全字母小写】
3.初始值
4.作用域
按照在类中编写变量的位置划分可分为：
1.成员变量【全局变量】---类中方法外
(1.)可以使用访问限制修饰符,也可以不使用。
(2.)可以不用赋予初始值，系统自动赋予默认值，也可以根据需要自己设置一个初始值。
(3.)可以在本类中的任意一个方法中被使用
例如:
//格式:访问限制修饰符 class 类名{}
public class Test1{
//类---描述具有共同性质的一组事物的群体的复合数据类型
//描述具有共同性质的一组事物需要从两方面
//描述具有共同性质的一组事物的基本属性---变量
//描述具有共同性质的一组事物的基本功能---方法
//类中的变量：
//成员变量【全局变量】--- 类中方法外
//1.可以使用访问限制修饰符,也可以不使用。
//2.可以不用赋予初始值，系统自动赋予默认值，也可以根据需要自己设置一个初始值。
//3.可以在本类中的任意一个方法中被使用
public String name="张三";
int age;
//方法1中使用成员变量【全局变量】
public void method1(){
System.out.println("name=="+name);
System.out.println("age=="+age);
}
//方法2中使用成员变量【全局变量】
public void method2(){
System.out.println("name=="+name);
System.out.println("age=="+age);
}
}测试类:
public class TestMain{
public static void main(String args[]){
//测试Test1类中方法中访问成员变量
Test1 t1=new Test1();
//调用Test1类中method1()
t1.method1();
t1.method2();
}
}
2.局部变量-----------------------方法里/方法参数
(1.)不能使用访问限制修饰符。
(2.)必须设置初始值
(3.)只能在本方法中使用。
例如:
//格式:访问限制修饰符 class 类名{}
public class Test2{
//类---描述具有共同性质的一组事物的群体的复合数据类型
//描述具有共同性质的一组事物需要从两方面
//描述具有共同性质的一组事物的基本属性---变量
//描述具有共同性质的一组事物的基本功能---方法
//类中的变量：
//局部变量----类中方法里/方法的参数
//1.不能使用访问限制修饰符。
//2.必须设置初始值
//3.只能在本方法中使用。
//方法1
public void method1(){
//1.不能使用访问限制修饰符。
//public String name="zhangsan";
String name="zhangsan";
//2.必须设置初始值
//int age;
int age=0;
System.out.println("在本方法中访问定义在方法中的局部变量");
//3.只能在本方法中使用
System.out.println("name=="+name);
System.out.println("age=="+age);
}
//方法2
public void method2(){
System.out.println("在method1方法外的其他方法中访问定义在method1的局部变量");
//3.只能在本方法中使用
//System.out.println("name=="+name);
//System.out.println("age=="+age);
}
//方法的参数也是局部变量
public void method3(String name3,int age3){
System.out.println("方法的参数也是局部变量");
System.out.println("name3=="+name3);
System.out.println("age3=="+age3);
}
//方法的参数也是局部变量
//3.局部变量只能在本方法中使用
public void method4(){
//System.out.println("name3=="+name3);
//System.out.println("age3=="+age3);
}
}测试类:
public class TestMain2{
public static void main(String args[]){
//测试Test2类中方法中访问局部变量
Test2 t2=new Test2();
//调用Test2类中method1()
t2.method1();
//调用Test2类中method3()
t2.method3("lisi",24);
}
}
3.什么是成员变量的隐藏？
成员变量与某一个方法中的局部变量的名称相同，这是我们在方法中使用这个成员变量的时候，得到的结果是局部变量的值，此时就是方法中的局部变量将类中成员变量的值隐藏了，这就是成员变量的隐藏。
如果需要访问被隐藏的成员变量的值，怎么办？
通过this.成员变量的名称来调用变量
例如：
//成员变量的隐藏
//成员变量的名称与局部变量的名称相同
//局部变量的值会把成员变量的值隐藏
//注意:成员变量的隐藏与变量是什么数据类型没有关系，只看名称
public class Test3{
//定义成员变量
public String name="张三";
public void method1(){
//定义局部变量
char name='B';
//成员变量的名称与局部变量的名称相同
//局部变量的值会把成员变量的值隐藏
System.out.println("name=="+name);//B
//如果需要访问被隐藏的成员变量的值，怎么办？
//通过this.成员变量的名称
System.out.println("this.name=="+this.name);//张三
}
}测试类:
public class TestMain3{
public static void main(String args[]){
//测试Test3类中的成员变量的隐藏
Test3 t3=new Test3();
t3.method1();
}
}
4.静态成员变量与实例变量的区别？
(1.)静态成员变量与实例变量----都是成员变量【全局变量】
都有成员变量的属性：
1.可以使用访问限制修饰符,也可以不使用。
2.可以不用赋予初始值，系统自动赋予默认值，也可以根据需要自己设置一个初始值。
3.可以在本类中的任意一个方法中被使用
(2.)成员变量【全局变量】可以分为2种:
按照成员变量【全局变量】是否使用static关键字
1.静态成员变量【类变量】---使用static关键字修饰的成员变量【全局变量】
2.实例变量---没有使用static关键字修饰的成员变量【全局变量】
static关键字---静态的---》提前分配存储数据的内存空间
程序运行时分配存储数据的内存空间。
程序运行前分配存储数据的内存空间。
例如：
//成员变量【全局变量】分类
//根据成员变量【全局变量】是否使用static关键字修饰
//1.使用static关键字修饰的成员变量【全局变量】---静态成员变量【类变量】
//2.没有使用static关键字修饰的成员变量【全局变量】---实例变量【普通的成员变量【全局变量】】
//只对成员变量【全局变量】与局部变量没有关系
//静态成员变量【类变量】与实例变量【普通的成员变量【全局变量】】都是成员变量【全局变量】
//所以静态成员变量【类变量】与实例变量都要符合成员变量【全局变量】的特征。
//1.可以使用访问限制修饰符,也可以不使用。
//2.可以不用赋予初始值，系统自动赋予默认值，也可以根据需要自己设置一个初始值。
//3.可以在本类中的任意一个方法中被使用
//静态成员变量【类变量】与实例变量的区别???
public class Test4{
//实例变量--没有使用static--程序运行时---晚
public String name="zhangsan";
//静态成员变量【类变量】--使用static---程序运行前---早
public static String address1="西安1"; //静态成员变量【类变量】
static String address2="西安1"; //静态成员变量【类变量】
static int age; //静态成员变量【类变量】
//方法1
public void method1(){
System.out.println("访问实例变量--name=="+name);
System.out.println("访问静态成员变量【类变量】--address1=="+address1);
System.out.println("访问静态成员变量【类变量】--address2=="+address2);
System.out.println("访问静态成员变量【类变量】-age=="+age);
}
//方法2
public void method2(){
System.out.println("访问实例变量--name=="+name);
System.out.println("访问静态成员变量【类变量】--address1=="+address1);
System.out.println("访问静态成员变量【类变量】--address2=="+address2);
System.out.println("访问静态成员变量【类变量】-age=="+age);
}
}测试类:
public class TestMain4{
public static void main(String args[]){
//测试Test4类中的静态成员变量
Test4 t4=new Test4();
//t4.method1();
t4.method2();
}
}
区别:
静态成员变量【类变量】 | 实例变量 |
成员变量【全局变量】 1.可以使用访问限制修饰符,也可以不使用。 2.可以不用赋予初始值，系统自动赋予默认值，也可以根据需要自己设置一个初始值。 3.可以在本类中的任意一个方法中被使用 | |
有static 关键字修饰 | 没有static 关键字修饰 |
程序运行前分配数据的内存空间【早】 | 程序运行时分配数据的内存空间【晚】 |
可以在多个同类对象之间共享数据值 | 不能在多个同类对象之间共享数据值 |
可以使用对象访问也可以使用类名访问 | 只能使用对象访问 |
例如：
public class Test5{
//静态成员变量【类变量】
public static String name="zhangsan";
//实例变量
public String address="西安";
}测试类:
public class TestMain5{
public static void main(String args[]){
//静态成员变量【类变量】可以在多个同类对象之间共享数据值
Test5 t5_1=new Test5(); //第一个对象
Test5 t5_2=new Test5(); //第二个对象
System.out.println("t5_1.name=="+t5_1.name);//zhangsan
System.out.println("t5_2.name=="+t5_2.name);//zhangsan
t5_1.name="lisi"; //通过第一个对象修改name静态成员变量【类变量】的值
System.out.println("t5_1.name=="+t5_1.name);//lisi
System.out.println("t5_2.name=="+t5_2.name);//lisi
//静态成员变量【类变量】是多个同类对象的公共变量。
//实例变量不可以在多个同类对象之间共享数据值
Test5 t5_11=new Test5(); //第一个对象
Test5 t5_22=new Test5(); //第二个对象
System.out.println("t5_11.address=="+t5_11.address);//西安
System.out.println("t5_22.address=="+t5_22.address);//西安
t5_11.address="北京"; //通过第一个对象修改address实例变量的值
System.out.println("t5_11.address=="+t5_11.address); //北京
System.out.println("t5_22.address=="+t5_22.address); //西安
//静态成员变量【类变量】可以使用对象访问也可以使用类名访问
Test5 t5_3=new Test5(); //第一个对象
System.out.println("t5_3.name=="+t5_1.name);//zhangsan
System.out.println("Test5.name=="+Test5.name);//zhangsan
//实例变量只能使用对象访问
Test5 t5_33=new Test5(); //第一个对象
System.out.println("t5_33.address=="+t5_33.address); //西安
//System.out.println("Test5.address=="+Test5.address);//错误
}
}
总结：
1.静态变量是所有对象共有的，某一个对象将它的值改变了，其他对象再去获取它的值，得到的是改变后的值；
2.实例变量则是每一个对象私有的，某一个对象将它的值改变了，不影响其他对象取值的结果，其他对象仍会得到实例变量一开始就被赋予的值。
3.在创建实例对象的时候，内存中会为每一个实例对象的每一个非静态成员变量开辟一段内存空间，用来存储这个对象所有的非静态成员变量值。即使两个不同的实例对象是属于同一个类，它们的同名非静态成员变量在内存中占用的空间是不同的。
4.静态成员变量有所不同。所有的实例对象都共用一个静态变量，内存中只有同一处空间存放这个静态变量值的。因此，如果一个对象把静态变量值改了，另外一个对象再取静态变量值就是改过之后的值了。
类中的变量结构图：
