Java学习日志Day7_键盘录入_引用类型_面向对象_局部变量与成员变量_匿名对象

一、键盘录入的三种形式

键盘录入有三种方式
1)早期的 main(String[] args)
String[]:字符串数组
args:形式参数名

弊端:只能接收字符串

	javac Demo.java		---- >Demo.class
	java Demo hello world java

2)方式2:JD5以后使用的:Scanner:文本扫描器

	导包:import java.util.Scanner;

3)第三种方式:利用的BufferedReader:字符缓冲输入流 (IO流部分)
功能:readLine() :读取一行内容

	java.io.BufferedReader;

举例：
class Demo{
	public static void main(String[] args){
		 System.out.println(args.length) ;
		 for(int x = 0 ; x < args.length ; x ++){
			System.out.println(args[x]) ;
		 }
		
	}
}

二、引用类型(数组)作为参数传递和基本类型作为参数传递的区别

方法的形式参数传递:
1)基本数据类型作为参数传递:四类八种

形式参数的改变不影响实际参数!

2)引用类型作为参数传递:数组,类,接口

形式参数改变会直接影响实际参数(String除外,它作为参数传递和基本类型作为参数传递效果一致!)
String特点:字符串是常量

举例：
class ArgsDemo{
	public static void main(String[] args){
		//定义两个变量a,b
		int a = 10 ;
		int b = 20 ;
		
		System.out.println("a:"+a+",b:"+b) ;//10,20
		
		change(a,b) ;
		
		System.out.println("a:"+a+",b:"+b) ;//10,20
		
		System.out.println("---------------------------") ;
		
		//创建一个数组,静态初始化
		int[] arr = {1,2,3,4,5} ;
		System.out.println(arr[3]) ; //4
		change(arr) ;
		System.out.println(arr[3]) ; //8
		
		System.out.println("---------------------------") ;
		
		//String作为引用类型(特殊的引用类型)作为参数传递
		String s = "hello" ;
		System.out.println(s) ;
		change(s) ;
		System.out.println(s) ;
		
	}
	
	public static void change(String s){
		System.out.println(s) ;
		s += "gaoyuanyuan" ;
		System.out.println(s)  ;
	}
	
	//重载的change方法
	public static void change(int[] arr){
		//遍历数组
		for(int x = 0 ; x < arr.length ; x ++){
			if(arr[x] % 2 ==0){
				arr[x] *= 2 ;
			}
		}
	}
	
	
	public static void change(int a,int b){
		System.out.println("a:"+a+",b:"+b) ;//10,20
		a = b ; // a = 20 
		b = a + b ; // b = 20 + 20 = 40 
		System.out.println("a:"+a+",b:"+b) ;//20,40
	}
	
}

三、面向对象

1.面向对象的思想：面向对象是基于面向过程的!
面向过程:：从需求分析,到业务逻辑,以及结果输出:整个过程都是自己完成(自己是一个执行者!)

需求: 键盘录入三个数据,使用功能改进,求三个数据中最大值!
		1)分析:导包 
		2)创建键盘录入对象Scanner
		3)提示并录入数据
		4)定义一个功能(方法)
			4.1)分析:明确返回值类型/明确参数类型以及参数个数
			
			4.2)方法中业务逻辑:if...else... /三元运算符操作
		5)调用方法
		6)输出结果

举例:
		生活的例子 (生活中处处都是对象)
面向过程:
		买电脑
		自己关注哪些配置--->去赛格电脑城--->砍价--->付费--->发现被坑了 ---->买回来
		
		洗衣服
		有一些脏衣服--->使用洗衣盆放入洗衣液--->接水--->泡一泡--->搓一搓--->甩一甩--->拧一拧--->晾衣服
		
面向对象:
		买电脑
		关注哪些配置---->找一个懂行的朋友---->买到电脑
		洗衣服:
		有一些脏衣服--->全自动洗衣机(一键)/找一个对象--->晾衣服

2. 面向对象的思想特点:
   1)让复杂的事情简单化
   2)让我们从执行者变成了指挥者(角色发生了变化)
   3)更符合我们生活中的思想行为习惯…

3. 面向对象的设计原则 :
   在不断的创建对象,使用对象,指挥对象做事情

    举例:	键盘录入Scanner
    		创建文本扫描器对象,使用这个对象录入int类型,double,String类型等等一些数据
    		然后完成相应的操作!
   

赵本山---->“将大象装进冰箱”

面向过程思想:
		伪代码
		
				class Demo{
					public static void main(String[] args){
						open() ;
						in();
						close() ;
						
					}
					
					
					//定义功能:冰箱的开门
					public static void open(){
						System.out.println("打开冰箱门...") ;
					}
					//将大象装进去的功能
					public static void in(){
						System.out.println("将大象装进去...") ;
					}
					//定义:关闭冰箱门
					public static void close(){
						System.out.println("关闭冰箱门...") ;
					}
				}
	
面向对象:"将大象装进冰箱"
			名词提前法: 
				1)有哪些类(真实存在的事物)
					Demo:测试类
					大象类
					冰箱类
				2)有哪些方法(功能)
					大象
						进去的功能
					冰箱:
						开和关的功能
				不断的创建对象,使用对象,指挥对象做事情(功能的调用)
				class Demo{
					public static void main(String[] args){
						//创建冰箱类对象
						冰箱类对象.open() ;
						
						创建大象类对象
						大象类对象.in() ;
						冰箱类对象.close() ;
					}
				}
				
				class 大象类{
				
					public void in(){
						System.out.println("大象进去...") ;
					}
				}
				
				class 冰箱类{
					public void open(){
						System.out.println("开门...") ;
					}
					
					public void close(){
						System.out.println("关门...") ;
					}
				}

4. 面向对象的三大特征:
   封装 继承 多态

5. 类与事物的关系:
   事物:是能够描述现实世界中真实存在的泛指的东西

    		学生----->学生事物
   

Java中,最基本的单元是类:class
类:是能够描述一组事物的属性和行为的集合!

		学生事物
			属性:姓名,年龄,学号,班级,身高,性别...
			行为:主要都是学习,吃,睡,玩游戏...
			
			
		使用Java代码的方式描述上面的学生事物:
				
			定义一个类:学生类 class Student{}
							
							成员变量(在类中,方法外定义):name,age,stuId,gender,hight...
							成员方法:(去掉static关键字): 之前的方法怎么定义,现在还怎么定义,只是去掉static即可!	
										study(),eat(),sleep(),playGame()...
										
										
										
		长方形----->长方形事物
						属性:长和宽
						行为:周长和面积
						
						
					定义一个长方形类
						成员变量:length,width
						成员方法:getLength(),getArea()

6. 类和对象:
   类:一组事物的属性和行为的集合!

    	学生类 Student
    			对应的真实存在事物(泛指)			学生事物
    	对象:	描述的应该真实事物中的具体的!
    						学生事物
    							高圆圆(具体事物),20岁,喜欢lol
    							
    							
    				代码实现:
    				创建对象
    				
    				类名 对象名  = new  类名();
    				对象名.成员变量= 赋值
    				对象名.成员方法() ; 使用这个方法
   

/*
	学生事物:
			属型:姓名,年龄,性别,身高
			行为:学习,玩游戏...
			
			
	学生类:Student
			成员变量
			成员方法
			
	使用Java面向对象的编程方式:定义学生类并且在	StudentTest类中测试一下	
*/
class Student{
	
	//将学生事物的属性----定义为成员变量:类中,方法外
	String name ;//姓名
	int age ;//年龄
	String gender;//性别
	int hight ; //身高
	
	//学生事物的行为---->成员方法:去掉static
	public void study(){
		System.out.println("学习JavaSE...") ;
	}
	
	public void playGame(String gameName){//传递一个参数:游戏名称
			System.out.println("正在玩"+gameName) ;
	}
	
}

//学生类的测试类
class StudentTest{
	
	public static void main(String[] args){
		//测试学生类
		//创建一个对象(代表:具体的学生事物)
		//类名  对象名 = new 类名();
		Student student = new Student() ;
		System.out.println(student.name+"---"+student.age+"---"+student.gender+"---"+student.hight) ;
		
		//对象名.成员变量=赋值
		student.name = "高圆圆" ;
		student.age = 41 ;
		student.gender ="女" ;
		student.hight=182 ;
		System.out.println(student.name+"---"+student.age+"---"+student.gender+"---"+student.hight) ;
		//对象名.成员方法() ;
		student.study() ;
		student.playGame("吃鸡") ;
		
	}
}

四、局部变量与成员变量的区别

1)代码的书写位置不同
局部变量:在方法定义中或者是方法声明上的变量
成员变量:类中方法外

2)内存中的位置不同
局部变量:在栈内存中
成员变量:在堆内存中

3)生命周期不同
局部变量:随着方法调用而存在,随着方法的调用结束而消失!(使用完毕,立即消失了)
成员变量:随着类的加载而存在,随着类的加载完毕,等待垃圾回收器自动回收而消失!
(对象创建完毕,对象可能被继续使用,所以不会立即消失!)

4)初始化不同:
局部变量:定义的时候,使用前必须初始化; 要么就是直接初始化,不能没有初始化值!
成员变量:随着类的加载而存在,存在系统默认初始化,可以不直接赋值! 也可以赋值(不推荐)

class Variable{
	//成员变量
	int num = 10 ;
	
	
	public void show(){ //方法声明上
		//int a = 20 ;//方法定义中
		//System.out.println(a) ;
		//int b  ;没有赋值
		int b ;
		b = 10 ;
		System.out.println(b) ;
	}
}

//测试类
class VariableDemo{
	
	public static void main(String[] args){
		//需求:要访问Variable类中的num变量,如何访问
		//创建Variable类的对象访问
		//类名 对象名 = new 类名();
		Variable v = new Variable() ;
		System.out.println(v.num) ;
		v.num = 200 ;
		System.out.println(v.num) ;
		v.show() ;
	}
}

五、引用类型作为参数传递——类

基本类型作为形式参数传递,形式参数的改变不会影响实际参数!
引用类型在作为参数传递,形式参数的改变会直接影响实际参数!(除了String字符串之外)
数组,类,接口
类：具体类:实际参数传递需要的是该类的对象!(空间地址值)

//定义一个学生类
class Student{
	//定义一个成员方法
	public void study(){
		System.out.println("Good Good Study ,Day Day Up!!!") ;
	}
}

//定义一个类StudentDemo类
class StudentDemo{
	//有一个成员方法:method
	public void method(Student s){//形式参数是Student类型
		s.study() ;	// 形式参数变量s.study():s应该在传递----学生类的对象!
	}
} 
//测试类
class StudentTest{
	public static void main(String[] args){
		//需求:要访问StudentDemo类中method 方法如何访问?
		//创建StudentDemo类的对象
		StudentDemo sd = new StudentDemo() ;
		//method方法中的参数传递:实际参数需要的是Student的具体对象
		Student student = new Student();
		sd.method(student) ; //实际参数是什么?
	}
}

六、匿名对象：没有名字的对象!

1. 格式:
   new 类名() ;

2. 特点:
   1)开发中使用一次即可
   2)使用完毕,立即被回收,可以结束内存空间!
   这种写法针对:移动端: Android(考虑内存问题)
   3)作为参数传递

   pc端:推荐:
   类名 对象名 = new 类名() ;

class Student{
	//成员方法
	public void study(){
		System.out.println("爱生活,爱Java...") ;
	}
}

class StudentDemo{
	public void method(Student s){
		s.study() ;
	}
}

//测试类中
class NoNameDemo{
	public static void main(String[] args){
		//需求:访问StudentDemo类中method
		//分步骤:
		
		//创建StudentDemo类的对象
		StudentDemo sd = new StudentDemo() ;
		//创建一个具体的学生类对象
		Student student = new Student() ;
		sd.method(student) ;
		
		System.out.println("-----------------------") ;
		
		//链式编程
		//匿名对象(只限于自己玩,开发中正常使用有名字的对象)
		 new StudentDemo().method(new Student()) ;
		 
		
	}
}