一个类的组成:
成员变量:在类中方法外
成员方法:去掉static
构造方法:
也是方法:
1)方法名和类名相同
2)没有具体返回类型
3)连void也没有构造方法的注意事项:
1)无参的构造方法,我们不给出,系统会默认提供
2)如果我们提供了有参构造方法(不管带几个参数),那么系统就不会再提供无参构造方法
3)构造方法是可以重载的
方法重载:overload
方法名相同(参数个数不同/参数类型不同)
如果给出了有参构造方法,而没有给出无参构造方法,再去无参构造对象的话就会报错(推荐永远给出无参构造)
4)构造方法的作用:
其实为了给类中属性进行赋值!(数据初始化)
给 成员变量赋值有几种方式?
两种方式:
1.通过setxxx(xxx)方法赋值
2.通过构造方法进行赋值／*需求:
手机事物:
属性:品牌,价格,颜色,内存大小
行为:打电话,玩游戏...
使用java面向对象变成方式:定义一个手机类,写一个标准的类,在PhoneTest 中进行测试*/
public class Phone {
//定义属性
private String brand;
private int price;
private String color;
//定义set/get访问方法
public void setBrand(String brand) {
this.brand = brand;
}
public void setPrice(int price) {
this.price = price;
}
public void setColor(String color) {
this.color = color;
}
public String getBrand() {
return brand;
}
public int getPrice() {
return price;
}
public String getColor() {
return color;
}
//定义构造方法
//无参构造
public Phone() {
}
//定义有参构造
public Phone(String brand, int price, String color) {
this.brand = brand;
this.price = price;
this.color = color;
}
//定义成员方法
public void callPhone(){
System.out.println("手机可以打电话...");
}
public void playGame(){
System.out.println("手机可以玩游戏");
}
}//定义测试类
public class PhoneTest {
public static void main(String[]args){
//利用无参构造对象,并调用set方法赋值
Phone s1=new Phone();
s1.setBrand("华为mate3");
s1.setPrice(4999);
s1.setColor("黑色");
System.out.println(s1.getBrand()+"---"+s1.getPrice()+
"----"+s1.getColor());
System.out.println("-----------------------------------------");
//利用有参构造对象赋值
Phone s2=new Phone ("小米5",3999,"宝石蓝");
System.out.println(s2.getBrand()+"---"+s2.getPrice()+
"----"+s2.getColor());
}
}//定义一个学生类,属性是姓名,年龄,性别 行为是学习
public class Student {
//成员变量
private String name;
private int age;
private char sex;
//访问方法
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public void setSex(char sex) {
this.sex = sex;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public char getSex() {
return sex;
}
//定义构造方法
//无参构造
public Student() {
}
//有参构造
public Student(String name, int age, char sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
//成员方法 学习
public void study(){
System.out.println("学习javaEE");
}
}//定义一个学生的测试类,对两种赋值方法进行测试
public class StudentTest {
public static void main (String []args){
//利用无参构造创建对象,并用setxxx()方法赋值
Student s1= new Student();
s1.setName("张三");
s1.setAge(23);
s1.setSex('男');
System.out.println("姓名:"+s1.getName()+" 年龄:"+s1.getAge()+" 性别:"+s1.getSex());
s1.study();
System.out.println("--------------------------------------");
//利用 有参构造赋值
Student s2=new Student("李思",18,'女');
System.out.println("姓名:"+s2.getName()+" 年龄:"+s2.getAge()+" 性别:"+s2.getSex());
s2.study();
}
}快捷键
alt +ins:选择setter and getter就会生成访问方法
alt+ins:选择constructor 全部选中就可以自动生成有参构造
选择selectNone 就会生成无参构造关于一个类的成员
成员方法:
1)是否有返回值类型
2)是否携带形式参数
有返回值无参的
有返回值带参的
无返回值无参的
无返回值有参的
总结:
1.成员方法都是去掉了static(非静态的),编程中除非有明确要求,否则都是非静态的
2.有具体的返回值类型的成员方法,要用对应的返回值类型接收成员变量的问题
访问问题:
1)当局部变量和成员变量名称不一致的情况,分别访问即可
2)当局部变量和成员变量名称一致的情况下,遵循就近原则:
先在局部位置找(方法定义中或者方法声明上),如果有直接访问它,如果没有,再去类中找(也就是局部变量的优先级高于成员变量)面试题:
Student s=new Student();做了哪些事情?
第一步:先在栈内存中加载Student.class字节码文件
第二步:在栈内存中开辟内存空间Student s
第三步:在堆内存中申请堆内存空间
第四步:系统默认给Student类中的成员变量进行初始化(默认初始化)
第五步:显示初始化
构造方法对数据进行初始化-----或者通过setxxx(xxxx)来赋值
第六步:给堆内存中产生了一个空间地址值
第七步:将空间地址值赋值给变量s
第八步:栈内存变量s指向堆内存地址!出现的问题:什么时候将变量定义为成员变量?
如果当前一些变量能够描述事物的属性的时候,就将属性---设置为成员变量
在实际开发中多使用局部变量!(占用内存少)static关键字
存在,共享共用的意思
静态修饰符static特点:
1)被静态修饰符修饰的变量/方法-------静态变量/静态方法(也叫类变量或者类方法,随着类的加载而加载)
随着静态的加载而加载
2)被静态修饰符修饰的变量或方法优于对象而存在(也就是说对象还没有创建,在加载类的时候就已经将其加载好 了并且静态的变量或方法都是存储在方法区中的静态区的,是一个独立的空间,不在堆内存中)
static和this是不能共存的
加载类---xxx.class---------先执行的
类名 对象名=new 类名();----创建对象是后执行的
3)被静态修饰;有共享,共用的意思
如果一个属性要被几个对象都使用的话,就将其设为静态
4)被静态修饰的变量/方法,可以被类名直接访问!(推荐),也可以使用对象名来访问,只是没必要(不推荐)
实际开发中,并不是为了使用方便,就将某个方法定义为静态,一般情况:定义为静态的功能,那么当前类----一定是一个工具类静态的注意事项:
1)定义静态的变量-------成员位置-----成员变量---加入static(不能修饰局部变量,只能修饰成员变量)
2)非静态的成员(变量或方法)既能访问非静态的成员(变量或方法)也能访问静态成员(变量或者方法)
静态的成员(变量或者方法)只能访问静态的成员(变量或方法)------------>静态只能访问静态,非静态两种都能访问静态变量和成员变量(非静态)的区别:
0)写法格式不同:
静态变量:static修饰 数据类型 变量名;
成员变量:数据类型 变量名
1)内存中位置不一样:
静态成员变量:方法区中----静态区域中
成员变量:堆内存中
2)生命周期不同:
静态成员变量:随着类的加载而加载,类就加载一次,static变量加载一次,随着类的加载完毕,不会立即消失
成员变量,随着对象的创建而存在,不会立即消失,等待垃圾回收器的回收!
3)初始化时机不同
静态成员变量:类加载的时候可以直接初始化!
成员变量:对象创建完毕,才进行初始化!
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
