跳转控制语句 方法 面向对象之封装

跳转控制语句

跳转控制语句：break,continue,return 
break:表示结束，中断的意思
	单独使用，没有意义，只能switch语句或者循环语句中使用
continue:结束当前循环，立即进行下一次循环
break:结束方法使用

方法

方法的概念：就是用{}包起来的内容，给{}独立的代码块起一个名字，以便于复用
定义方法有两种情况：
	情况1：有具体返回值类型的方法定义：
	定义格式：
权限修饰符 静态修饰符 返回值类型 方法名（形式参数列表）{
	return结果；
}
定义方法时两个明确：1）明确返回值类型
		   		  2）明确参数类型和参数个数
	调用方法（目前main方法中调用）：赋值调用
	情况2：没有具体返回值类型的方法定义：
	定义格式：
权限修饰符 静态修饰符 void 方法名（参数列表）{
	输出结果；
}
定义方法时两个明确：1）明确返回值类型：void
				  2）明确参数类型和参数个数
	调用方法：单独调用	
定义方法以及调用方法时的注意事项：
1）方法和方法是平级关系，不能在一个方法中定义另一个方法	；
2）在定义方法的时候，必须带上static关键字（该方法目前都在main方法中调用，必须带上static）
3）在定义方法的时候，知道两个明确
4）在定义方法的时候，形式参数必须带上数据类型

方法重载

方法重载：方法名相同，参数列表不同，与返回值无关
		参数列表不同：1）数据类型不同
					 2）参数个数不同

面向对象

面向对象：基于面向过程的一种思想
面向对象的思想特点：
	1）更符合生活中的思想行为习惯
	2）让复杂的事情简单化
	3）从执行者变成了指挥者
面向对象设计原则：创建按对象，使用对象，指挥对象做事情
面向对象的三大特征：封装，继承，多态
类和事物的关系：
	事物：描述现实世界的真实存在泛指的东西
	类：是描述一组事物的属性和行为的集合
成员变量：类中方法外
成员方法：public 返回值类型 方法名（参数）{}  （去掉static）
创建类对象：类名 对象名 = new 类名（）；
	对象名访问成员变量
	对象名访问成员方法

//学生类
class Student{
	//成员变量(属性)
		int id;
		String name;
		int age;
		String gender;
		//成员方法(行为)
		public void eat(String name){
			System.out.println("吃"+name);
		}
		public void sleep(){
			System.out.println("睡觉");
		}
		public void playGame(){
			System.out.println("开心消消乐");
		}
		public void study(){
			System.out.println("学习");
		}
}
//学生测试
class StudentTest{
	public static void main(String[] args){
		//创建类对象
		//类名 对象名= new 类名();
		Student student = new Student();
		//对象名访问成员变量
		student.id=10;
		System.out.println("学号："+student.id);
		student.name="赵丽颖";
		System.out.println("姓名："+student.name);
		student.age=18;
		System.out.println("年龄："+student.age);
		student.gender="女";
		System.out.println("性别："+student.gender);
		//对象名访问成员方法
		student.eat("火锅");
		student.sleep();
		student.playGame();
		student.study();
		
	}
}

运行结果如下：

局部变量和成员变量的区别

1）在类中的位置不同
	局部变量：在方法定义中或者是方法声明上
	成员变量：在类中方法外
2）在内存中的位置不同
	局部变量：在栈内存中存储
	成员变量：在堆内存中存储
3）生命周期不同
	局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
	成员变量：随着对象的创建而存在，随着对象的创建完毕并且使用完毕，等待垃圾回收器回收掉之后才消失
4）初始时机不同
	局部变量：必须在使用之前进行数据的初始化
	成员变量：在堆内存中，即使这个成员变量没有赋值，系统会根据变量的类型给这个变量进行默认初始化

封装

封装：将类中成员变量私有化（private），对外提供公共的访问方法
	提供公共的访问方法赋值：setXXX/getXXX方法  XXX:对应的属性名称
私有化的成员变量：只能在本类中，外界不能访问
private关键字的特点：
	1）private可以修饰一个类中的成员变量，也可以是成员方法
	2）被private修饰的成员变量，只能在本类中，外界不能访问（保证数据的安全性）

构造方法

构造方法：1）方法名和类名相同
		 2）没有具体的返回值类型
		 3）连void都没有
格式：
权限修饰符  方法名（类名）（）{

}
构造方法的主要作用：就是给该类对象中的数据进行初始化
构造方法中的注意事项：
	1）在一个类中，我们不写无参构造方法，系统会默认的提供一个无参构造方法
	2）如果我们提供一个有参构造方法，系统不会再提供无参了，如果使用无参构造方法创建对象，就会报错，所以永远建议给出无参构造方法

class Phone{
	//成员变量
	private String brand;
	private String color;
	private int price;
	private int memory;
	//构造方法
	public Phone(){
	}
	public Phone(String brand,String color,int price,int memory){
		this.brand = brand;
		this.color = color;
		this.price = price;
		this.memory = memory;
	}
	public void setBrand(String brand){
		this.brand = brand;
	}public void setColor(String color){
		this.color = color;
	}
	public void setPrice(int price){
		this.price = price;
	}
	public void setMemory(int memory){
		this.memory = memory;
	}
	public String getBrand(){
		return brand;
	}
	public String getColor(){
		return color;
	}
	public int getPrice(){
		return price;
	}
	public int getMemory(){
		return memory;
	}
	//成员方法
	//打电话
	public void callPhone(){
		System.out.println("手机可以打电话");
	}
	//拍照
	public void takePhoto(){
		System.out.println("手机可以拍照");
	}
	//聊天
	public void chart(){
		System.out.println("手机可以聊天");
	}
	
}
//测试手机类
class PhoneDemo{
	public static void main(String[] args){
		//方式1
		Phone p = new Phone("华为手机","蓝色",5000,32);
		System.out.println(p.getBrand()+"---"+p.getColor()+"---"+p.getPrice()+"---"+p.getMemory());
		p.callPhone();
		p.takePhoto();
		p.chart();
		System.out.println("----------------------");
		Phone p2 = new Phone();
		p2.setBrand("华为手机");
		p2.setColor("黑色");
		p2.setPrice(5999);
		p2.setMemory(16);
		System.out.println(p2.getBrand()+"---"+p2.getColor()+"---"+p2.getPrice()+"---"+p2.getMemory());
		p2.callPhone();
		p2.takePhoto();
		p2.chart();
	}
}

运行结果如下：

static关键字

关于静态static的特点：
1）被static修饰的变量或方法，都随着类的加载而加载
2）被static修饰，优先于对象存在
3）被static修饰的可以被多个对象共用
4）被static修饰的成员方法或成员变量，可以被类名直接访问
使用static关键字的注意事项：
1）在static中，是没有this关键字的
2）访问问题：
	非静态的成员方法：既可以访问静态的成员变量，也可以访问非静态的成员变量
				    既可以访问静态的成员方法，也可以访问非静态的成员方法
	静态的成员方法：静态只能访问静态