Java基础Day07

day07

1. 面向对象思想
   1.1 面向对象的概念
2. 面向对象 : 就是Java的一种编程思想

面向过程: 现在需要做一个功能,想法就是我如果实现这个功能,主要关注的是实现过程
面向对象: 现在需要做一个功能,想法就是让谁去做

打扫卫生:
面向过程思考: 我该怎么打扫,先摆凳子,扫地,拖地,关空调,关窗…
面向对象思考: 我让xx同学打扫卫生

2. 面向过程与面向对象之间的关系
   面向对象基于面向过程,其实面向过程就是面向对象的基础,单单就开发思想来说,面向对象的思想,更加高级

3. 面向对象好处

1. 更符合人类的思维方式,有事情找到别人帮你实现,自己轻松
2. 面向对象将复杂的问题简单化
3. 由实施者变成了指挥者

4. 面向对象的特征
5. 封装
6. 继承
7. 多态

1.2 类与对象的关系
Java中的很多功能,都是在一些类中实现的
类 : 就是事物的一个抽象的概念,抽象的表示方式
抽象 : 无法准确描述的,无法形容的
举例 : 玩具模型 -----> 抽象存在-----> 类

对象 : 就是事物的具体表现方式,也是类的具体的表现方式
举例 : 超级玛丽玩具-----> 具体存在-------> 对象
皮卡丘 ------> 具体存在 ------> 对象
蓝精灵 -----> 具体存在 ------> 对象

1.3 类的组成
类: 就是一些列的属性和功能的集合,举例 : 人类

1. 属性 : 用于对类的特征,特性进行的描述
   人类 : 姓名和年龄,就是属性的存在
   在Java中,属性都是通过成员变量的方式来进行表示,成员变量与普通的变量定义方式一致,但是在类中定义的位置不同,成员变量定义在类中方法外的位置
2. 功能 : 方法,指具有指定的一些功能的集合
   注意 : 现在定义方法,可以不与main方法的修饰符保持一致, 之前使用public static
   现在可以将static去掉,只要一个public即可
   人类功能 : 吃饭,睡觉,工作,学习…

代码
// 类的定义 : 1) 成员变量(类具有的特征) 2) 功能
public class Person{
// 1. 定义成员变量: 数据类型 变量名 = 变量值 ;
// 成员变量,定义在类中方法外
String name = “zhangsan”;
int age = 20;

// 2. 定义方法
public void work(){
  System.out.println("人类可以工作");
}

public void eat(){
  System.out.println("人类需要吃饭");
}

}

1.4 对象的创建和使用

1. 对象的创建
   公式:
   类名 对象名 = new 类名(); // Random ran = new Random();
   解释说明:
   类名 : 类是一种引用数据类型,上面定义的Person类,那么Person现在就是一个引用数据类型, 相当于告知对象的类型是什么
   对象名 : 就是一个名字,起名字的时候,符合标识符的规范
   = : 赋值运算符, 表示将引用数据类型在内存中的地址值赋值给等号左边的对象名(所有的引用数据类型创建对象,都是在堆内存中开辟的空间,变量名就是对这个地址空间的引用)
   new : 关键字,表示新建,表示创建对象,在堆内存中,给数据类型开辟空间
   类名 : 与前面的类名保持一致
   () : 表示调用了类的构造方法

2. 对象的使用
   对象名.属性 : 调用了类中的指定的属性

1. 属性的获取 : 变量 = 对象名.属性
2. 属性的修改 : 对象名.属性 = 值
   对象名.方法() : 调用了类中的指定的功能

举例 : ran.nextInt();

代码
// 用于测试Person类的使用过程
public class TestPerson{
public static void main(String[] args) {
// 1. 创建一个Person对象
// 类名 对象名 = new 类名();
Person p = new Person();

   // 2. 使用对象
    // 1) 获取到类中的属性 : 对象名.属性
    String name = p.name ;
	int age = p.age ;

    System.out.println(name+"-----"+age);

   // 2) 给类中的属性赋值: 对象名.属性 = 值
   p.name = "QQ";
   System.out.println(p.name);

   // 3) 调用类中方法
   p.eat();
   p.sleep();
   p.work();   
}

}

练习:
定义一个汽车类,有颜色(color),轮胎个数(num),功能为跑: run()
要求 : 汽车在实现跑的功能时,显示汽车的颜色和轮胎个数

在测试类中,创建汽车对象,修改成员变量的值,调用run方法

代码
// 定义一个汽车类
public class Car{
/*
定义一个汽车类,有颜色(color),轮胎个数(num),功能为跑: run()
要求 : 汽车在实现跑的功能时,显示汽车的颜色和轮胎个数

分析 : 颜色(color),轮胎个数(num)----> 汽车的属性----> 成员变量
       功能为跑: run()----> 方法
*/

// 1. 成员变量定义,可以不赋值
// 2. 成员变量的作用范围,自变量定义之后器,可以在整个类中使用
// 3. 类中的成员变量,创建这个类的对象时,JVM虚拟机为类中
// 的所有的成员变量,进行一个默认的赋初值动作
// 根据类中的成员变量的类型不同,赋的初值也不同
// 1) 引用数据类型,默认赋值null
// 2) int类型 ,默认值0
// 3) double类型 , 默认0.0
// 4) char 类型 ,默认为空,什么都没有
// 5) boolean类型 , 默认为false
String color ;
int num ; 

public void run(){// 3. 类中的方法可以使用类中的成员变量的
   System.out.println("颜色为"+color+"的汽车有"+num+"个轮胎在跑");
}

}

// 测试汽车类
public class TestCar{
public static void main(String[] args) {
// 在测试类中,创建汽车对象,修改成员变量的值,调用run方法
// 1. 创建一个汽车对象
Car c = new Car();
// 注意: 1. Car类中成员变量没给值,但是可以正常使用
// 2. String类型的color ,结果为null; int类型num结果为0
System.out.println(c.color);// null
System.out.println(c.num);// 0

   // 2. 修改成员变量的值
   c.color = "red";
   c.num = 4 ;

   // 3. 调用run方法
   c.run();// 颜色为red的汽车有4个轮胎在跑   
}

}

1.5 类在内存中的运行过程
一. 类在内存中的运行过程

内存中的区域功能划分

1. 方法区或数据共享 : 加载类的.class文件
2. 栈内存 : 类中的方法在栈内存中运行
3. 堆内存 : 代码中引用数据类型创建对象,在堆内存中开辟空间

类的创建和使用在内存中的运行过程

1. 先将类的.class文件加载进内存,到了方法区或数据共享
2. 运行main方法,因为main方法作为程序的唯一执行入口,main方法进入到栈内存中运行
   ,main中的代码,从上到下一行一行执行
3. Car c = new Car ();

1. new 关键字,在堆内存中开辟一开内存空间
2. 类中的所有的属性(成员变量),跟随着类的创建进入到堆内存中
3. JVM给堆内存中的所有的成员变量进行赋初值的动作
   引用数据类型,默认赋值null
   int类型 ,默认值0
   double类型 , 默认0.0
   char 类型 ,默认为空,什么都没有
   boolean类型 , 默认为false
4. 将类在堆内存中的地址值,返回给对象的引用

4. 通过对象名.调用类中的方法和属性,因为对象名就表示类对象在内存中的空间地址

二. 在类中定义多个对象,其运行过程

代码
// 创建多个对象
public class TestCar2{
public static void main(String[] args) {
// 1. 创建Car对象
Car c = new Car();
System.out.println©;
c.color = “red”;
c.num = 6 ;
c.run();// red … 6

	// 2.创建Car对象
	Car c1 = new Car();
	// 说明 : 引用数据类型,每次new创建对象,都是在内存中开辟新的空间
	System.out.println(c1);
    c1.run();// null ... 0 

	// 3. 创建一个Car对象
Car c2 = c ;// 赋值,将c的内存地址,赋值给c2变量,现在c2 和 c指向同一块内存空间
	c2.run();// red...6
}

}

1.6成员变量和局部变量的区别
1.6.1 成员变量和局部变量在内存中的存储
成员变量 : 指定义在类中,方法外的变量
局部变量 : 指定义在方法中的变量,方法的参数也属于局部变量

代码
// 成员变量和局部变量的区别
public class BianLianDemo{
// 1. 定义了一个int类型的成员变量
int i = 9 ;

  public void function(){
     int i = 15;
	 System.out.println(i);
  }

  public static void main(String[] args) {
     BianLianDemo b = new BianLianDemo();
	 System.out.println(b.i);// 9
	 b.function();// 15  
  }

}

成员变量和局部变量在内存中的存储:

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

1. 定义位置不同
   成员变量 : 定义在类中,方法外
   局部变量 : 定义在方法中

2. 在内存中存储位置不同
   成员变量 : 跟随着对象的创建(new)进入到堆内存中
   局部变量 : 跟随着方法进入到栈内存中

3. 生命周期不同(谁使用的时间长)
   成员变量 : 生命周期比较长, 当创建的对象,不再使用时,对象在内存中变成垃圾,等着者被回收掉
   局部变量 : 生命周期相对比较短,当方法进栈运行,局部变量出生,当方法运行完毕,方法弹栈死亡,局部变量也一起消亡

4. 初始化值
   成员变量 : 使用是,可以不赋值,在创建类对象时,JVM给类中的成员变量进行默认的赋初值动作
   局部变量 : 要是用,一定是需要先赋值.JVM不会给局部变量赋值

1.7匿名对象
匿名对象 : 匿名----> 表示没有名字
一个没有名字的对象,称为匿名对象

定义方式:

1. 正常创建对象 : Person p = new Person();// p就是对象名
2. 匿名对象 : new Person(); 使用方法 : new Person().eat();
   匿名对象的解释 :

1. 匿名对象仍然在堆内存中开辟空间
2. 匿名对象类Person中的成员仍然进内存,JVM仍然赋初值
3. 匿名对象在堆内存中也是有地址返回的

注意事项 : 匿名对象只能使用一次, 例如: 调用一次类中的属性或者是调用类中的方法

匿名对象的优缺点:

1. 优点 : 节省内存空间, 当使用匿名对象时,如果匿名对象使用了一次,那么这个匿名的对象马上就会变成垃圾,就等待被回收
2. 缺点 : 只能用一次

如果针对于类中的方法或者是属性,只需要使用一次,可以使用匿名对象完成,否则正常创建逻辑进行调用

代码
// 匿名对象的使用
public class NiMingDuiXiang{
public static void main(String[] args) {
// 1. 创建一个匿名对象,调用类中方法
new Person().eat();
// 2. 创建一个匿名对象,调用类中属性
System.out.println(new Person().name);
}
}

1.8 基本数据类型作为参数传递

1. 基本数据类型,作为参数传递,方法内部修改基本数据的值,方法执行结束,改变没有被遗留下来
   
   

1.9 引用数据类型作为参数传递

代码

// 基本数据类型作为参数传递
public class ParamJiben {
public static void main(String[] args) {
//int x = 5;
//getNumber(x);
//getNumber1(x);
//x = getNumber1(x);
// System.out.println(x);// 10

    Person p = new Person();
	getPerson(p);
	System.out.println(p.name);// 李四

}

	// 3. 引用数据类型作为方法的参数传递
public static void getPerson(Person p){
	// 方法中可以使用p
	System.out.println(p.name);//zhangsan
	p.name = "李四";

}

// 1. 基本数据类型作为方法的参数传递,没有返回值
public static void getNumber(int a){
    // 方法内部,可以使用参数a
	a = 10; // 赋值
    System.out.println(a);// 10
}

// 2. 基本数据作为方法的参数传递,有返回值
public static int getNumber1(int a){
    // 方法内部,可以使用参数a
	a = 10; // 赋值
    System.out.println(a);// 10
	return a ;
}

}

// 类的定义 : 1) 成员变量(类具有的特征) 2) 功能
public class Person{
// 1. 定义成员变量: 数据类型 变量名 = 变量值 ;
// 成员变量,定义在类中方法外
String name = “zhangsan”;
int age = 20;
}

2. 封装
   2.1 封装的概念
   封装: 面向对象的一大特征,指隐藏事物的实现细节(实现过程),对外提供公共的访问方式

举例 : 抽奖,有一个箱子,里面装了很多奖品,可以抽取,只能伸手进去摸奖品出来(隐藏事物的实现细节), 箱子上面留存的抽奖入口,可以理解为公共访问方式

封装的优点:

1. 提高代码的安全性
2. 提高代码的复用性

2.2 private关键字
private : 关键字,修饰符,表示私有的,私密的

private 可以修饰:

1. 修饰成员变量
2. 修饰方法
3. 修饰构造方法

使用了private修饰的成员,只能在当前类中使用,在其他类中不能使用

private私有的概念,只是面向对象中封装特性的其中一种表现方式
2.3 Settet和Getter 方法

1. private关键字修饰的成员,只能在当前类中使用,无法再外类中使用,于是需要对外提供公共的访问方式,针对于使用private修饰的成员变量,提供对应的set和get方法,作为对外的公共访问途径
2. 实际开发中,类中属性基本上都是使用private进行修饰的, 再给属性提供对应的set和get方法

代码
public class Student{
// 学生学号,成员变量
String id ;
// 学生年龄,使用private修饰,那么就只能在Student类中应用
private int age;

// 定义一个方法,就为了给age变量赋值
public void setAge(int a){

  if( a >= 0 && a <= 100){
	  // 给成员变量age进行赋值
      age = a;
  }else{
      System.out.println("输入年龄有误,设置年龄为默认值20");
	  age = 20;
  }	
}

// 定义一个方法,就是为了获取到age的值
public int getAge(){
  return age;
}

}

public class TestStudent{
public static void main(String[] args) {
// 1. 创建一个Student对象
Student s = new Student();
// 正常人类年龄,0-100
/*
分析: 1. 需要输入的人的年龄,必须要符合标准,0-100
2. 控制年龄的输入数据的范围,想法 : 不让客户直接输入年龄,那么就将年龄
成员变量,使用private修饰
使用private修饰的成员变量age,只能在Student类的内部使用
3. 在Student类中,提供age变量的公共的访问方式
*/
// s.age = 20;
s.setAge(89);
int age = s.getAge();
System.out.println(age);// 20
}
}

2.4变量的就近访问原则和this关键字
2.4.1变量的就近访问原则
确定变量在实际的运行当中,访问(使用)规则
访问的原则 : 在进行变量使用时,哪个变量离的最近,优先使用哪个变量

代码
// 变量的就近访问原则
public class BianLiangFangWen{

// 1. 定义一个成员变量
int i = 10 ;

public void getI(){
    // 2. 定义一个局部变量
	int i = 99 ;
    System.out.println(i);// 99 ,变量的就近访问原则,变量在使用时,哪里变量距离最近,使用哪个

}
public static void main(String[] args) {
	// 3. 创建一个对象
    BianLiangFangWen bw = new BianLiangFangWen();
	bw.getI();
}

}

2.4.2 this关键字
this : 关键字, 表示本类对象的引用
分析 : this 关键字,表示本类对象的引用
解释: 本类 BianLiangFangWen
对象 new BianLiangFangWen()
this.i 相当于 new BianLiangFangWen().i-----> 调用的是成员变量的i值
结论: 如果变量之前有this关键字,那么这个变量就表示成员变量

this关键字的第一个使用方式 : 用于区分成员变量和局部变量,加有this关键字的变量就表示成员变量

代码
// 变量的就近访问原则
public class BianLiangFangWen{

// 1. 定义一个成员变量
int i = 10 ;

public void getI(){
    // 2. 定义一个局部变量
	// 99 ,变量的就近访问原则,变量在使用时,哪里变量距离最近,使用哪个
	int i = 99 ;

	// 要求: 在成员变量int i = 10 以及局部变量int i= 99 同时存在的基础上,如何做到
	// 方法中打印出的i值的结果为成员变量10
	// 解决方案 : 在变量之前添加一个this关键字
	/*
	   分析 : this 关键字,表示本类对象的引用
	          解释: 本类 BianLiangFangWen
			        对象 new BianLiangFangWen()
	   this.i 相当于  new BianLiangFangWen().i-----> 调用的是成员变量的i值
	   结论: 如果变量之前有this关键字,那么这个变量就表示成员变量
	
	*/
    System.out.println(this.i);
}

public static void main(String[] args) {
	// 3. 创建一个对象
    BianLiangFangWen bw = new BianLiangFangWen();
	bw.getI();
}

}

this关键字,在set方法中的使用
public class Student{
// 学生学号,成员变量
String id ;
// 学生年龄,使用private修饰,那么就只能在Student类中应用
private int age;

// 定义一个方法,就为了给age变量赋值
/*
  私有的成员变量,需要提供对应的set和get方法
  但是,方法的参数名称与成员变量的名称保持一致的
  为什么要让成员变量和局部变量重名:
 1) 每次起不同的名字,比较繁琐
 2) 开发工具中,eclipse,idea,都有自动的生成set和get方法的方式,工具自动生成的代码
   全部都是局部变量与成员变量重名,需要在set方法中使用this关键字

*/
public void setAge(int age){

  if( age >= 0 && age <= 100){
	  // 给成员变量age进行赋值
      this.age = age;
  
  }else{
      System.out.println("输入年龄有误,设置年龄为默认值20");
	  this.age = 20;
  }	
}

// 定义一个方法,就是为了获取到age的值
public int getAge(){
  return age;
}

}