【JavaSE学习笔记】面向对象_01(入门，匿名对象，成员变量，局部变量，封装，this，构造方法)

面向对象01

A：面向对象入门

1）：面向对象思想概述

a.基于过程思想：给一个需求，通过分析需求，然后一步一步的去实现！完成一个功能的具体步骤

举例：打水：自己打水--->拿起杯子--->走到打水的地方--->打水

           炒菜：买菜--->砍价--->摘菜--->洗菜--->炒菜

b.面向对象思想：创建对象，适用对象调用功能！（主要：对象）

举例：打水：让别人给我打水（只管水给我就可以了）--->喝水

           炒菜：找个对象给你干--->端上来就可以了

c.面向对象的特点：

1.更符合我们的一些思想行为习惯

2.让复杂的事情简单化

3.让我们从执行者变成指挥者

d.案例：把大象塞进冰箱

Ⅰ.面向过程：

      功能：打开冰箱，大象进去，关闭冰箱

public class Demo01 {
	public static void main(String[] args) {
		open();
		in();
		close();
	}
	
	public static void open() {
		System.out.println("打开冰箱的功能");
	}
	
	public static void in() {
		System.out.println("大象进去的功能");
	}
	
	public static void close() {
		System.out.println("关闭冰箱的功能");
	}
}

Ⅱ.面向对象：

     首先分析这个需求有哪些类？

            冰箱

            大象

             Demo01（测试类）

class 冰箱{
	public static void open() {
		System.out.println("打开冰箱的功能");
	}
	
	public static void close() {
		System.out.println("关闭冰箱的功能");
	}
}

class 大象{
	public static void in() {
		System.out.println("冰箱进去的功能");
	}
}

public class Demo01 {
	public static void main(String[] args) {
		冰箱.open();
		大象.in();
		冰箱.close();
	}
}

e.面向对象的三大特征：

       封装、继承、多态

2）类与对象的描述

a.要学习类，就得知道事物！

      事物是现实事件里面的一些具体的东西！

b.如何描述一个事物？

       举例：学生

                   姓名，年龄，性别

                   学习，打游戏

Ⅰ.描述十五的属性：姓名，年龄，性别

Ⅱ.描述事物的行为：学习，打游戏

c.一个事物转换成类

学生类：

      属性在类中叫成员变量：name,age,sex

      行为在类中叫成员方法：study(),playGeme()

e.成员变量的位置：类中成员方法外

f.如何定义一个类：

class Phone{
	//成员变量
	String brand;
	int price;
	String color;
	
	//成员方法
	public void callPhone(String name) {
		System.out.println("给"+name+"打电话");
	}
	
	public void setMessage(String name) {
		System.out.println("给"+name+"发短信");
	}
	
	public void playGame(String game) {
		System.out.println("玩"+game);
	}
}

g.Java中最基本的单元是类

3）练习：

a.一个对象

b.两个对象

c.三个对象

B.匿名对象

1）匿名对象，就是没有名字的对象，执行一次，不适合多次调用

class Student{
	public void show() {
		System.out.println("学生爱学习");
	}
}

class StudentDemo01{
	//如果形式是这种情况，就需要Student类的对象：Student s = new Student();
	public void method(Student  s) {
		s.show();//Student s:要的是一个Student类的具体对象
	}
}

public class Demo01 {
	public static void main(String[] args) {
		Student s = new Student();//有s对象名：有名字对象
		s.show();
		s.show();
		//这个对象将show调用了两次
		
		//使用匿名对象(开发中，匿名对象也会经常用到)
		new Student().show();
		new Student().show();//重新创建了一个对象，对内存中传声内存空间
		
		//匿名对象可以作为参数进行传递
		StudentDemo01 sd2 = new StudentDemo01();
		sd2.method(new Student());
		
		//链式编程
		new StudentDemo01().method(new Student());
	}
}

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

1）在类中的位置不同

a.成员变量：在类中，方法外

b.局部变量：在方法声明上，或者是在方法定义中

2）在内存里的位置不一样

a.成员变量：在堆内存

b.局部变量：在栈内存

3）生命周期不同

a.成员变量：随着对象的创建而存在，随着对象的消失而消失

b.局部变量：随着方法调用而存在，随着方法的调用结束而消失

4）初始化值不同

a.成员变量：有默认值：int类型：0   引用类型：null

b.局部变量：必须初始化值，否则报错！

5）注意：当局部变量名称和成员变量名称一致的时候，就近原则

//基本类
class Variable{
	//定义成员变量
	int num = 100;
	
	//成员方法
	public void show() {
		int num2 = 100;
		System.out.println(num2);
		
		int num = 200;
		System.out.println(num);//num = 200,就近一致原则
	}
	
}

public class Demo01 {
	public static void main(String[] args) {
		//调用Variable类里面的成员变量num
		//创建Variable类的对象
		Variable v = new Variable();
		
		System.out.println(v.num);//100
		
		//调用成员方法
		v.show();//200
	}
}

D.封装

1）private关键字的作用

a.私有的，不可访问的

b.private可以修饰成员变量，也可以修饰成员方法

c.被private修饰的成员只能在本类中访问，外界不能访问

class Demo{
	//定义成员变量
	private int num;
	
	//成员方法
	public void show() {
		System.out.println(num);
	}
	
	private void method() {
		System.out.println("method");
	}
	
	public void function() {
		method();
	}
}

public class Demo01{
	public static void main(String[] args) {
		//创建Demo类的对象
		Demo d = new Demo();
		//System.out.println(d.num);//在Demo类中被private修饰，外界不能访问
		d.show();
		//d.method();//The method method() from the type Demo is not visible
		d.notifyAll();
	}
}

2）练习：

/*
 * 一个手机类的标准写法
 * 成员变量：brand,price,color(将成员变量私有化，提供公共的访问方式)
 * 成员方法：手机特有的功能：打电话/发短信
 * set和get方法():公共的访问方法
 */
//定义手机类
class Phone{
	//成员变量私有
	private String brand;
	private int price;
	private String color;
	
	//提供的公共访问方式：set()/get()
	//获取brand的值，既然获取就返回值类型
	/*
	 * 两个明确：
	 * 返回值类型：String
	 * 参数类型：无
	 */
	public String getBrand() {
		return brand;
	}
	
	//给brand去赋值的set()方法
	/*
	 * 两个明确：
	 * 返回值类型：无
	 * 参数列表：String brand
	 */
	public void setBrand(String b) {//b:在测试类里面测试的时候：b属于传递的实际参数
		brand = b;
	}
	
	public int getPrice() {
		return price;
	}
	
	public void setPrice(int p) {
		price = p;
	}
	
	public String getColor() {
		return color;
	}
	
	public void setColor(String c) {
		color = c;
	}
	
	//打电话
	public void callPhone() {
		System.out.println("打电话");
	}
	
	//玩游戏
	public void playGame() {
		System.out.println("玩游戏");
	}
}

public class Demo01{
	public static void main(String[] args) {
		//创建手机类的对象
		Phone p = new Phone();
		
		//成员变量私有化，只能通过公共的访问方式
		p.setBrand("华为");
		p.setPrice(1699);
		p.setColor("黑色");
		System.out.println(p.getBrand()+"---"+p.getPrice()+"---"+p.getColor());
		p.callPhone();
		p.playGame();
	}
}

E:this关键字

1）this：代表当前类的对象

class  Student{
	//成员变量
	private String name;
	
	public void setName(String name) {
		this.name = name;
		/*
		 * 前面的neme属于成员变量：
		 * 局部变量和成员变量名称一致，就近一致原则
		 * 第一个name：为Student类里面的name
		 * 这种情况：为了区分成员变量和局部变量，java提供了关键字this
		 * this:代表当前对象的引用，简单记：代表当前类的一个对象
		 */
	}
	
	public String getName() {
		return name;
	}
}

2）上一节里的手机例子

class  Phone{
	private String brand;
	private int price;
	private String color;
	
	public void setBrand(String brand) {
		this.brand = brand;
	}
	
	public String getBrand() {
		return brand;
	}
	
	public void setPrice(int price) {
		this.price = price;
	}
	
	public int getPrice() {
		return price;
	}
	
	public void setColor(String color) {
		this.color = color;
	}
	
	public String getColor() {
		return color;
	}
	
	public void callPhine(String name) {
		System.out.println("给"+name+"打电话");
	}
	
	public void setMessage(String name) {
		System.out.println("给"+name+"发短信");
	}
}

3）面试题：

        Student s = new Student();这句话做了几件事？

a.Student s 在栈内存分配空间

b.new Student()在堆内存里分配空间

c.通过加载Student类加载成员变量：默认的初始化值

d.显示初始化：通过构造方法进行数据初始化

e.通过创建对象赋值操作

f.给堆内存标记一个内存空间的一个地址：Student s 里面的地址间接的指向

F.构造方法

1）给数据进行初始化的

a.方法名与类名相同

b.没有返回值类型，连void都没有

c.没有具体返回值

class Student{
	private String name;	//null
	private int age;		//0
	
	//构造方法(无参数构造方法)
	public Student() {
		System.out.println("我是一个构造方法");
	}
	
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public int getAge() {
		return age;
	}
	
	public void setAge(int age) {
		this.age = age;
	}
	
	public void show() {
		System.out.println(name+"---"+age);
	}
}

public class Demo01{
	public static void main(String[] args) {
		//创建Student对象
		Student s = new Student();
		
		s.setName("Messi");
		s.setAge(30);
		s.show();
	}
}

2）构造方法如何调用

a.如果我们基本类中，没有给出构造方法，系统会默认提供一个无参的构造方法

b.在代码中如果自己已经给出了构造方法，系统将不再提供默认的无参构造方法

3）给成员变量赋值两种方法

a.公共的访问方法：set()

b.构造方法给成员变量赋值

class Student{
	private String name;	//null
	private int age;		//0
	
	//构造方法(无参数构造方法)
	public Student() {
		System.out.println("我是一个构造方法");
	}
	
	//构造方法是可以重载的：方法名相同，参数列表不同，与返回值没有关系
	public Student(String name){
		System.out.println("这是一个带String类型的有参构造方法");
		this.name = name;
	}
	
	public Student(int age){
		System.out.println("这是一个带int类型的有参构造方法");
		this.age = age;
	}
	
	public Student(String name, int age){
		System.out.println("这是带多个类型的有参构造方法");
		this.name = name;
		this.age = age;
	}
	
	
	public String getName() {
		//return this.name   这里隐藏了一个关键字this
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public int getAge() {
		return age;
	}
	
	public void setAge(int age) {
		this.age = age;
	}
	
	public void show() {
		System.out.println(name+"---"+age);
	}
}

public class Demo01{
	public static void main(String[] args) {
		Student s1 = new Student();
		s1.setName("Messi");
		s1.setAge(30);
		System.out.println(s1.getName()+"---"+s1.getAge());
		System.out.println("-------------");
		
		//创建第二个对象
		Student s2 = new Student("Messi");
		s2.setAge(30);
		System.out.println(s2.getName()+"---"+s2.getAge());
		System.out.println("-------------");
		
		//创建第三个对象
		Student s3 = new Student(32);
		s3.setName("C·Ronald");
		System.out.println(s3.getName()+"---"+s3.getAge());
		System.out.println("-------------");
		
		//创建第四个对象
		Student s4 = new Student("C·Ronaldo", 32);
		System.out.println(s4.getName()+"---"+s4.getAge());
	}
}