Java面向对象,成员变量,局部变量,引用类型,匿名对象,封装,this关键字,构造方法,标准类,成员方法,static关键字,文档说明书,代码块

面向对象思维特点

面向对象的本质是基于面向过程!
1)更符合生活中的思想行为习惯
2)让我们从执行者变成指挥者
3)让复杂的事情简单化

面向对象的设计原则

不断的创建对象,使用对象,指挥对象做事情!

创建一个对象的内存图解

面向对象举例

/*
手机事物
		属性:品牌,价格,颜色,内存
		行为:打电话,发短信,玩游戏...
		
定义一个手机类:描述手机事物

		成员变量:
				brand,price,color,memory
				callPhone(),sendMsg(),playGame()..
*/
class Phone{
   

	//成员变量...
	String brand; //品牌
	double price ; //价格
	String color ; //颜色
	int memory ; //内存
	
	//成员方法
	//去掉static
	public void callPhone(){
   
		System.out.println("手机可以打电话") ;
	}
	
	public void sendMsg(){
   
		System.out.println("手机可以发短信...") ;
	}
	public void playGame(String name){
    //局部变量
		System.out.println("使用手机可以玩"+name) ;
	}
}


//测试类
class PhoneTest{
   
	public static void main(String[] args){
   
		//创建手机类对象
		//类名 对象名 = new 类名() ;
		Phone p = new Phone() ;
		System.out.println(p) ;
		System.out.println(p.brand+"---"+p.price+
					"---"+p.color+"---"+p.memory) ;
		//成员变量赋值
		//对象名.成员变量= 值;
		p.brand = "华为mate30 pro" ;
		p.price = 5699.0 ;
		p.color = "翡翠绿";
		p.memory = 128 ;
		System.out.println(p.brand+"---"+p.price+
					"---"+p.color+"---"+p.memory) ;
		System.out.println("------------------------");
		//对象名.成员方法名() ;
		p.callPhone();
		p.sendMsg() ;
		p.playGame("csgo") ;
					
	}
}

class Phone2{
   

	//成员变量...
	String brand; //品牌
	double price ; //价格
	String color ; //颜色
	int memory ; //内存
	
	//成员方法
	//去掉static
	public void callPhone(){
   
		System.out.println("手机可以打电话") ;
	}
	
	public void sendMsg(){
   
		System.out.println("手机可以发短信...") ;
	}
	public void playGame(String name){
    //局部变量
		System.out.println("使用手机可以玩"+name) ;
	}
}
//测试类
class PhoneTest2{
   
	public static void main(String[] args){
   
		//先创建两个手机类对象,分别去给成员变量赋值
		//在将第一个手机类对象赋值给第三个手机对象名 
		//给第三个手机对象的成员变量赋值,输出第一个手机对象的成员变量
		
		Phone2 p1 = new Phone2() ;
		p1.brand = "Iphone12" ;
		p1.price = 4999.0 ;
		p1.color = "土豪金" ;
		p1.memory = 128 ;
		System.out.println(p1.brand+"---"+
		p1.price+"---"+p1.color+"---"+p1.memory) ;
		System.out.println("------------------------") ;
		
		//创建第二个手机类对象
		Phone2 p2 = new Phone2() ;
		p2.brand = "华为p40" ;
		p2.price = 8999.0 ;
		p2.color = "深空灰" ;
		p2.memory = 218 ;
		System.out.println(p2.brand+"---"+
		p2.price+"---"+p2.color+"---"+p2.memory) ;
		
		System.out.println("------------------------") ;
		
		//将一个手机类对象赋值p3
		Phone2 p3 = p1 ;
		p3.brand = "锤子" ;
		p3.price = 2999.0;
		p3.color = "红色";
		p3.memory = 64 ;
		System.out.println(p1.brand+"---"+
		p1.price+"---"+p1.color+"---"+p1.memory) ;
		
		
	}
}

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

/*
	面试题:
	
		成员变量和局部变量的区别?
		
		1)书写位置不同
			成员变量:在类中,方法外定义的变量!
			局部变量:在方法声明上或者是方法定义中!
					public void show(String name){
						int num = 200 ;
						System.out.println(name+num) ;
					}
					
		2)内存中的位置不同
			成员变量:在堆内存中
			局部变量:在栈内存中
			
			
		3)生命周期不同:
			局部变量:随着方法调用而存在,随着方法调用完毕而消失!
			成员变量:随着对象的创建完毕而存在,随着对象被GC回收掉而消失
											对象的回收:
											并不是立即回收,而是等待垃圾回收器空闲时回收掉!
		
		4)初始化不同:
			成员变量:可以不进行初始化,因为它在堆内存中(跟对象有关系),存在系统默认初始化
			局部变量:必须在使用之前对象局部变量进行初始化,否则报错"可能尚未初始化变量xx"

*/

//定义一个类:Variable
class Variable{
   
	
	
	//成员变量:类中,方法外
	int num ;
	int num3 = 100 ; //成员变量:直接赋值了
	
	
	//成员方法
	public void show(){
   
		int num2 = 200 ;
		System.out.println(num2) ;
		System.out.println("------------------") ;
		System.out.println(num) ;
		System.out.println(num3) ;
	}
	
	public void method(){
   
		int i  ; //定义了
		i = 10 ;
		
		//在使用之前必须初始化 
		System.out.println(i) ;//可能尚未初始化变量i
		
		
	}
}


//测试类
class VariableDemo{
   
	public static void main(String[] args){
   
		
		//需求:要访问Variable中的num变量?
		//创建Variable类的对象
		Variable v = new Variable() ;
		System.out.println(v.num) ; //系统默认初始化
		
		v.show();
		System.out.println("---------------------") ;
		v.method();
	}
}

形式参数是基本类型以及引用类型(类)的情况

/*
	方法的形式参数是基本类型:
		形参的改变对实际参数没有影响(是什么类型,传递对应的数据值即可!)
		
		
	

*/
//定义一个Demo类
class Demo{
   
	
	//定义一个两个数据求和的功能
	//成员方法
	public int sum(int a,int b){
    //形式参数是基本类型
		
		return a + b ;
	}
}



//测试类
class ArgsDemo{
   
	public static void main(String[] args){
   
		//需要访问Demo类中的sum方法
		//创建Demo类的对象
		//对象名.成员方法名();
		Demo d  = new Demo() ;
		int result = d.sum(10,20) ;//实际参数 :(形式参数都int类型)
		System.out.println("result:"+result) ;
	}
}

/*

Java最终研究的就是引用类型!
方法的形式参数是引用类型:  形式参数的改变:会直接影响实际参数!
		数组,类,接口
		
		
		之前:数组{1,2,3,4,5}					
		int[] arr = new int[]{元素1,元素2....} ;
			public  static void change(int[] arr){ //形式参数是一个数组
					for(int x = 0 ; x < arr.length ; x ++){
						if(arr[x] % 2 == 0){
							arr[x] *= 2 ;
						}
					}
			}
			
		现在形式参数是一个类:(具体类)
		
*/
//定义一个学生类
class Student{
   
	//定义一个成员方法
	public void study(){
   
		System.out.println("Good Good Study,Day Day Up!!") ;
	}
}
//定义一个StudentDemo类
class StudentDemo{
   
	
	//定义一个method成员方法
	public void method(Student s){
   //形式参数是一个引用类型   
						//实际参数传递的时候:需要改学生类的具体对象 Student student = new Student() ;
		s.study() ; //分析:变量名.成员方法() ;前面这个变量代表当前学生类的对象
	}
}
//测试类
class ArgsDemo2{
   
	public static void main(String[] args){
   
		//需求:需要访问StudentDemo类中的method方法
		//1)创建StudentDemo类的对象
		StudentDemo sd = new StudentDemo() ;
		
		//创建一个具体的学生对象
		//student:实际参数
		Student student   = new Student() ;
		sd.method(student) ;
	}
}

匿名对象

/*
	匿名对象:
		
			概念:没有名字的对象!
			
			之前的格式:
				类名  对象名 = new 类名() ;
				
			匿名对象的创建格式:
					new 类名() ;
					
			特点:
				1)可以作为形式参数传递!
				2)匿名对象不要使用多次,使用一次即可!
					匿名对象,应用场景:
							移动端:android 大量去使用匿名对象  或者匿名内部类
								
					匿名对象创建完毕,使用完毕就立即被回收(节省内存空间)
					
					
*/
//有一个学生类
class Student{
   
	public void love(){
   
		System.out.println("爱学习,爱Java...") ;
	}
}

//定义一个类:StudentDemo
class StudentDemo{
   
	public void method(Student s){
   
		s.love<