java基础篇

面向过程:凡事必躬亲
面向对象:

懒人改变世界

十五字讲解面向对象:
1.服务员点单
2.万物皆对象
3.

Java的三大特性:封装,继承,多态

面向对象的三大特点:
1.更符合我们平时的思维习惯;
2.把复杂的问题简单化;
3.把我们从执行者变成指挥者;

服务员点单

Thinking in Java----->  万物皆对象

在面试中,面试官再问你关于解释面向对象思想的问题 如何作答??
	首先你要跟面试官去解释面向对象的三大特点;举例!!!-->现场的事物的案例;---
		--> 面试官您面试的这个过程 中间就涉及到了很多面向对象的思想(面试官您就是一个对象)
		面试官您进行面试招聘,肯定是因为公司有了项目开发的需求,老板调用您面试的功能,这是一个面向对象的思维;
		(1)凭借您的实力,您一个人搞定这个项目肯定是没有问题的!!但是您肯定还有一些管理更加有难度的工作需要去做,
		这时候您需要 招聘 一些   (2)具备开发功能的人 (3)比如我!!!  帮助您完成这个项目;
		
		
如何使用Java代码去表示生活中的一类事物呢(一个范围 不是指某个很明确的东西)		--->  类 (.java文件, class)

	当你定义了一个类:
		那么就是在使用了java代码去表示一类事物;
		public class Car{}   ---> 汽车
		public class Student{}  -->学生
		public class Teacher{} -->老师
		public class HelloWorld{}  -->HelloWorld这一类事物
		
			你每定义一个类,就是表示一类事物;
			
	类是这类事物的抽象!!!
	使用了类去表示一类事物, 如何去形容这类事物呢?
	     使用 属性和行为
		 属性:成员变量
		 行为:成员方法
		 
	public class Wife{
		//属性-->成员变量-->描述信息-->成员变量在定义的时候可以不需要赋值
		//年轻
		int age;
		//漂亮
		boolean beauty;
		//身材好
		boolean sexy;
		//行为-->成员方法  --->  功能   -->定义方法时  修饰符:public    把static去掉
		//修饰符 返回值类型 方法名(形式参数列表){方法体}
		//做饭
		public void zuoFan(){
			//媳妇如何做饭
		}
		//洗衣服
		public void xiYiFu(){
			//媳妇如何洗衣服
		}
	}
	
	Java使用类来描述一类事物, 使用 对象来表示具体的这类事物中的某个个体;
		类是这类事物的抽象,对象是这类事物的具体化!!!!!!!!!!!!!!
		
	如何造一个wife呢?
	格式:
		类名 对象名 = new 类名();
		Wife 迪丽热巴 = new Wife();
		
		迪丽热巴-->就是你new 出来的媳妇!!!
		十五字讲解面向对象:
			1.服务员点单
			2.万物皆对象
			3.对象调方法(对象调属性)   --->调: .
			//访问属性 -->对属性进行赋值
			迪丽热巴.age = 18;
			迪丽热巴.beauty = true;
			迪丽热巴.sexy = true;
		//	迪丽热巴.height = 175; -->没有的属性也是不可以调用的!!
			//访问行为  -->调用方法
			迪丽热巴.zuoFan();
			迪丽热巴.xiYiFu();
		//	迪丽热巴.shengHaiZi(); -->没有的行为是不可以调用的!!!
			
			
			
			
			
	public void function(Phone p){
		
	}
	
	public Phone function(){
		return p;//也是地址值
	}

	 使用方法的时候:
		若方法属于某个对象的话 使用对象调方法 
		Phone p = new Phone();
		对象名.function(p);//-->缺什么给什么  Phone p = p;-->接的是地址值
		
		
	引用数据传递一定传的是地址值!!!!
	
	
成员变量和局部变量的区别:
	1.类中的位置不同:
		成员变量:方法外,类中
		局部变量:方法中,方法的形式参数列表上,for循环的初始化语句,代码块中定义的变量
	2.在内存中的位置不同:
		成员变量:堆内存中
		局部变量:栈内存中
	3.初始化值不同:
		成员变量:系统会根据其数据类型给予相应的默认值
		局部变量:局部变量未赋值,不能直接使用;
	4.生命周期不同:
		成员变量:随着对象的产生而产生,随着对象的死亡而死亡;(等待垃圾回收机制空闲的时候回收)
		局部变量：随着方法的调用产生,随着方法的调用完毕随着方法弹栈而消失;
	5.在我们开发时,非常好用的一个点!!
		颜色不同!!!!-->编译器给与的颜色标识不同;
		成员变量:IDEA给的是 紫色!
		局部变量:IDEA给的是  黑色(变量使用了)/灰色(变量未使用)
		
	因果关系!!
		因为在 1.类中的位置不同  所以 2.在内存中的位置不同 又因为:2.在内存中的位置不同 导致 3.初始化值不同,4.生命周期不同:
	
	
	
	
		访问权限修饰符:public protected 不写 private
	
	
	private:私有的
	
	这是学习修饰符的学习方法!!!!
	可以修饰什么东西:成员变量,成员方法
	被修饰的东西具备什么样的特点:
		被修饰的成员变量只能在本类中使用;
		被修饰的成员方法只能在本类中使用;
		---> 被修饰的成员只能在本类中使用;
	
	
	
	
变量的就近原则:
	1.成员变量和局部变量的名称可以相同!!!
	
	
	
如何定义一个标准的事物描述类!!!
	1.编写成员变量(属性)--->属性一定要私有!!!
	2.编写无参的构造方法!
	3.编写全参的构造方法!
	4.提供相应的getXxx()/setXxx()方法!
	5.成员方法(行为,功能)--->有没有都可以,你先写就写,不想写拉倒!
	
	
如何使用呢?
	1.创建一个测试类!在测试类中编写main方法
	2.在main方法内,调用构造方法-->创建事物描述类的对象
	3.对象调方法!!!!!!!

面向对象的思想:
三大特点:
1.更符合我们平时的思维习惯;
2.把复杂的问题简单化;
3.把我们从执行者变成指挥者;
三大特性:
封装,继承,多态
面向对象十五字: 服务员点单–>万物皆对象–>对象调方法
类与对象之间的关系:
类是事物的抽象,对象是该类事物的具体化;

面向对象的代码: 4个重点,3个难点
1.第一个重点: 定义一个事物描述类,并使用;
//1.定义一个类
public class 类名{
//2.定义属性–>描述事物的信息–>所有的属性都是成员变量,所有的属性都要被private私有修饰
private 数据类型 属性名1;
private 数据类型 属性名2;
…
//3.定义无参构造方法—>
构造方法–>无参的!! -->快捷键 code–>generate–>Constructor -->select None
//4.定义全参构造–>
构造方法–>全参的!! -->快捷键 code–>generate–>Constructor -->全选–>点ok
//5.编写getters and setters
快捷键: alt+Insert–>快速的编写get/set方法 code–>generate–>getter and setter–>全选 -->点ok
//6.行为–>有行为就写,没行为就不写
}
//如何使用这个事物描述类了?
1.创建一个测试类,并在测试类中编写main方法;
2.在main方法中创建该类的对象(无参构造方法,全参构造方法);
3.对象调方法!!对象调属性!!

2.第二个重点和难点: this关键字
	this:本类对象的引用
	作用:可以使用this.属性名 -->访问成员位置上的变量!
	
	举例:  this相当于一面镜子,当有对象调方法(对象调属性)的时候,就相当于对象出现在了镜子面前;
		镜子里面的事物就是this代表的那个对象!!
	this可以干嘛!  调方法,调属性  -->对象能干什么this就可以干什么!
	
	变量的就近原则:
		1.若局部位置有同名的变量优先选择局部位置的同名变量;
		2.若非要使用成员位置上的该变量,使用 this.变量名 即可!!
		
	局部变量和成员变量的区别:
		1.在类中的位置不同:
			成员变量:类中方法外
			局部变量:方法内,方法的形式参数列表,for循环的初始化语句,代码块中;
		2.在内存中的位置不同:
			成员变量:堆内存
			局部变量:栈内存
		3.初始化值不同:
			成员变量:系统会根据其数据类型给予对应的默认值;
			局部变量:变量未赋值不能直接使用;
		4.生命周期不同:
			成员变量:随着对象的创建而产生,随着对象的死亡而死亡;
			局部变量:随着方法的执行而产生,随着方法的调用完毕而死亡;
		5.颜色不同:
			成员变量:IDEA中是紫色
			局部变量:IDEA中是灰色(未使用)/黑色(使用了)
	因果关系:
		因为 1.在类中的位置不同 所以 2.在内存中的位置不同
		有因为 2.在内存中的位置不同  导致 3.初始化值不同 和 4.生命周期不同
		
3.第三个重点和难点:
	private:权限修饰符
	可以修饰什么东西: 成员变量,成员方法(不建议修饰)
	作用:被修饰的成员具备什么样的特点
		被private修饰的成员只能在本类中访问,若要在其他类中访问被private修饰的成员
			--->我们需要提供相应的访问方法(getXxx()或者setXxx());
	
4.第四个重点和难点:
	构造方法的作用:
		1.提供多种创建对象的方式!
		2.可以在创建对象的同时给对象的属性进行赋值操作(含参构造能够完成)!
	格式:不用记
		public 类名(形式参数列表){
			//方法体-->大多情况 给成员变量赋值!
		}
	如何调用呢?
		创建对象既是调用相应的构造方法;
	创建对象倒地做了多少事情:
		类名 对象名 = new 类名(实参);
		1.创建了一个对象;
		2.若使用的是含参构造在创建对象的同时给成员变量赋值;
		3.在堆内存中开辟了空间;
	注意事项:
		1.若你在一个类中不写任何的构造方法,系统会默认赠送一个无参的构造方法;
			但是若你写了任意一个构造方法,默认送的无参构造就没有了;
		2.构造方法一定要和类名一致!!!且没有返回值类型!!!可以重载!!! --> 方便我们认出构造方法!!