package com.qianfeng.test;
/*
* 总结成员变量的特点:
* 1.在创建对象的时候会被赋上初始值
* 2.可以在创建类的同时直接给值,供所有的对象共享.
* 3.可以在没有被static修饰的方法之外使用.
*
* 比较成员变量和局部变量?
* 成员变量 局部变量
* 1.作用域: 整个对象 ;从定义变量开始到他所在的函数/for/if等结束
* 2.默认值:有默认值 ;没有默认值,如果想使用,必须先赋值后使用
* 3.存放位置:放在堆区里面的对象中;放在栈区里面的方法中
* 4.释放机制:跟对象保持一致,通过垃圾回收机制回收;使用完立即释放
*
* 成员可以分成两类:
* 1.静态的成员-被static修饰的.静态的成员变量和方法--可以通过引用和类名调用
* 2.非静态的成员:非静态的成员变量和方法----只能通过引用调用
*
* 为什么可以通过类名直接调用静态的成员?
*
为什么可以通过类名直接调用静态的成员变量?
* *当成员被static修饰之后就变成了静态的,会在class生成的同时放在静态方法区中一份,而静态方法区的特点是内容会随着
程序的结束而释放,所以对象的创建与否不能影响他们的调用,所以可以直接使用类名调用
静态的成员方法和非静态的成员方法优先使用哪一个?
答:优先使用静态的成员方法
原因:静态的方法比非静态的效率高,节省内存.
注意:但是有一种情况例外:当方法中必须使用非静态的成员变量的时候,这时必须使用非静态的方法
总结:被static修饰的成员变量会变成静态的成员变量,成员方法会变成静态的成员方法.
在使用类名调用成员的时候,实际上是在使用类的字节码文件对象调用静态成员.
*/
public class Demo3 {
public static void main(String[] args) {
Person person = new Person();
person.name = "bingbing";
person.age = 2;
person.show();
System.out.println(person.name);
//通过类名调用静态成员
Person.age = 4;
Person.show();
//Person.name = "lisi"; 类名不能直接调用非静态的成员
}
}
class Person{
String name = "zhangsan";//可以在创建类的同时直接给值
static int age;
public void run(){
System.out.println("跑");
}
public static void show() {
System.out.println("展示");
}
}
package com.qianfeng.test;
public class Demo4 {
public static void main(String[] args) {
//static功能:创建工具类
int[] arr = new int[]{3,5,8};
//不使用非静态的方法-原因:在工具类中没有使用非静态的成员变量.
// ArrayTool arrayTool = new ArrayTool();
// arrayTool.ErFenSearch(arr, 5);
//直接通过类名调用-用static修饰的方法作为工具类的方法
ArrayTool.ErFenSearch(arr, 4);
//验证static修饰的成员变量被所有对象共享
//一个类可以创建多个对象,对象之间没有关系,互不影响.
Test.age = 4;
Test test = new Test();
System.out.println(test.age);//4
Test test1 = new Test();
System.out.println(test1.age);//4
}
/*
* static的作用总结:可以修饰成员变量和成员方法
* 作用:保值-延长成员的存活时间,使其与程序保持一致
*
* 被static修饰的成员变量的特点:
* 1.被当前类的所有对象共享.
* 2.由随着对象的加载而加载变成随着类的加载而加载,变量被放在了静态方法区,执行顺序优先于非静态的成员变量.
* 3.可以使用类名或引用调用
*
* 比较静态的成员变量和非静态的成员变量?
* 1.存储数据的使用:非静态的只能供当前的对象使用,静态的被所有对象共享
* 2.生命周期:非静态的跟对象一致,静态的与程序一致
* 3.存储的位置:非静态的在对象中,静态的在静态方法区
* 4.访问的方式:非静态的只能使用引用.静态的可以使用引用或类名.
*
* 被static 修饰的成员方法的特点:
* 1.静态的成员方法内部只能使用静态的成员
* 2.非静态的成员方法内部既可以使用静态的又可以使用非静态的.
*/
}
class Test{
static int age;
}
package com.qianfeng.test;
/*
* 构造方法:
* 调用时候的构成:类名+()
* 作用:对对象的属性进行初始化,如果我们自己不创建,系统会调用默认的无参构造方法
*
* 创建自己的构造方法:两种
* 1.无参的构造方法:会将成员变量初始化成null或0或false
* 2.有参的构造方法:会将成员变量初始化并赋值(赋值成通过参数传入的值)
*
* 定义:构成:
* 修饰词 方法名(参数列表){
* //方法体
* //执行代码
* }
*
* 注意点:1.没有返回值这一项 2.方法名必须是类名
*
* 使用构造方法的注意点:
* 1.一旦创建了自己的构造方法,就不会再去调用系统的构造方法.
* 2.多个构造方法之间是重载的关系
*
* this:是一个关键字,是引用数据类型.保存的是当前对象的地址,指向当前的对象.
* 场景:想在当前类的内部拿到当前类的引用的时候.
*
* this的作用总结:
* 1.区分成员变量和局部变量
* 2.可以在构造方法中调用其他重载的构造方法,提高代码的复用性,简化代码.
*
* this的注意点:
* 1.在作为方法的时候,只适用于构造方法.
* 2.不能自己调用自己--死循环
* 3.相互之间不能调用--死循环
* 4.在构造方法中调用其他重载的构造方法--代码必须放在第一行.
* 5.在静态方法中不能使用this
*/
public class Demo5 {
public static void main(String[] args) {
Student student = new Student();
student.age = 19;
Student student1 = new Student("冰冰");
student1.age = 19;
System.out.println(student1.name);
}
}
class Student{
String name;
int age;
double weight;
double height;
//无参构造方法
public Student(){
//this(); 死循环
//在构造方法的内部自动进行属性的初始化.
System.out.println("无参构造方法");
}
//有参构造方法
//当成员变量和形参名字一致时,方法内部识别的是形参.依据的是就近原则
//就近原则是从内存的角度说的.
public Student(String name){
this.name = name;
System.out.println("有参构造方法");
}
public Student(String name,int age){
this(name);
this.age = age;
System.out.println("有参构造方法");
}
public Student(String name,int age,double height,double weight){
this(name, age);//相当于在调用有两个参数的构造方法
this.height = height;
this.weight = weight;
System.out.println("有参构造方法");
}
}
package com.qianfeng.test;
public class Demo6 {
/*
* 匿名对象:没有名字的对象
* 作用:简化代码
*/
public static void main(String[] args) {
new Dog();//匿名对象
//调用方法
//使用场景:作为参数传递
//Dog dog = new Dog();
feedDog(new Dog());
new Dog().age = 4;
new Dog().name = "bingbing";
System.out.println(new Dog().age+" "+new Dog().name);
}
public static void feedDog(Dog dog){//dog = new Dog()
dog.age = 3;
}
}
class Dog{
String name;
int age;
}