JAVA语言中类、对象、封装、private、this、构造方法、static及main方法格式解释

系统管理员 2021-12-12 03:17 174阅读 0赞

### 类与对象 ###

**面向对象**  
       面向对象是基于面向过程的编程思想  
**类与对象**  
       Java语言中最基本的单位是类。用类体现事物  
**类**  
       成员变量                事物属性  
       成员方法                事物行为  
**类**：是一组相关的属性和行为的集合。  
**对象**：是该类事物的具体存在，是一个具体的实例。  
例如：  
学生：类  
班长：对象

**类的定义及使用**  
       **类的定义**：  
              成员变量：定义格式相同，只是位置不同  
              成员方法：定义格式不同，只是去掉了static  
       **使用类的内容**  
              创建对象格式：  
                     类名   对象名 = new 类名();  
              **使用成员变量、成员方法**  
                      对象名.成员变量  
                      对象名.成员方法()

**成员变量与局部变量的区别**  
       在类中位置不同  
              成员变量：类中方法外  
              局部变量：方法内或方法声明上  
       在内存中位置不同  
              成员变量：栈内存  
              局部变量：堆内存  
       生命周期不同  
              成员变量：随着对象的存在而存在，随着对象的消失而消失  
              局部变量：随着方法的调用而存在，随着方法的调用完毕而消失  
       初始化不同  
              成员变量：用默认初始化值  
              局部变量：没有默认初始化值，必须先定义，赋值，才能使用。   
              
**形式参数的问题：**  
       基本类型：形式参数的改变不影响实际参数  
       引用类型：形式参数的改变直接影响实际参数  
     （引用类型有：类、接口、数组）

**匿名对象**：没有名字的对象。  
       应用场景：只调用一次的时候适合，调用多次不适合。  
       匿名对象调用完毕后可以别垃圾回收器回收

class Student1{
    	public void show() {
    		System.out.println("hello world");
    	}
    }
    
    class Student1Demo{
    	public void method(Student1 s) {
    		s.show();
    	}
    }
    
    public class NoName {
    
    	public static void main(String[] args) {
    		
    		Student1Demo s = new Student1Demo();
    		Student1 s1 = new Student1();
    		s.method(s1);
    		
    		System.out.println("---------");
    		
    		//匿名方法调用
    		new Student1Demo().method(new Student1());
    	}
    }
    
    --------------------------------------------------------------------------------------
    
    结果：
    hello world
    ---------
    hello world

### 封装 ###

封装  
       **封装**：是指隐藏对象的属性和实现细节，只对外提供公共访问方式。  
      ** 好处**：  
                1、隐藏了实现细节，提供公共的访问方式  
                2、提高了代码的复用性  
                3、提高了安全性  
       **封装原则**：  
              将不需要对外提供的内容都隐藏起来  
              把属性隐藏，提供公共方法对其访问

**private关键字**  
       是一个权限修饰符  
       可以修饰成员（成员变量和成员方法）  
       被private修饰的成员只在本类中才能访问。  
**private常见应用：**  
       把成员变量用private修饰  
       提供对应的getXxx()/setXxx()方法

**this关键字**  
       代表所在类的对象引用  
       方法被哪个对象调用，this就代表那个对象（当局部变量隐藏成员变量时使用）

**构造方法**  
      ** 构造方法作用：**给对象的数据进行初始化  
       **构造方法格式：**  
              方法名与类名相同  
              没有返回值类型，连void都没有  
              没有具体的返回值  
       **构造方法注意事项**  
              构造方法也是可以重载的  
              如果给未出构造方法，系统将自动提供一个无参构造方法。  
              如果给出构造方法，系统将不再提供默认的无参构造方法。（如果还想使用无参构造方法，必须自己给出）  
            （建议自己给出无参构造方法）  
        **给成员赋值两种方式**  
               setXxx();  
               构造方法

class Student{
    	private String name;
    	
    	private int age;
    	
    	//无参构造方法
    	public Student(){
    	}
    	
    	//带参构造方法
    	public Student(String name,int age) {
    		this.name=name;
    		this.age=age;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public int getAge() {
    		return age;
    	}
    
    	public void setAge(int age) {
    		this.age = age;
    	}
    	public void show() {
    		System.out.println(name+"---"+age);
    	}
    }
    	
    public class StudentTest {
    	public static void main(String[] args) {
    		Student s = new Student();
    		
    		s.setName("林青霞");
    		s.setAge(27);
    		
    		System.out.println(s.getName()+"---"+s.getAge());
    		
    		Student s1 = new Student("刘意",30);
    		
    		s1.show();
    	}
    }
    
    
    ----------------------------------------------------------------------------------------
    结果：
    
    林青霞---27
    刘意---30

**类的初始化过程**  
       加载Student.class文件进内存  
       在栈中为s开辟空间  
       在堆内存未学生对象开辟空间  
       对学生对象的成员变量进行默认初始化  
       对学生对象的成员变量进行显示初始化  
       通过构造方法对学生对象的成员变量赋值  
       学生对象初始化完毕，把对象地址赋值给s变量

class Phone{
    	//品牌
    	private String brand;
    	//价格
    	private int price;
    	//颜色
    	private String color;
    	//无参构造方法
    	public Phone() {
    		
    	}
    	
    	public void setBrand(String brand) {
    		this.brand=brand;
    	}
    	
    	public int getPrice() {
    		return price;
    	}
    	
    	public void setPrice(int price) {
    		this.price = price;
    	}
    	
    	public String getColor() {
    		return color;
    	}
    	
    	public void setColor(String color) {
    		this.color = color;
    	}
    	
    	public String getBrand() {
    		return brand;
    	}
    	
    }
    public class PhoneTest {
    
    	public static void main(String[] args) {
    		Phone s = new Phone();
    		s.setBrand("三星");
    		s.setPrice(4999);
    		s.setColor("褐色");
    		System.out.println(s.getBrand()+"---"+s.getPrice()+"---"+s.getColor());
    	}
    }
    
    -----------------------------------------------------------------------------------------
    结果：
    
    三星---4999---褐色

**如果一个变量是用来描述这个类的信息，该变量就应该定义为成员变量**

**static关键字**  
         可以修饰成员变量和成员方法  
         特点：  
                随着类的加载而加载  
                优先与对象存在  
                被类的所有对象共享（判断该不该使用静态的依据）  
                可以通过类名调用  
          注意事项  
                 在静态方法中是没有this关键字  
                 静态方法只能访问静态成员变量和静态成员方法（非静态方法都可以访问）

**静态变量和成员变量的区别**  
       所属不同  
              静态变量：属于类，类变量  
              成员变量：属于对象，对象变量，实例变量  
       内存位置不同  
              静态变量：方法区的静态区  
              成员变量：堆内存  
       生命周期不同  
              静态变量：静态变量是随着类的加载而加载，随着类的消失而消失  
              成员变量：成员变量是随着对象的创建而存在，随着对象的消失而消失  
       调用不同  
              静态变量：可以通过对象名调用，也可以通过类名调用  
              成员变量：只能通过对象名调用

**main方法格式：**  
public  static  void  main(String\[\]  args)\{....\}  
public:公共的，访问权限是最大的。由于main方法是被jvm调用，所以权限要够大。  
static:静态的，不需要创建对象，通过类名就可以。方便jvm调用。  
void:main方法是被jvm调用，不需要返回值  
main:是一个常见的方法入口。（主方法）  
String\[\]  args:字符串数组。