面向对象

基于面向过程的一种思想
面向过程: 代表C语言,强调一个功能的步骤
面向对象: 代表Java语言, 强调对象的创建,使用对象调用功能
生活中处处都是面向对象

举生活的例子:

	面向过程:(自己就是执行者)
			
			买电脑
			 心里清楚电脑的配置----->去赛格电脑城购买电脑----->砍价----> 买到了电脑
			 
			洗衣服
			  
			  脱下脏衣服---->使用洗衣盆放入洗衣液,接水----->泡一泡---->搓一搓---->透一透-----
							拧一拧---->晾一晾 
							
			炒菜
				去买菜---->砍价---->挑菜---->摘菜----->洗菜---->切菜---->起锅烧油----->炒菜---->出锅
			
			
	面向对象:(自己是指挥者)
			买电脑:
				看了电脑配置----->让懂行的朋友去买电脑----->买到电脑
				
			洗衣服:
			脱下脏衣服----->找一个全自动洗衣机(一键)/对象------>晾一晾
			
			
			炒菜
				饭店---->点菜---->出锅
				对象---->出锅

面向对象的思想特点:
1)更符合生活中的思想行为习惯
2)让复杂的事情简单化
3)让我们成从执行者变成了一个指挥者!
面向对象设计原则:
不断创建对象,使用对象,指挥该对象做事情!
面向对象的三大特征:
封装,继承,多态!

类和事物

类 和 事物的关系:

事物:描述现实世界的真实存在泛指的东西!  

学生----->学生事物
			属性:姓名,年龄,学号,性别
			行为:主要学习

类:是描述一组事物的属性和行为的集合
类: 是Java语言的最基本的单元		

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

	属性:描述学生的特征(姓名,年龄,学号,性别)			
	行为:描述学生能干什么(主要学习)		
													
代码体现出来:类  学生类   class Student{}
成员变量：位置：在类中，方法外	（name,age,studyId,gender）
成员方法：study()
	public 返回值类型 方法名（参数）{}
	
	代码体系具体事物：创建该类对象
				类名 对象名 = new 类名();
	对象名.成员变量
			对象名.name = "张三" ;
	对象名.成员方法()

面向对象的最大特点：强调对象的创建，使用该对象调用自己的功能！
举例:

//定义一个学生类
	class Student{
		//定义学生类中的属性
		String name;	//姓名
		String sex;		//性别
		int age;		//年龄
		int id;			//学号
		String team;	//班级
		//定义学生类中的行为
		public void eat(){//吃
			System.out.println("吃火锅...");
		}
		public void drink(){
			System.out.println("喝快乐肥宅水...");
		}
		public void paly(){
			System.out.println("打篮球...");
		}
		public void learn(){
			System.out.println("学C学Java...");
		}
	}
	
	//定义一个学生测试类
	class StudentTest{
		public static void main(String[] args){
			//创建类对象
			Student student = new Student();
			//访问属性
			student.name = "史蒂芬.库里";
			student.sex = "男";
			student.age = 31;
			student.id = 312354;
			student.team = "金州勇士";
			System.out.println("姓名:"+student.name);
			System.out.println("性别:"+student.sex);
			System.out.println("年龄:"+student.age);
			System.out.println("学号:"+student.id);
			System.out.println("班级:"+student.team);
			System.out.println("--------------------------------");
			//访问行为
			student.eat();
			student.drink();
			student.paly();
			student.learn();
		}
	}

成员变量和局部变量

局部变量和成员变量的区别?
1)在类中的位置不同
	局部变量:在方法定义中或者是方法声明上的变量
	成员变量:在类中,方法外定义的变量
2)在内存中的位置不同
	局部变量:在栈内存中存储  跟方法有关
	成员变量:在堆内存中存储	 跟类的对象有关

3)生命周期不同
	局部变量:随着方法的调用而存在,随着方法的调用完毕而消失!
	成员变量:随着对象的创建而存在,随着对象的创建完毕并且使用完毕,等待垃圾回收器回收掉掉(GC)之后才消失!(不会立即被回收)									
4)初始时机不同:
	局部变量:在方法定义中或者方法声明上的变量,必须在使用之前进行数据初始化,否则"可能尚未初始化变量"
	成员变量:跟对象有关系,在堆内存中,即使这个成员变量没有赋值,系统会根据变量的类型给这个变量进行默认初始化

匿名对象

匿名对象:没有名字的对象
匿名对象的格式
new 类名() ; (前提条件:该类是一个具体类)
特点:
1.仅仅使用一次,使用完毕,从内存中会立即被释放掉
2.匿名对象也可以作为参数进行传递
举例:

/自定义一个学生类
class Student{
	public void study(){
		System.out.println("好好学习,天天向上!!") ;
	}
}

//自定义StudentDemo类
class StudentDemo{
	public void method(Student s){//形式参数是一个引用类型,具体类
		s.study() ;
	}
}
//测试类
class NoNameDemo{
	public static void main(String[] args){
		//创建StudentDemo类对象    类名 对象名 = new 类名() ;
		StudentDemo sd = new StudentDemo() ;
		//创建学生类对象
		Student s = new Student() ; //对象名称叫s 
		sd.method(s) ;
		System.out.println("-------------------------") ;
		
		//使用匿名对象
		sd.method(new Student()) ;  //该学生的匿名对象作为参数传递
	}
}

封装

private关键字

特点:
1)private可以修饰一个类中的成员变量,也可以成员方法
2)被private修饰的成员变量或者是成员方法只能在本类中方法,外界不能访问的
举例:

class Demo{

	//定义一个成员变量
	int num = 10;
	private int num2 = 30 ; //私有修饰,只能在Demo类中访问,外界要访问需要通过公共的方法来访问!
	
	//成员方法
	public void method(){
		System.out.println(num) ;
		System.out.println(num2) ;
		System.out.println("method demo...") ;
	}
	
	//私有的成员方法
	private void function(){ //私有的方法,只能在本类中访问
		System.out.println("function demo...") ;
	}
	//公共方法
	public void show(){
		function() ;
	}
}
//测试类
class PrivateDemo{
	public static void main(String[] args){
		//创建Demo类的对象
		Demo d = new Demo() ;
		d.num = 50 ; //num成员变量在Demo类中没有被private修饰
		System.out.println(d.num) ;
		//d.num2 = 100 ; //System.out.println(d.num) ;
		//System.out.println(d.num2) ;
		System.out.println("-------------------------") ;
		
		d.method() ;
		//d.function() ;// function() 在 Demo 中是 private 访问控制
		d.show() ;
	}
}

标准类的写法

为了区分成员变量和局部变量----java提供了一个关键字:this(代表了当前该类对象地址引用)
setXXX(形参)方法,谁调用这个方法,那么this代表它(地址)
举例:

class Student{
	//成员变量私有化
	private String name ; //姓名
	private int age; //年龄
	//提供公共的访问方法赋值 setXXX/getXXX方法 XXX对应的属性名称
	//给姓名赋值
	
	public void setName(String name){ //
		this.name = name ;//this.name = "庄周"
	}
	
	public void setAge(int age){ // age = 25 局部变量
		this.age = age ; //this.age = 25
	}
	
	//获取姓名
	public String getName(){
		return name ; //此时获取的name,成员变量的name,隐藏关键了this
		//return this.name ; //其实这样的写法  //return "庄周" ;
	}
	//获取年龄
	public int getAge(){ 
		return age ;// return this.age = return 25 ;
	}
	//其他的成员方法:
	public void study(){
		System.out.println("学习Java中的面向对象...") ;
	}
}
//测试类名
class StudentTest{
	public static void main(String[] args){
		//创建学生类对象
		Student s = new Student() ;
		//通过setXXX方法进行赋值 
		s.setName("庄周") ;
		s.setAge(25) ;
		System.out.println(s.getName()+"---"+s.getAge());
		s.study();
	}
}

构造方法

构造方法:
1)方法名和类名相同
2)没有具体的返回值类型
3)并且连void都没有

	权限修饰符 + 方法名就是类名(){
		
	}

构造方法主要作用:就是给该对象中的数据进行初始化!
注意事项:
1)在一个类中,我们不写无参构造方法,系统会默认的提供一个无参构造方法,
2)如果我们提供一个有参构造方法,系统不会在提供无参了,如果使用无参构造方法创建对象,就会报错!
(永远建议给出无参构造方法)!
举例:

class Student{
	//属性私有化
	private String stuId ; //学号
	private String name ;  //姓名
	private int age ;      //年龄
	private String gender ; //性别
	
	//提供无参构造方法
	public Student(){
	}
	
	//提供有参构造方法
	public Student(String stuId,String name,int age,String gender){
		this.stuId = stuId ;
		this.name = name ;
		this.age = age ;
		this.gender = gender ;
	}
	
	//提供setXXX()/getXXX()
	public void setStuId(String stuId){
		this.stuId = stuId ;
	}
	public void setName(String name){
		this.name = name ;
	}
	public void setAge(int age){
		this.age = age ;
	}
	public void setGender(String gender){
		this.gender = gender ;
	}
	//获取值
	public String getStuId(){
		return stuId ;
	}
	public String getName(){
		return name ;
	}
	
	public int getAge(){
		return age ;
	}
	public String getGender(){
	
		return gender ;
	}
	
	public void study(){
		System.out.println("学C学Java...") ;
	}
	public void sleep(){
		System.out.println("累了,睡会吧") ;
	}
	
}

//测试类
class StudentTest{
	public static void main(String[] args){
		//测试学生类
		
		//方式1:无参构造方法+setXXX:赋值
		Student s = new Student() ;
		s.setStuId("30");
		s.setName("库里");
		s.setAge(31) ;
		s.setGender("男") ;
		
		System.out.println(s.getStuId()+"----"+
		s.getName()+"----"+s.getAge()+"----"+
		s.getGender()); 
		s.study();
		s.sleep();
		System.out.println("--------------------------");
		//方式2:通过有参构造方法赋值  (构造方法目的:对对象的数据进行初始化)
		Student s2 = new Student("30","库里",31,"男") ;
		System.out.println(s2.getStuId()+"----"+
		s2.getName()+"----"+s2.getAge()+"----"+
		s2.getGender()); 
		s2.study();
		s2.sleep();
		
	}
}

成员方法

成员方法的分类:

	两种情况:
		要么有返回值类型
			1)有返回值类型,并且有参数
			2)有返回值类型,没有参数
		要么没有具体返回值:void代替
			1)没有返回值类型,带参
			2)没有返回值类,不带参

class StudentDemo{
	//定义成员方法
	
	//有返回来类型的情况
	
	//有返回值,带参
	public String method(String str){
		return "hello"+str;
	}
	
	//有返回值,不带参的
	public String function(){
		return "hello JavaEE" ;
	}
	
	//没有返回值类型的情况
	
	//没有返回值带参的 :void代替返回值类型
	public void  show(int num){
		System.out.println(num);
		function2() ;
	}
	
	//没有返回值,不带参的
	private void function2(){
		System.out.println("function2 StudentDemo") ;
	}
	
}
//测试类
class MethodDemo{
	public static void main(String[] args){
			//访问这些成员方法:
			//创建对象 :类名  对象名 = new 类名();
			StudentDemo sd = new StudentDemo() ;
			String result = sd.method("world") ;
			System.out.println(result) ;
			
			String s2 = sd.function() ;
			System.out.println(s2) ;
			
			sd.show(100) ;
			//sd.function2() ;//function2() 在 StudentDemo 中是 private 访问控制
			
	}
}

static关键字

特点:

	1)被static修饰的变量/方法 都随着类的加载而加载
		
			class xxx{} ----> 通过javac 编译xxx.java文件		--->编译没有问题(Java语法校验)
						---->产生xxx.class文件   
						
							java xxx类
	2)被static修饰的 优先于对象存在
		回想main :被静态修饰符: jvm调用它
			public static void main(String[] args){
				
			}
			
	3)被static修饰的可以被多个对象共用 
		有共享,共用
		举例:
			班级的编号(同一个班级的都在共用编号)
			水杯(不能被共用)
			
	4)被静态修饰的成员变量或者成员方法 ,
			可以被类名直接访问(推荐访问方式)
				类名.成员方法;
				类名.成员方法();

class StaticDemo{

	public static void main(String[] args){
		
		Demo d = new Demo() ;
		
		//访问非静态的成员变量,成员方法
		System.out.println(d.num) ;
		d.show();
		System.out.println("-------------") ;
		
		//对象名来访问静态成员
		System.out.println(d.num2) ;
		d.method();
		
		System.out.println("-------------") ;
		//推荐方式:静态成员 直接使用类名访问(static静态的随着类的加载而加载)
		System.out.println(Demo.num2) ;
		Demo.method();
	}
}

使用static关键字的注意事项:

	1)在static中,是没有this关键字的! (this:代表当前类的对象的地址值,对象已经创建了而static修饰的
	和类有关系);
	2)关于成员方法的访问问题:
			非静态的成员方法
				既可以访问静态的成员变量,也可以访问非静态的成员变量
				既可以访问静态的成员方法,也可以访问非静态的成员方法;
			
			静态的成员方法
				简单记:静态只能访问静态

本文地址：https://blog.csdn.net/weixin_48340270/article/details/107574551

如您对本文有疑问或者有任何想说的，请 点击进行留言回复，万千网友为您解惑！