目录
封装
private关键字
this关键字
构造方法
类的成员方法
一个基本类的标准代码写法
类的初始化过程
static关键字
静态变量和成员变量的区别
main方法是静态的
封装
封装概述 :是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
好处：
隐藏实现细节，提供公共的访问方式
提高了代码的复用性 提高安全性。
封装原则：
将不需要对外提供的内容都隐藏起来。
把属性隐藏，提供公共方法对其访问。
private关键字private关键字：是一个权限修饰符。
可以修饰成员(成员变量和成员方法).
被private修饰的成员只在本类中才能访问。
private最常见的应用： 把成员变量用private修饰
提供对应的getXxx()/setXxx()方法
一个标准的案例的使用
class Phone{ //定义一个手机类
private String name; //用private修饰成员变量
private int price;
private String color;
//提供一个公共的set方法，使外界能给成员变量赋值
public void setName(String s) {
name = s;
}
//提供一个公共的get方法，使外界能能获取到成员变量的值
public String getName() {
return name;
}
public void setPrice(int p){
price= p;
}
public int getPrice(){
return price;
}
public void setColor(String c){
color=c;
}
public String getColor(){
return color;
}
public void show(){//打印所有的成员变量值
System.out.println("品牌："+name+" 价格:"+price+" 颜色:"+color);
}
}
public class PrivateTest1 {
public static void main(String[] args) {
Phone r=new Phone();
//调用set方法为成员变量赋值
r.setName("XX手机");
r.setPrice(9999);
r.setColor("黑色");
r.show();
//调用get方法获取成员变量的值
System.out.println(r.getName());
System.out.println(r.getPrice());
System.out.println(r.getColor());
}
}
this关键字
this:代表所在类的对象引用
记住： 方法被哪个对象调用，this就代表那个对象
class Dog{//定义一个狗的类
//定义狗的成员变量（品种，名字，年龄）
private String breed;
private String name;
private int age;
public void setBreed(String breed) {
this.breed = breed; //使用this引用对象
}
public void setName(String name) {
this.name = name; //这里其实隐藏了一个this，可以不写，因为就近原则就是对象的成员变量
}
public void setAge(int age) {
this.age = age;
}
public String getBreed() {
return breed;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public void show(){
System.out.println("品种："+breed+"名字："+name+"年龄："+age);
}
}
public class PrivateTest3 {
public static void main(String[] args) {
Dog dog=new Dog(); //创建一个狗的对象
//给成员变量进行赋值
dog.setBreed("哈士奇");
dog.setName("大风");
dog.setAge(4);
dog.show();
}
}
构造方法
构造方法作用概述：给对象的数据进行初始化
构造方法格式
方法名与类名相同
没有返回值类型，连void都没有
没有具体的返回值
无参构造方法：
class Student{ //定义一个学生类
//定义成员变量
private String name;
private int age;
//定义一个构造方法
Student(){
System.out.println("这是一个构造方法");
}
}
public class StudentTest {
public static void main(String[] args) {
//创建Student类的对象
//调用的是无参构造方法创建对象
Student student=new Student();
}
}
带参构造方法：
class Student{ //定义一个学生类
//定义成员变量
private String name;
private int age;
//定义一个无参构造方法
Student(){
System.out.println("这是一个构造方法");
}
//定义一个带参数name的构造方法
Student(String name){
System.out.println("这是一个带参数name的构造方法");
}
//定义一个带参数name和age的构造方法
Student(String name,int age){
System.out.println("这是一个带参数name和age的构造方法");
this.name=name;
this.age=age;
}
public void show(){
System.out.println(name+"------"+age);
}
}
public class StudentTest {
public static void main(String[] args) {
//创建Student类的对象
//调用的是无参构造方法创建对象
Student student=new Student();
student.show();
//使用带一个参数的构造方法创建对象
Student student1=new Student("小米");
student1.show();
//使用带两个参数的构造方法创建对象
Student student2=new Student("小明",18);
student2.show();
}
}
构造方法注意事项
如果你不提供构造方法，系统会给出默认构造方法
如果你提供了构造方法，系统将不再提供
构造方法也是可以重载的
给成员变量值的赋值方法a.使用无参构造方法+setXxx()方法给成员变量赋值
b.使用带参数的方法给成员变量赋值，需要与this关键字配合使用。
类的成员方法方法具体划分：
a.根据返回值：有明确返回值的方法
返回void类型的方法（无返回值）
b.根据形式参数：无参方法
有参方法
class Function{
//定义一个无返回值无参数的方法
public void Function1(){
System.out.println("这是一个无返回值无参数的方法");
}
//定义一个无返回值有参数的方法
public void Function2(String name){
System.out.println("这是一个无返回值有参数的方法"+name);
}
//定义一个有返回值无参数的方法
public String Function3(){
return "16年义务教育";
}
//定义一个有返回值有参数的方
public String Function4(String s){
return s+"欢迎你";
}
}
public class FunctionTest {
public static void main(String[] args) {
Function function=new Function();//创建function类的对象
//无返回值的方法，直接调用输出结果
function.Function1();
function.Function2("User");
//有返回值的方法，调用时，需要用一个变量接收
String s= function.Function3();
System.out.println(s);
String e= function.Function4("User");
System.out.println(e);
}
}
一个基本类的标准代码写法
类的组成：成员变量，成员方法
成员变量：被private修饰
构造方法：一个无参构造方法/一个带所有参数的构造方法
成员方法：setXxx（...）和getXxx()
show()：打印所有成员变量的值
例：一个手机的标准代码
class Phone{
//定义成员变量
private String brand;
private int price;
private String color;
//定义构造方法（快捷键alt +insert选Constructor）
public Phone() {}
public Phone(String brand, int price, String color) {
this.brand = brand;
this.price = price;
this.color = color;
}
//setXxx()方法和getXxx方法（快捷键alt+insert选Getter和Setter）
public String getBrand() {
return brand;
}
public int getPrice() {
return price;
}
public String getColor() {
return color;
}
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 void call(String name){
System.out.println("给"+name+"打电话");
}
//展示所有成员变量的值
public void show(){
System.out.println("品牌："+brand+",价格："+price+",颜色："+color);
}
}
public class PhoneTest {
public static void main(String[] args) {
Phone phone=new Phone("华为",9999,"黑色");//调用有参构造方法创建对象
phone.show();
phone.call("User"); //调用打电话的方法
}
}
类的初始化过程
Student s = new Student();在内存中做了哪些事情?
a.加载Student.class文件进内存
b.在栈内存为s开辟空间
c.在堆内存为学生对象开辟空间
d.对学生对象的成员变量进行默认初始化
e.对学生对象的成员变量进行显示初始化
f.通过构造方法对学生对象的成员变量赋值
g.学生对象初始化完毕，把对象地址赋值给s变量
static关键字可以修饰成员变量和成员方法
static关键字特点 :随着类的加载而加载
优先于对象存在
被类的所有对象共享(这也是我们判断是否使用静态关键字的条件)
可以通过类名调用
例：我们创建一个动物类
class Animal{ //定义一个动物类
private String name;
private String color;
private String kind;
public Animal(){}
public Animal(String name, String color, String kind) {
this.name = name;
this.color = color;
this.kind = kind;
}
//getXxx()和setXxx(..)方法
public void show(){
System.out.println("动物名字："+name+",颜色:"+color+",种类:"+kind);
}
}
public class AnimalTest {
public static void main(String[] args) {
Animal animal=new Animal("老虎","黄色","猫科动物");//用构造方法创建Animal类的对象
animal.show();
Animal animal1=new Animal("狮子","棕色","猫科动物");
animal1.show();
Animal animal2=new Animal("猫","白色","猫科动物");
animal2.show();
}
}
我们可以发现这三种动物都是猫科动物，每次创建新对象时，就会在堆内存中开辟空间，如果数量非常多，这样就造成了浪费，所有我们可以用static改进。
改进后：
class Animal{ //定义一个动物类
private String name;
private String color;
private static String kind; //使用static修饰kind
public Animal(){}
public Animal(String name, String color, String kind) {
this.name = name;
this.color = color;
this.kind = kind;
}
public Animal(String name,String color){ //新增构造方法
this.name = name;
this.color = color;
}
//getXxx()和setXxx(..)方法
public void show(){
System.out.println("动物名字："+name+",颜色:"+color+",种类:"+kind);
}
}
public class AnimalTest {
public static void main(String[] args) {
Animal animal=new Animal("老虎","黄色","猫科动物");//用构造方法创建Animal类的对象
animal.show();
Animal animal1=new Animal("狮子","棕色"); //调用新的构造方法
animal1.show();
Animal animal2=new Animal("猫","白色");
animal2.show();
}
}
改进前后的输出结果都是一样的，改进后的更加节省内存
static关键字注意事项 : 在静态方法中是没有this关键字的
静态方法只能访问静态的成员变量和静态的成员方法
静态变量和成员变量的区别a.所属不同：
静态变量属于类，所以也称为为类变量
成员变量属于对象，所以也称为实例变量(对象变量)
b.内存中位置不同
静态变量存储于方法区的静态区
成员变量存储于堆内存
c.内存出现时间不同
静态变量随着类的加载而加载，随着类的消失而消失
成员变量随着对象的创建而存在，随着对象的消失而消失
d.调用不同
静态变量可以通过类名调用，也可以通过对象调用
成员变量只能通过对象名调用
main方法是静态的public static void main(String[] args) {}
a. public 被jvm调用，访问权限足够大。
b. static 被jvm调用，不用创建对象，直接类名访问
c.void被jvm调用，不需要给jvm返回值
d. main 一个通用的名称，虽然不是关键字，但是被jvm识别
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）