封装构造函数类的组成

最新推荐文章于 2024-08-14 23:12:09 发布

披云戴月一枝花

最新推荐文章于 2024-08-14 23:12:09 发布

阅读量59

点赞数

文章标签： java

本文链接：https://blog.csdn.net/asdasaaasd/article/details/129374821

版权

面向对象的三大特性: 封装继承多态

1、封装

概述

面向对象编程语言是对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。封装可以被认为是一个保护屏障，防止该类的代码和数据被其他类随意访问。要访问该类的数据，必须通过指定的方式。适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。

原则

将属性隐藏起来，若需要访问某个属性，提供公共方法对其访问。

1.1 重载

   我们在实现各种整数相加的时候方法名不一样的
   但是方法的命名要遵循见名知意
   怎么办?

针对这种情况，方法的功能相同,参数列表不同,为了见名知意
Java就允许这些相同功能，但是不同参数的方法使用同一个名字专业名词:方法重载

	//在一个类中，方法名相同，参数列表不同(参数的类型或者个数不同) 与返回值没有关系 
	
	
	//1.两个整数相加  返回结果
	public int sum(int a,int b) {
		return a+b;
	}
	
	public long sum(long a,int b) {
		return a+b;
	}
	
	
//	public long sum(int a,int b) {
//		return a+b;
//	}
	
	
	//错误的，和方法的参数的名字是没有关系的，因为调用方法是靠方法的参数个数和类型来确定一个方法的
//	public int sum(int b,int a) {
//		
//	}
	
	
	//2.三个整数相加  返回结果
	public int sum(int a,int b,int c) {
		return a+b+c;
	}
	
	
}

public class NumberDemo02 {
	
	public static void main(String[] args) {
		
		
		Number2 number=new Number2();
		System.out.println(number.sum(1, 2));
		System.out.println(number.sum(1l, 2));
		System.out.println(number.sum(1, 2,3));
		
	}

}

1.2 封装的概念

面向对象编程语言是对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。封装可以被认为是一个保护屏障，*防止该类的代码和数据被其他类随意访问*。要访问该类的数据，必须通过指定的方式。适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。

将属性隐藏起来，若需要访问某个属性，提供公共方法对其访问。

class Student{
	
	String name;
	
	//成员变量
	//成员变量可以赋值，但是可以进行一些非法操作
	//在赋值之前，可以先判断一下，在哪里判断?
	//逻辑代码必须写在方法中
	//private 私有的，可以修饰成员变量和成员方法
	//被private修饰的成员只能在本类中访问
	//我们在这个类中写一个赋值的方法
	//age不能直接赋值 private修饰
	private int age;
	
	
	//public 公有的，外界可以访问
	//封装： 指隐藏对象的属性和实现细节，仅对外提供公共的访问方式
	public void setAge(int a) {
		
		if(a<0 || a>120) {
			System.out.println("你是妖怪!");
		}else {
			//int a 局部变量
			//age 成员变量
			age=a;
		}
		
	}
	
	//写一个方法来获取它的值
	//两个明确:
	//返回值类型 int
	//参数列表 没有参数
	//修饰符 public
	public int getAge() {
		return age;
	}
	
	public void show() {
		System.out.println("展示肌肉...");
	}
	
	public void eat() {
		System.out.println("吃奥利给饼干!");
	}
	
}

public class StudentDemo {
	
	public static void main(String[] args) {
		
		Student s=new Student();
		
		s.name="小龙";
		
		s.setAge(21);
		
		System.out.println("name:"+s.name+";age="+s.getAge());
		
		
	}

}

private 特点

private 权限修饰符可以修饰成员变量和成员方法
被private修饰的成员变量或者成员方法只能在本类中访问
外界访问只能通过公共的方法间接的调用

class Private{
	
	private int num=10;
	
	
	public void show() {
		//本类的方法可以访问私有的属性
		System.out.println(num);
	}
	
	private void method() {
		System.out.println("method");
	}
	
	public void function() {
		//本类的方法可以访问私有的方法
		method();
	}
	
}

public class PrivateDemo {
	
	public static void main(String[] args) {
		
		Private p=new Private();
		p.function();
	}

}

标准的封装

class Person{

	//姓名
	private String name;
	
	//年龄
	private int age;
	
	//姓名的设置
	public void setName(String n) {
		//今后的开发中，不在这里写判断,专门的地方
		name=n;
	}
	
	//姓名的获取
	public String getName() {
		return name;
	}
	
	
	//年龄的设置
	public void setAge(int a) {
		age=a;
	}
	
	//年龄的获取
	public int getAge() {
		return age;
	}
	
	
}

public class PersonDemo {

	public static void main(String[] args) {
		
		Person person=new Person();
		
		//赋值
		person.setName("奥利给");
		person.setAge(88);

		//获取值
		System.out.println(person.getName()+person.getAge());
		
	}
	
}

1.3 this 关键字

this就代表对象 this.属性操作成员的属性

class Car{
	
	//品牌
	private String brand;//null
	
	//颜色
	private String color;
	
	//价格
	private double price;
	
	
	//设置品牌
	//String b 方法的参数名没有见名知意
    //String brand 局部变量
	//如果在方法中遇到了局部变量和成员变量同名，如果直接使用变量名他是就近原则,就是局部变量
	//就是想把局部变量的值传递给成员变量
	//成员变量怎么调用?
	//对象名.属性
	//那么，谁能够代表当前对象呢?  java提供了一个关键字叫做this
	//this就代表对象  this.属性  操作成员的属性
	public void setBrand(String brand) {
		this.brand = brand;
		System.out.println(brand+"内部");
	}
	
	
	public String getBrand() {
	    //当方法中只能操作成员变量的时候 系统会自动加上this
		//return this.brand;
		//this可以不写
		return brand;
	}
	
	public String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	}
	public double getPrice() {
		return price;
	}
	public void setPrice(double price) {
		this.price = price;
	}
	
	
	
}
public class CarDemo {

	public static void main(String[] args) {
		
		
		Car car=new Car();
		
		car.setBrand("科斯拉");
		
		System.out.println(car.getBrand());
		
	}
}

构造函数

2.1 构造方法的格式

构造方法：给对象进行初始化

格式

方法名与类名相同

没有返回值，连void都没有

没有具体的返回值

构造方法他是在创建对象时自动调用

class Student{
	
	private String name;//null
	private int age;//0
	
	public  Student() {
		System.out.println("这是构造方法...");
	}
	
	
}

public class StudentDemo {
	
	
	public static void main(String[] args) {
		
		Student s=new Student();
		
		System.out.println(s);
		
	}
	

}

2.2 构造方法的重载

我们一直在使用构造方法，但是之前我们没有定义构造方法，构造啊方法怎么来的呢？

注意：如果我们没有给出构造方法，系统会自动提供一个无参的构造方法

如果我们给出了构造方法系统将不会自动提供无参的构造方法

这个时候，如果写的是有参数的构造函数，就必须自己给出无参的构造函数。

class Student{
	
	private String name;//null
	private int age;//0
	
	public  Student() {
		System.out.println("这是构造方法...");
	}
	
	public Student(String name) {
		this.name=name;
	}
	
	public Student(String name,int age) {
		this.name=name;
		this.age=age;
	}
	
	public Student(int age,String name) {
		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);
		System.out.println(age);
	}
	
}

public class StudentDemo {
	
	
	public static void main(String[] args) {
		
		
		//1.使用有一个参数的构造方法
		Student s=new Student("奥列给");
		
		s.show();
		
		//2.使用有两个个参数的构造方法
		Student s2=new Student("奥列给的女朋友",21);
				
	    s2.show();
	    
	    
		Student s3=new Student(1,"xxx");
		
	    s3.show();
	    
	    
        Student s4=new Student();
		
	    s4.show();
	    
	    s4.setName("王某");
	    s4.setAge(19);
	    
	    s4.show();
		
	}
	

}

有参数的构造函数，就必须自己给出午餐的构造函数。