Java语言基础5

面向对象（成员变量和局部变量）

成员变量和局部变量的区别：
1.在类中的位置不同
A：成员变量 类中方法外
B：局部变量 方法内或者方法声明上
2.在内存中的位置不同
A：成员变量 堆内存
B：局部变量 栈内存
3.生命周期不同
A：成员变量 随着对象的存在而存在，随着对象的消失而消失
B：局部变量 随着方法的调用而存在，随者方法的调用完毕而消失
4.初始化值不同
A：成员变量 有默认的初始化值
B：局部变量 没有默认的初始化值，必须先定义，赋值，才能使用。
注意事项：
局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。

面向对象（方法的形式参数是类名的时候如何调用）

形式参数的问题：
基本类型：形式参数的改变不影响实际参数
引用类型：形式参数的改变直接影响实际参数

// An highlighted block
//形式参数是基本类型
class Demo{
	public int sum(int a,int b){
	return a+b;
}
}
//形式参数是引用类型
class Student{
	public void show(){
	System.out.println("我爱学习");
}
}
class StudentDemo{
//如果你看到了一个方法的形式参数是一个类类型（引用数据类型），其实需要的是该类的对象
	public void method(Student s){//调用的时候，把main方法中的s的地址传到了这里Student s = new Student（）
	s.show();
}
}

class ArgsTest{
	public static void main(String[] args){
//形式参数是基本类型的调用
	Demo d = new Demo();
	int result = d.sum(10,20);
	System.out.println(result:+result);
//形式参数是引用类型的调用
//需求：我要调用StudentDemo类中的method()方法
	StudentDemo sd = new StudentDemo();
	//创建学生对象	
	Student s = new Student();
	sd.method();//把s的地址给到了这里
	
}
}

面向对象（匿名对象的概述和应用）

匿名对象

匿名对象:就是没有名字的对象
是对象的一种缉拿话表示形式
匿名对象的两种使用情况
对象调用方法仅仅一次的时候
作为实际参数传递

package mianxiangduixiang;
/*匿名对象：就是没有名字的对象
匿名对象的应用场景：
A：调用方法，仅仅只调用一次的时候
B：注意，多次调用不适合
好处：匿名对象调用完毕就是垃圾。可以被回收，提高资源利用率
C：匿名对象可以作为实际参数传递
*/

// An highlighted block
public class NoName {

	public static void main(String[] args) {
		//带名字的调用
		Student s = new Student();
		s.study();
		System.out.println("----------------------");
		//匿名调用
		new Student().study();
		System.out.println("----------------------");
		//匿名对象作为实际参数传递
		StudentDemo sd = new StudentDemo();
		Student ss = new Student();
		sd.method(ss);//这里的ss是一个实际参数
		//匿名对象
		sd.method(new Student());
		//多个匿名对象的调用
		new StudentDemo().method(new Student());
		
	}

}

面向对象（封装的概述）

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

定义一个学生类：
成员变量：name,age;
成员方法：show（）方法
我们在这个案例的过程中，发现了一些问题：
通过对象去给成员变量赋值，可以赋值一些非法的数据。
这样子是不合理的。
影噶是这个样子：在赋值之前，先对数据进行判断。
判断在哪里做比较合适：
StudentDemo类只是一个测试类，测试类一般只创建对象，调用方法。
所以判断应该定义在Student类中；
而我们在成员变量的位置可以不可以进行数据判断呢？
是不可以的，因为做数据校验，必须要依靠依靠一些逻辑语句
逻辑语句是应该定义在方法中的，所以，我们最终咋Student类中提供一个方法
来对数据进行校验
按照我们前面的分析，我们给出了一个方法进行校验
但是呢，它偏偏不调用方法来赋值，我们直接赋值了
这样我么的方法就没有起到作用。
我就应该要求你必须使用我的方法，而不能直接调用成员变量赋值
怎么去强制要求不能直接使用成员变量呢
针对这种情况，java就提供了一个关键字private
private:私有的。可以修饰成员变量和成员方法
注意：被private修饰的成员只能在本类中访问

private关键词的概述和特点

privaet关键字
是一个权限修饰符。
可以修饰成员（成员变量和成员方法）
被private修饰的成员只在本类中才能访问
private最常见的应用：
把成员变量用private修饰
提供对应的getxxx()/setxxx()方法
一个标准的案例的使用

_this关键字的概述和应用

this：代表所在类的对象引用
记住：
方法被那个对象调用，this就代表那个对象
什么时候调用this呢？
局部变量隐藏成员变量；
其他用法后面和super一起讲解

// An highlighted block
//定义一个学生类：
class Student{
	private String name;
	private int age;
//姓名获取值
	public String getName(){
	return name;
	}
//姓名设置值
public void setName(String name){//name = "林青霞";
	/*
	name = name;变量的使用规则就近原则
	这里是类名，目前还没有过类似的用法，所以这个是有问题的
	这里的调用只能通过对象名
	这个对象如果存在，它应该代表的是Student的一个对象
	那么，谁能够代表当前类的对象呢？java就提供了一个关键字this
	this.name = name;
	*/

	this.name = name;
}
	public int getAge(){
	return Age;
}
public voin setAge(int age){
	this age = age;
}
}
class StudentTest{
	public static void main(String[] args){
//创建学生对象
	Student s =new Student();
//给成员变量赋值
	s.setName("林青霞");
	s.setAge(27);
System.out.println(s.getName()+"--------"+s.getAge())
}
}

phone的练习

// An highlighted block
//练习：请把手机类写成一个标注类，然后创建对象测试功能。
/*
 手机类：
  	成员变量：
  		品牌：String brand;
  		价格：int price;
  		颜色：String color;
  	成员方法：
  		针对每一个成员变量给出对应的getXxx()/setXxx()方法；
  	最后定义测试：
  		创建一个对象，先通过getXxx()方法输出成员变量的值。这一次的结构是null--0--null;
  		然后通过setXxx()方法给成员变量赋值。再次输出结构，这一次结果是三星---2999--土豪金；
 */
public class phone {
	private String brand;
	private int price;
	private String color;
	public String getBrand() {
		return brand;
	}
	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 class ceshiphon {

	public static void main(String[] args) {
		//定义一个手机类
		phone p = new phone();
		//给手机型号，价格，颜色赋值；
		System.out.println(p.getBrand()+"---"+p.getPrice()+"---"+p.getColor());
		p.setBrand("三星");
		p.setPrice(2999);
		p.setColor("土豪金");
		System.out.println(p.getBrand()+"---"+p.getPrice()+"---"+p.getColor());
	}

}

构造方法概述和格式

构造方法作用概述;
给对象的数据进行初始化
构造方法格式
方法名与类名相同
没有返回值类型，连void都没有
没有具体的返回值

// An highlighted block
class Student{//类名
	private String name;
	private int age;

	piblic Student(){//方法名
	System.out.println("构造方法")
}
}
class ConstructDemo{
	public static void main (String[] args){
	//创建对象
	Student s = new Student();
	System.out.println(s);//地址值：Studentxxxxx
}
}

构造方法的重载和注意事项

构造方法注意事项
如果你不提供构造方法，系统会给出默认构造方法
如果你提供了构造方法，系统将不再提供
构造方法也是可以重载的

成员方法的分类及使用

类的成员方法
成员方法其实就是我们前面讲过的方法
方法的具体划分;
根据返回值
有明确返回值方法
返回void类型的方法
根据形式参数
无参方法
带参方法

一个标准学生类的代码及测试

一个基本类的标准代码写法
类：
成员变量
构造方法
无参构造方法
带参构造方法
成员方法
getXxx()获取
setXxx()赋值
show();输出该类的所有成员变量值
给成员变量赋值
A：setXxx()方法
B:构造方法
输出成员变量值的方法：
A:通过getXxx()分别获取然后拼接
B:通过调用show()方法搞定

// An highlighted block
/*
 一个标准代码的最终版
 学生类：
  	成员变量
  		name,age
  	构造方法
  		无参，带多个参
  	成员方法
  		getXxx()/setXxx()
  		show():输出该类的所以成员变量值
 给成员变量赋值：
 	1.setXxx()方法
 	2.构造方法
 输出成员变量值的方式：
 	1.通过getXxx()分别获取然后拼接
 	2.通过调用show()发明合法一次全部调用
 */
class Students {
	//姓名
	private String name;
	//年龄
	private int age;
	//构造方法（无参构造）
public Students(){
	}
	//构造方法（带参构造）
public Students(String name,int age) {
	this.name = name;
	this.age = age;
}
	//get,set方法
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;
}

创建对象做了哪些事情

Student s = new Student();在内存中做了哪些事情？
加载Studnets.class文件进内存
在栈内存为s开辟空间
在堆内存为学生对象开辟空间
对学生对象的成员变量进行默认初始化
对学生对象的成员变量进行显示初始化
通过构造方法对学生对象的成员变量赋值
学生对象初始化完毕，把对象地址赋值给s变量

什么时候定义成员变量

类是一组相关性的属性和行为的集合
并且类是通过事物转换过来的
而类中的成员变量就是事物的属性
属性是用来描述事物的
同理：成员变量其实是用来描述类的

变量什么时候定义为成员变量：
如果这个变量是用来藐视这个类的信息的，那么，该变量就应该定义为成员变量
变量到底定义在哪里好呢？
变量的范围是越小越好。因为能及时的被回收。

static关键字的特点

static 的特点：（它可以修饰成员变量，还可以修饰成员方法）
A：随着类的加载而加载
回想main方法
B：优先于对象存在
C：被类的所以对象共享
举例：咱们班级的学生应该共用同一个班级编号
其实这个特点也是在告诉我们什么时候使用静态？
如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的
举例：
饮水机（用静态修饰）因为它可以是公共的
水杯（不能用静态修饰）因为它是共有的
D：可以通过类名调用
其实它本身也可以通过对象名调用
推荐使用类名调用
静态修饰的内容一般我们称其为：与类相关的，类成员

static的注意事项

static关键字
可以修饰成员变量和成员方法
static关键字的特点
随着类的加载而加载
优先于对象存在
被类的所有对象共享
这也是我们判断是否使用静态关键字的条件
可以通过类名调用
static关键字注意事项
在静态方法中是不是没有this关键字
静态方法只能访问静态的成员变量和静态的成员方法

非静态方法：
	成员变量：可以是静态的，也可以是非静态的
	成员方法：可以是静态的成员方法，也可以是非静态的成员方法


	总结：静态可以访问静态，非静态可以访问一切

静态变量和成员变量的区别

静态变量和成员变量的区别
所属不同
静态变量属于类，所以也称为类变量
成员变量属于对象，所以也称为实例变量（对象变量）
内存中位置不同
静态变量存储于方法区的静态区
成员变量存储于堆内存
内存出现世界不同
静态变量随着类的加载而加载，随着类的消失而消失
成员变量随着对象的创建而存在，随着对象的消失而消失
调用不同
静态变量可以通过类名调用，也可以通过对象调用
成员变量只能通过对象名调用

main方法的格式详细解释

main方法的格式讲解：
public static void main(String[] args){…}

public:公共的，访问权限是最大的。由于main方法是被jvm调用，所以权限要够大
static：静态的，不需要创建对象，通过类名就可以。方便jvm的调用
void：因为我们曾经说过，方法的返回值是返回给调用者，而main方法是被jvm调用。你返回内容给jvm没有意义
main:是一个常见的方法入口。我见过的语言都是以main作为入口
String[] args:这是一个字符串数组。值去哪了？
	这个东西到底有什么用？怎么给值
	这个东西早期是为了接收键盘录入的数据的
	格式是：
		java MainDemo hello world java

总结

1.成员变量和局部变量的区别
（1）在类中的位置不同
成员变量：类中方法外
局部变量：方法定义中或者声明上
（2）在内存中的位置不同
成员变量：在堆中
局部变量：在栈中
（3）声明周期不同
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
（4）初始化值不同
成员变量：有默认值
局部变量：没有默认值，必须定义，赋值，然后才能使用
2.类作为形式参数的问题？
（1）如果你看到 一个方法需要的参数是一个类名，就应该知道这里实际需要的是一个具体的对象
3.匿名对象
（1）没有名字的对象
（2）应用场景
A:调用方法，仅仅只调用一次的时候
B:可以作为实际参数传递
4.封装
（1）隐藏实现细节，提供公共的访问方式
（2）好处：
A:隐藏实现细节，提供公共的访问方式
B:提高代码的复用性
C:提高代码的安全性
（3）设计原则
把不想让外界知道的实现细节隐藏起来，提供公共的访问方式
（4）private是封装的一种体现
封装：类（例如：class Dog类中下面的部分，有成员变量成员方法，是一个大的封装），
方法:(例如：public static void…下面包含的部分就是一个小的封装)
private修饰成员变量；
5.private关键字
（1）私有的意义，可以修饰成员变量和成员方法
（2）特点：
被private修饰后的成员只能在本类中被访问
（3）private的应用
以后再写一个类的时候：
把所有的成员变量给private了
提供对应的getXxx()/setXxx()方法
6.this关键字
（1）代表当前类的引用对象
记住：哪个对象调用方法，该方法内部的this就代表那个对象
（2）this的应用场景：
A:解决了局部变量隐藏成员变量的问题
B:其实this还有其他的应用
7.构造方法
（1）作用：用于对对象的数据进行初始化
（2）格式：
A:方法名和类名相同
B:没有返回值类型，连void都没有
C:没有返回值
在任何的void类型的方法的最后都可以写上：return;(代表结束方法)
（3）构造方法的注意事项
A:如果我们没有写构造方法，系统将提供一个默认的无参构造方法
B:如果我们写了构造方法，系统将不在提供参构造方法
如果这个时候我们想用无参构造方法，就必须自己给出
推荐永远自己手动给出无参构造
（4）给成员变量赋值的方式
A:setXxx()
B:带参构造方法
8：代码：Student s = new Student(0；做了哪些事情？
（1）把Student.class文件加载到内存
（2）在栈内存为s开辟空间
（3）在堆内存为学生对象申请空间
（4）给学生的成员变量进行默认初始化：null，0
（5）给学生的成员变量进显示初始化。（赋值）
（6）通过构造方法给成员变量进行初始化。（赋值）
（7）对象构造完毕，把对峙赋值给s变量
9.static关键字
（1）静态的意思。可以修饰成员变量和成员方法
（2）静态的特点
A:随着类的加载而加载
B：优先于对象存在
C:被类的所有对象共享
这其实也是我们判断该不该使用静态的依据
D:可以通过类名调用
既可以通过对象名调用，也可以通过类名调用，建议通过类名调用
（3）静态的内存图
静态的内容在方法区的静态区
（4）静态的注意事项：
A:在静态方法中没有this对象
B:静态只能访问静态
（5）静态变量和成员变量在的区别
A:所属不同
静态变量：属于类，类变量
成员变量：属于对象，对象变量，实例变量
B:内存位置不同
静态变量：方法区的静态区
成员变量：堆内存
C:声明周期不同
静态变量：静态变量是随着类的加载而加载，随着类的消失而消失
成员变量：成员变量是随着对象的创建而存在，随着对象的消失而消失
D:调用不同
静态变量：可以通过对象名调用，也可以通过类名调用
成员变量：只能通过对象名调用
（6）main方法是静态的
public：权限最大
static：不用创建对象调用
void：返回值给jvm没有意义
main：就是一个常见的名称
String[] args：可以接收数据，提供程序的灵活性
格式：java MainDemo hell word java
java MainDemo 10 20 30（也当作字符串输出）