Java自学笔记Day07

day07

面向对象

面向对象思想概述

/* A: 面向过程思想概述:
		*第一步
		*第二步;
	B: 面向对象思想概述:
		*找对象(第一步,第二步)
	C: 举例说明
		买煎饼果子

​

	D:面向对象的思想特点:
 		a: 	一种更符合我们思想习惯的思想(懒人思想);
 		b: 可以将复杂的事情简单化;
 		c:将我们从执行者变成指挥者;角色发生转换;
 	E: 面向对象开发
 		*就是不断创建对象,使用对象,指挥对象做事
 	F: 面向对象设计
 		*其实就是在管理和维护对象之间的关系;
 	G: 面向对象特征:
		*封装(encapsulation);
		*继承(inheritance);
		*多态(polymorphism);

面向对象(类与对象概述)

A: 学习编程是为了什么?
	为了把我们日常生活中实物用学习语言描述出来;
B: 我们如何描述现实世界的事物
	*属性 就是该事物的描述信息(事物身上的名词);
	*行为 就是该事物能够做什么(事物身上的动词);
C: Java中最基本的单位是类,Java中用class描述事物也是如此;
	*成员变量 事物的属性;
	*成员方法 事物的行为;
D: 定义类其实就是定义类的成员(成员变量和成员方法);
	*成员变量 和以前定义变量是一样的,只不过位置发生了改变,在类中,在方法外;
	*成员方法 和以前定义方法一样,只不过把static去掉
E: 类和对象的概念
	a: 类: 是一组相关的属性和行为的集合;
	b: 对象: 是该事物的具体体现

类的定义举例
1.学生类
class Student
{
	String name;			  //姓名
	int age;				  //年龄
	String gender;			  //性别

	public void study(){
		System.out.println("学生学习");
	}
	public void sleep(){
		System.out.println("学生睡觉");
	}
}
2.手机类
class phone
{
	String brand;
	int price;

	public void call(){
		System.out.println("打电话");
	}
	public void call(){
		System.out.println("sent message");
	}
	public void call(){
		System.out.println("play game");
	}
}

类的使用

A: 文件名问题
	*在一个java文件中写两个类:一个基本的类,一个测试类;
	建议文件名称和测试类名称一致;
B: 如何使用对象?
	*创建对象并使用
	*格式: 类名 对象名 = new 类名();
D:如何使用成员变量名?
	对象名.变量名
E: 如何使用成员方法名?
	*对象名.方法名(...)
	
使用举例
//定义学生类并使用
class Demo1_Student 
{
	public static void main(String[] args) 
	{
		//创建对象的格式: 类名 对象名 = new 类名();
		//对象名其实就是合法的标识符,如果是一个单词所有字母小写,如果是多个单词,从第二个单词开始首字母大写
		Student s = new Student();
		/*
		D:如何使用成员变量名?
			对象名.变量名
		E: 如何使用成员方法名?
			*对象名.方法名(...)
		*/
		s.name = "张三";
		s.age = 23;
		System.out.println(s.name + "..." + s.age);
		s.study();
		s.sleep();
	}
}
class Student
{
	String name;			  //姓名
	int age;				  //年龄
	String gender;			  //性别

	public void study(){
		System.out.println("学生学习");
	}
	public void sleep(){
		System.out.println("学生睡觉");
	}
}
//定义手机类并使用对象
class Demo_Phone 
{
	public static void main(String[] args) 
	{
		Phone p = new Phone();
		p.brand = "红米Note7";
		p.price = 1499;
		System.out.println(p.brand + "..." + p.price);
		p.call();
		p.sendMessage();
		p.playGame();
	}
}

class Phone
{
	String brand;
	int price;

	public void call(){
		System.out.println("打电话");
	}
	public void sendMessage(){
		System.out.println("send message");
	}
	public void playGame(){
		System.out.println("play game");
	}
}

类的内存分配

class Demo3_Car 
{
	public static void main(String[] args) 
	{
		Car c1 = new Car();
		c1.brand = "广汽丰田";
		c1.color = "blue";
		c1.price =  200000;
		c1.run();	//调用行为

		Car c2 = new Car();
		c2.brand = "奥迪A5";
		c2.color = "white";
		c2.price =  240000;
		c2.run();	//调用行为

		//c2 = null ;		 //NullPointerException    用null把原来的地址值覆盖掉了
		//c2.run();									//c2里面的记录是null,所以报出空指针异常
	}			 
}
/*
车的属性:商标,价钱,	颜色
车的行为: 运行,刹车
*/
class Car
{
	String color;						//属性:颜色
	String brand;						//属性:商标;
	int price;							//属性:价格
	public void run(){					//车运行   行为
		System.out.println(brand + color + price);
	}
}

类:一个对象内存分配

类:两个对象的内存分配

​ 堆:如果没有任何引用指向该对象,该对象就会变成垃圾,Java中有完善的垃圾回收机制,会在不定时的进行回收

C语言中需要手动回收;

面向对象(成员变量和局部变量的区别)

A:在类中位置不同
	*成员变量:在类中方法外;
	*局部变量:在方法定义中或者方法声明上;
B: 内存中的位置不同
	成员变量:在堆内存(成员变量属于对象,对象进堆内存);
	局部变量:在栈内存(局部变量属于方法,方法进占内存);
C: 生命周期不同
	成员变量:随着对象的创建而创建,随着对象的消失而消失;
	局部变量:随着方法的调用而存在,随着方法调用完毕而消失;
D: 初始化变量不同
	*成员变量,有默认初始化值;
	*局部变量:没有默认初始化值,必须定义,赋值,然后才能使用;
*注意事项:
	*局部变量名称可以和成员变量名称一样,在方法中使用的时候,采用的是就近原则;
	*基本数据类型变量包括:byte,short,int,long,float,double,boolean,char
	*引用数据类型变量包括:数组,类,接口,枚举
class Demo2_Person 
{
	public static void main(String[] args) 
	{
		Person p = new Person();
		p.speak();
	}
}
class Person{
	String name;//成员变量;
	int num;
	public void speak(){		   //x和num都是局部变量
		int num = 10;
		System.out.println(name);
		System.out.println(num);
	}
}

方法的形式参数是类名的时候如何调用

A: 方法的参数是类名 public void print (Student s){}//print{new Student()}
	如果看到一个方法的形式参数是一个类类型(引用类型),这里需要的其实是该类的对象
	
####
class Demo7_Student 
{
	public static void main(String[] args) 
	{
		print(10);	  

		Student s = new Student();				//创建对象,并将对象的地址赋值给s
		print(s);
	}
	public static void print(int x){			//基本数据类型当做形参
		System.out.println(x);
	}

	public static void print(Student s){		//引用数据类型当做形参
		s.name  = "张三";
		s.age = 23;
		s.speak();
	}
}
class Student
{
	String name;
	int age;

	public void speak(){
		System.out.println(name + "..." + age);
	}	
}

匿名对象的概述和应用

A:什么是匿名对象
	没有名字的对象;
B:匿名对象的应用场景
 	a: 调用方法,仅仅只调用一次的时候;
		那么这种代码有什么好处:
			节省代码
	*注意:调用多次的时候,不适合,匿名对象调用完毕就是垃圾,可以被垃圾回收器回收;
	 b: 匿名对象可以作为实际参数传递
 C:案例演示
 	匿名对象应用场景	
 class Demo2_Car 
{
	public static void main(String[] args) 
	{
		Car c1 = new Car();			//创建有名字的对象;
		c1.run();
		new Car().run();			
     //匿名对象调用,匿名对象只适合对方法的一次调用,因为调用多次就会产生多个对象,不如调用有名字的对象;
	 //匿名对象是否可以调用属性并赋值?有什么意义?
		new Car().color = "red";
		new Car().num  = 4;
	}
}
class Car
{
	String color;
	int num;
	public void run(){
		System.out.println(color + "..." + num);
	}
}

//匿名对象可以当做参数传递
class Demo6_Car 
{
	public static void main(String[] args) 
	{
		method(new Car());
	}

	public static void method(Car cc){
		cc.color = "red";
		cc.num = 4;
		cc.run();
	}
}
class Car
{
	String color;
	int num;
	public void run(){
		System.out.println(color + "..." + num);
	}
}

封装

A: 封装概述
	*是指隐藏对象的属性和实现细节,仅对外提供公共访问方式;
B: 封装好处
	*隐藏实现细节,提供公共的访问方式;
	*提高代码的复用性;
	*提高安全性;
C: 封装原则
	*将不需要对外提供的内容都隐藏起来;
	*把属性隐藏,提供公共方法对其访问;

面向对象相关关键字介绍

关键字:private

/*
 *A:人类年龄赋值问题
 *B:private关键字介绍
	*a:是一个权限修饰符;
	*b:可以修饰成员变量和成员方法;
	*c:被修饰的成员只能在本类中被访问;
 *C: 案例演示
	*封装和private的应用;
	*A:把成员变量用private修饰;
	*B:提供对应的getXxx()和setXxx()方法;
	*private仅仅是封装的一种体现形式,不能说封装就是私有
*/
class Demo1_Person 
{
	public static void main(String[] args) 
	{
		Person p1 = new Person();		  
		p1.name = "张三";				  //调用姓名属性并赋值
		//p1.age = 23;					  //调用年龄属性并赋值
		//p1.speak();						  //调用行为

		p1.setAge(-17);
		System.out.println(p1.getAge());
	}
}
class Person {
	String name;
	private int age;

	public void setAge(int a){		      //设置年龄
		if (a > 0 & a <200)
		{
			age = a;
		}else {
			System.out.println("输入年龄不合法");
		}
	}
	public int getAge(){			      //获取年龄
		return age;
	}
	public void speak(){
		System.out.println("我的姓名是" + name + "..." + "我的年龄是" + age);
		}
}

关键字:this

/*
A: this关键字特点
	*代表当前对象的引用;
B: 案例演示:
	*this的应用场景:
	用来区分成员变量和局部变量
*/
class Demo1_This 
{
	public static void main(String[] args) 
	{
		Person p1 = new Person();
		p1.setName("张三");
		p1.setAge(23);
		System.out.println(p1.getName() + "...." + p1.getAge());

		Person p2 = new Person();
		p2.setName("李四");
		p2.setAge(24);
		System.out.println(p2.getName() + "...." + p2.getAge());
	}
}

class Person {
	private String name;
	private int age;

	public void setAge(int age){		      //设置年龄
		if (age > 0 & age <200)
		{									//就近原则
			this.age = age;
		}else {
			System.out.println("输入年龄不合法");
		}
	}
	public int getAge(){			      //获取年龄
		return age;
	}

	public void setName(String name){
		this.name = name;
	}		//设置姓名;
	public String getName(){
		return name;
	}		//获取姓名;
}

案例应用

class Test_Phone 
{
	public static void main(String[] args) 
	{
		Phone p = new Phone();
		p.setBrand("红米note7");
		p.setPrice(1399);
		System.out.println("手机品牌是" + p.getBrand() + ",价格是" + p.getPrice());
		p.call();
		p.sendMessage();
		p.playGame();
	}
}
/*
手机类:
	属性:品牌,价格
	行为:打电话,发短信,玩游戏
*/
class Phone									 //java bean
{
	private String brand;			//品牌
	private int price;				//价格
	
	public void setBrand(String brand){
		this.brand = brand;			//设置品牌;
	}								//获取品牌
	public String getBrand(){
		return this.brand;			 //this可以省略,系统会自动添加;
	}

	public void setPrice(int price){
		this.price = price;
	}
	public int getPrice(){
		return price;					//省略了this
	}
	public void call(){
		System.out.println("打电话");
	}
	public void sendMessage(){
		System.out.println("send Message");
	}
	public void playGame(){
		System.out.println("playGame");
	}
}

构造方法

##A: 构造方法的概述和作用:
	*给对象的数据(属性)进行初始化;还可以动态赋值
  B: 构造方法格式与特点:
	*a: 方法名与类名相同(大小也与类名保持一致);
	*b: 没有返回值类型,连void都没有;
	*c: 没有具体的返回值return
  C: 构造方法的重载(重载:方法名相同,与返回值类型无关)
    *构造方法没有返回值;
  D: 构造方法的注意事项
  	 *a:如果我们没有给出构造方法,系统将自动提供一个无参数的构造方法;
	 *b:如果我们给出构造方法,系统将不再提供默认的无参数构造方法;
		*注意:这个时候,我们如果还想使用无参数构造方法,就必须自己给出,建议一直自己给出无参数构方法

class Demo3_Person 
{
	public static void main(String[] args) 
	{
		Person p1 = new Person();		 //括号未写内容,空参构造
		p1.show();
		System.out.println("-----------");
		Person p2 = new Person("张三",23); //有参构造
		p2.show();
		System.out.println("-----------");
		Person p3 = new Person("李四",26); //有参构造
		p3.show();
	}
}
class Person
{
	private int age;
	private String name;

	public Person(){
		System.out.println("空参构造");
	}
	public Person(String name ,int age){
		this.name = name;
		this.age = age;
		System.out.println("有参构造");
	}
	public void show(){
		System.out.println(name + "... " + age);
	}
}

给成员变量赋值的两种方法

/*
构造方法
	给属性进行初始化;
setXxx方法
	修改属性值,
	这两种方式,在开发中setXxx更多一些,因为比较灵活;
*/

class Demo4_Person 
{
	public static void main(String[] args) 
	{
		Person p1 = new Person("张三",23);	//有参构造创建对象;
		p1 = new Person("张天一",23);		//这种方式看运行结果貌似改名了,其实是将原对象变成垃圾
		System.out.println(p1.getName() + "...." + p1.getAge());
		System.out.println("-----------");
		Person p2 = new Person();			 //空参构造创建对象
		p2.setName("李四");
		p2.setName("李鬼");					  //改名
		p2.setAge(25);
		System.out.println(p2.getName() + "...." + p2.getAge());
	}
}
/*
构造方法
	给属性进行初始化;
setXxx方法
	修改属性值,
	这两种方式,在开发中setXxx更多一些,因为比较灵活;
*/
class Person
{
	private int age;
	private String name;

	public Person(){
	}
	public Person(String name ,int age){
		this.name = name;
		this.age = age;
	}
	public void setName(String name){
		this.name = name;		  //设置姓名
	}
	public String getName(){
		return name;			 //获取姓名
	}
	public void setAge(int age){
		this.age = age;			  //设置年龄
	}
	public int getAge(){
		return this.age;		   //获取年龄
	}
	public void show(){
		System.out.println(name + "... " + age);
	}
}