java基础----类和对象
类和对象
1.类是什么？
类：生活中的类就是具有共同性质或者功能的一组事物集合。
类：java程序中的类就是【类型】--【数据类型】--【复合数据类型】---【自定义的复合数据类型】
类就是描述具有共同性质或者功能的一组事物的自定义的复合数据类型。
2.类是如何编写的？
格式：访问限制修饰符 class 类名{
}
例如：
public class Student{
}
(1) 访问限制修饰符---public 缺省的
public----[公共的] 所有包都可以访问
缺省的--[友好的] 同一个包中可以访问。
(2)class---创建类的关键字【类的标志】
(3)类名--合法的标识符【每一个的单词的首字母大写】
(4){}----类体
3.类中可以编写什么？
类中可以编写变量和方法
用变量来描述事物的基本特征【属性】，
用方法来描述事物的基本行为【功能】。
4.类中的变量的分类以及特征？成员变量的隐藏？静态成员变量与实例变量的区别？
类中的变量
变量书写在类体中。
变量--保存数据
数据类型【基本数据类型/复合数据类型】
变量名称【合法的修饰符，全字母小写】
初始值
作用域【有效范围】
(1)变量的分类:
成员变量【全局变量】---类中除过方法以外的地方【在类体，但没有在方法中】。
局部变量---类中的方法里面和方法的参数。
(2)成员变量【全局变量】的特征
类中除过方法以外的地方。
可以没有初始值，系统会自动赋予这个全局变量一个默认的初始值。
需要访问限制修饰符
可以在本类中的任何一个方法中被使用，且不受访问限制修饰符的影响。
(3)局部变量的特征
类中的方法里面和方法的参数。
局部变量一定要有初始值。
不能有访问限制修饰符
只能在定义该局部变量的方法中使用，超出本方法就错误
(4)成员变量的隐藏
类中的某一个成员变量的名称与某一个方法中的局部变量的名称相同，那么类中的成员变量的数据值被局部变量覆盖隐藏。
(5)静态成员变量与实例变量的区别？
静态变量也叫类变量，这种变量前加了static修饰符。可以直接用类名调用，也可以用对象调用，而且所有对象的同一个类变 量 都是共享同一块内存空间。
实例变量也叫对象变量，这种变量没有加static修饰符。只能通过对象调用， 而且所有对象的同一个实例变量是共享不同的内 存空间的。
区别在于：
静态变量是所有对象共有的，某一个对象将它的值改变了，其他对象再去获取它的值，得到的是改变后的值；
实例变量则是每一个对象私有的，某一个对象将它的值改变了，不影响其他对象取值的结果，其他对象仍会得到实例变量一 开始就被赋予的值。
5.类中的方法以及表现形式和特征？方法的重载？
(1)方法
用来描述具有共同性质的一组事物的基本行为。
普通方法【实例方法】基本格式：
访问限制修饰符 方法的返回值类型 方法的名称(方法参数列表){
需要实现的基本行为
}
静态方法【类方法】基本格式：
访问限制修饰符 static 方法的返回值类型 方法的名称(方法参数列表){
需要实现的基本行为
}
构造方法：
没有方法返回值类型部分
方法的名称与类名称相同
访问限制修饰符 类名称(方法参数列表){
需要实现的基本行为
}
(2)方法的重载
方法重载----在同一个类中，方法名称相同，参数不同这种现象就是方法重载。
参数不同： 有或无
数量不同
类型不同
注意：方法重载与方法的返回值类型，没有关系。
例如：
package com.click369.method1;
public class TestMethod4 {
//方法重载与方法的返回值类型，没有关系。
//构造方法重载
public TestMethod4(){}
public TestMethod4(String test){
}
public TestMethod4(String test,int num){
}
public TestMethod4(int num){
}
//实例方法重载
public void test1(){}
public int test1(String test){
return 100;
}
public int test1(int test){
return 100;
}
public void test1(int num1,int num2){}
//静态方法重载
public static void testStatic1(){}
public static int testStatic1(String test){
return 100;
}
public static int testStatic1(int test){
return 100;
}
public static void testStatic1(int num1,int num2){}
}
6.同一个类中方法与变量的调用关系？方法与方法的调用关系？
在同一个类中只能方法调用变量，不能变量调用方法
同一个类中方法调用变量：
例如：
package com.click369.test1;
public class TestClassDemo5 {
//实例变量
public int shilibianlang=1001;
//静态成员变量【类变量】
public static String staticbianliang="类变量";
//构造方法
public TestClassDemo5(){}
public TestClassDemo5(int num){
//1.构造方法可以调用实例变量，默认是this.实例变量，this.可以省略
System.out.println(this.shilibianlang);
System.out.println(shilibianlang);
//2.构造方法可以调用类变量，默认是类名.类变量，类名.可以省略，也可以是this.类变量，this.可以省略
System.out.println(TestClassDemo5.staticbianliang);
System.out.println(this.staticbianliang);
System.out.println(staticbianliang);
}
//实例方法
public void test1(){}
public int test2(int num){
//1.实例方法可以调用实例变量，默认是this.实例变量，this.可以省略
System.out.println(this.shilibianlang);
System.out.println(shilibianlang);
//2.实例方法可以调用类变量，默认是类名.类变量，类名.可以省略，也可以是this.类变量，this.可以省略
System.out.println(TestClassDemo5.staticbianliang);
System.out.println(this.staticbianliang);
System.out.println(staticbianliang);
return num;
}
//静态方法【类方法】
//静态方法【类方法】中你绝对不能出现this
public static void teststatic1(){}
public static int teststatic2(int num){
//1.类方法不可以调用实例变量
//System.out.println(this.shilibianlang);
//System.out.println(shilibianlang);
//2.类方法可以调用类变量，默认是类名.类变量，类名.可以省略
System.out.println(TestClassDemo5.staticbianliang);
//System.out.println(this.staticbianliang);
System.out.println(staticbianliang);
return num;
}
}
同一个类中方法调用方法
package com.click369.test1;
public class TestClassDemo6 {
//构造方法
public TestClassDemo6(){}
public TestClassDemo6(int num){
//构造方法可以调用其他的构造方法，new + 其他的构造方法;
new TestClassDemo6();
//构造方法可以调用实例方法，默认this.实例方法，this.可以省略
this.test1();
test1();
//构造方法可以调用类方法,默认类名.类方法，类名.可以省略，也可以是this.类方法，this.可以省略
TestClassDemo6.teststatic1();
this.teststatic1();
teststatic1();
}
//实例方法
public void test1(){}
public int test2(int num){
//实例方法可以调用其他的构造方法，new + 其他的构造方法;
new TestClassDemo6();
//实例方法可以调用其他实例方法，默认this.实例方法，this.可以省略
this.test1();
test1();
//实例方法可以调用类方法,默认类名.类方法，类名.可以省略，也可以是this.类方法，this.可以省略
TestClassDemo6.teststatic1();
this.teststatic1();
teststatic1();
return num;
}
//静态方法【类方法】
//静态方法【类方法】中你绝对不能出现this
public static void teststatic1(){}
public static int teststatic2(int num){
//类方法可以调用其他的构造方法，new + 其他的构造方法;
new TestClassDemo6();
//类方法不可以调用实例方法
//this.test1();
//test1();
//类方法可以调用类方法,默认类名.类方法，类名.可以省略
TestClassDemo6.teststatic1();
//this.teststatic1();
teststatic1();
return num;
}
}
总结：1.静态方法【类方法】中你绝对不能出现this
2.静态方法【类方法】中不能调用实例变量和实例方法
3.构造方法可以调用实例变量/实例方法，默认是this.实例变量/this.实例方法，this.可以省略。
4.构造方法可以调用类变量/类方法，默认是类名.类变量/类名.类方法，类名.可以省略，也可以是this.类变量/this.类方法，this.可以省略。
5.构造方法可以调用其他的构造方法，new + 其他的构造方法;
6.实例方法可以调用实例变量/实例方法，默认是this.实例变量/this.实例方法，this.可以省略。
7.实例方法可以调用类变量/类方法，默认是类名.类变量/类名.类方法，类名.可以省略，也可以是this.类变量/this.类方法，this.可以省略。
8.实例方法可以调用构造方法，new + 其他的构造方法;
9.类方法可以调用类变量/类方法，默认是类名.类变量/类名.类方法，类名.可以省略。
10.类方法可以调用构造方法，new + 其他的构造方法;
7.对象是什么？对象如何创建？创建好的对象的作用？
类是创建对象的模具/图纸
对象是通过类制作出来的实际的实体
没有类就没有对象
没有对象类就没有意义
创建对象:
对象就是通过类创建出来的实体
通过 new + 构造方法 创建的。
定义格式：类名 对象名称；
创建格式：对象名称=new 构造方法;
定义+创建格式: 类名 对象名称=new 构造方法;
例如：
public class Student{
}
//定义格式：类名 对象名称；
Student stu1; ====> int num1;
//创建格式：对象名称=new 构造方法;
stu1=new Student(); ===> num1=100;
//定义+创建格式: 类名 对象名称=new 构造方法;
Student stu2=new Student();=====>int num1=100;
对象的作用：
可以通过对象来调用定义在类中的变量【实例变量/类变量】，和方法【实例方法/类方法】，忽略访问限制修饰符的影响。
Java程序=对象+消息【类中的变量，方法】
其他类中实例变量/实例方法只能对象调用。
其他类中类变量/类方法，可以对象调用，也可以类名调用。
8.对象的内存分配原理？
对象是通过类创建的，而类是一种复合数据类型，那么对象的内存分配与复合数据类型的内存分配是一致。因此对象的内存分配会在内存的堆区和栈区都有分配。对象是通过类创建的，而类是一种复合数据类型，那么对象的内存分配与复合数据类型的内存分配是一致。因此对象的内存分配会在内存的堆区和栈区都有分配。
9.对象调用方法
以实例方法为例，解释对象调用方法的关系
没有参数，没有返回值
没有参数，有返回值
有参数，没有返回值
有参数，有返回值
例如：
package com.click369.test2;
public class UserBean {
public void testUser1(){
System.out.println("UserBean类的testUser1的实例方法");
}
}
package com.click369.test2;
/**
* 个人信息类
* @author Administrator
*
*/
public class PersonBean {
//1.没有参数，没有返回值
public void test1(){
System.out.println("没有参数，没有返回值");
}
//2.没有参数，有返回值
public String test2(){
System.out.println("没有参数，有返回值");
return "hello";
}
//3.有参数，没有返回值
public void test3(int num1,double num2){
System.out.println("有参数，没有返回值");
System.out.println("int num1=="+num1);
System.out.println("double num2=="+num2);
}
//4.有参数，有返回值
public double test4(int num1,double num2){
System.out.println("有参数，有返回值");
System.out.println("int num1=="+num1);
System.out.println("double num2=="+num2);
return num1+num2;
}
//5.参数为复合数据类型
public void test5(UserBean user){
System.out.println("参数为复合数据类型");
user.testUser1();
}
//6.返回值为复合数据类型
public UserBean test6(){
System.out.println("返回值为复合数据类型");
//UserBean user=new UserBean();
//return user;
return new UserBean();
}
}
package com.click369.test2;
public class TestMain {
public static void main(String[] args) {
PersonBean person=new PersonBean();
//1.调用没有参数，没有返回值
//person.test1();
//2.调用没有参数，有返回值,创建变量接收方法的返回值结果
//String value=person.test2();
//System.out.println("test2方法的执行结果=="+value);
//3.调用有参数，没有返回值,传入参数值
//person.test3(100, 12.5);
//int a=100;
//double b=12.5;
//person.test3(a,b);
//4.调用有参数，有返回值,传入参数值,创建变量接收方法的返回值结果
//double num=person.test4(100, 12.5);
//System.out.println("test4方法的执行结果=="+num);
//5.调用参数为复合数据类型的方法
//person.test5(new UserBean());
//UserBean user=new UserBean();
//person.test5(user);
//6.调用返回值为复合数据类型的方法
UserBean user=person.test6();
user.testUser1();
}
}
总结：1.先new 2，要什么，给什么 3. 给什么，收什么
10.类与对象的关系？
类和对象之间是抽象与具体的关系。类是一个模板是对一类事物的抽象描述，而对象用于表示现实中该事物的个体。类是在对象之上的抽象，对象则是类的具体化，是类的实例。类必须通过对象才可以使用，而对象中的属性和行为必须在类中定义