欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

第二周学习记录之面向对象

程序员文章站 2022-07-10 19:09:02
面向对象基于面向过程的一种思想面向过程: 代表C语言,强调一个功能的步骤面向对象: 代表Java语言, 强调对象的创建,使用对象调用功能生活中处处都是面向对象举生活的例子:面向过程:(自己就是执行者)买电脑 心里清楚电脑的配置----->去赛格电脑城购买电脑----->砍价----> 买到了电脑 洗衣服 脱下脏衣服---->使用洗衣盆放入洗衣液,接水----->泡一泡---->搓一搓--...

面向对象

基于面向过程的一种思想
面向过程: 代表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