【JavaSE笔记】面向对象（一）_面向对象入门

本期知识点：

面对对象入门

封装

成员变量&局部变量

匿名对象

this关键字

构造方法

1. 面对对象入门

a. 定一个学生类：

学生事物：
属性：姓名，年龄，性别
行为：学习，睡觉，运动
事物转变为一个类：学生Student
属性——>成员变量
行为——>成员方法（去掉static）

b. 创建对象的格式：

类名 对象名 = new 类名();

c. 使用对象区访问成员变量：

对象名.成员变量
例:定义一个手机类：

class Phone1{
String brand;
int price;
String color;

public void tel(){
System.out.println("打电话");
}
public void mess(){
System.out.println("发短信");
}
public void game(){
System.out.println("玩游戏");
}
public void show(){
System.out.println(brand+"-"+price+"-"+color);
}
}
public class phoneDemo {
public static void main(String arg[]){
Phone1 a=new Phone1();
a.brand="诺基亚";
a.price=9999;
a.color="白色";
a.show();
a.tel();
a.mess();
a.game();
}
}

面试题：
Student s = new Student();这句话做了几件事情？
i. Student s 在栈内存分配空间；
ii. new Student ()在堆内存申请堆内存空间；
iii. 通过加载Student类加载成员变量：默认的初始化值
iv. 显示初始化：通过构造方法进行数据初始化值；
v. 通过创建对象进行赋值操作；
vi. 给内存标记一个内存空间的一个地址值：Student s 里的地址间接指向

2. 封装

把成员变量私有化,在基本类里面提供他们公共的访问方法!

a. 以一个手机类的标准写法为例：

成员变量：brand,price,color（将成员变量私有化，提供公共的访问方式）
成员方法：手机特有的功能：打电话，发短息，打游戏。
set和get方法()：公共的访问方法

两个明确:
i.返回值类型:String
ii.参数类型:无

class Phone{
//成员变量私有
private String brand ;
private int price ;
private String color ;

//提供的公共访问方式:set()/get()
//获取brand的值,既然获取就返回值类型
/*
* 两个明确:
* 	返回值类型:String
* 	参数类型:无
* */
public String getBrand(){
return brand ;
}

//给brand去赋值的set()方法
/*
* 两个明确:
* 	返回值类型:void
* 参数类型: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("玩游戏....");
}
}

b. private 关键字:

i. 私有的，不可访问；
ii. private可以修饰成员变量，也可以修饰成员方法；
iii. 被private修饰的成员变量只能在本类中访问，外界不能访问；

class Demo{
//定义成员变量
//int num ;
private int num ;

//成员方法
public void show(){
System.out.println(num);
}

private void method(){
System.out.println("method");
}

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

3. 成员变量&局部变量

a. 在类中的位置不同：

i. 成员变量：在类中，方法外；
ii. 局部变量：在方法声明上，或者是在方法定义中

b. 在内存里面的位置不一样

i. 成员变量：在堆内存中
ii. 局部变量：在栈内存中

c. 生命周期不同

i. 成员变量：随着对象的创建而存在，随着对象的消失而消失
ii. 局部变量：随着方法调用的存在，随着方法的调用结束而消失

d. 初始化值不同

i. 成员变量：有默认值
1) int类型：0
2) 引用类型：NULL
ii. 局部变量：必须初始化值,否则报错!(在使用它之前,没有初始化)
注意：当局部变量名字和成员变量名字一致时，就近原则。

例：

class Phone{
//定义成员变量
int a;
String b;
//方法
public void fun(){
a=1000;
System.out.println(a);
}
}

public class Demo {
public static void main(String arg[]){
Phone p = new Phone();//创建
System.out.println(p.a);
System.out.println(p.b);
p.fun();
}
}

4. 匿名对象

没有名字的对象；

调用执行一次；

不适合多次调用；

匿名对象可以作为参数传递；

例：

class Student01{
public void show(){
System.out.println("love learning");
}
}
//匿名对象可以作为参数传递
class Student02{
public void fun(Student01 s){
s.show();
}
}
public class Demo01 {
public static void main(String arg[]){
Student01 a=new Student01();

//		a.show();
//		a.show();
//使用匿名对象
new Student01().show();
new Student01().show();
//匿名对象可以作为参数传递
Student02 b=new Student02();
b.fun(new Student01());
//链式编程
new Student02().fun(new Student01());
new Student02().fun(a);
}
}

5.
9ce1
this关键字

代表当前对象的引用

为什么要使用this关键字：为了区分成员变量和局部变量

6. 构造方法：

给数据进行初始化的方法

a. 方法名与类名同名
b. 没有返回值类型
c. 没有具体的返回值
注意：
a. 如果我门基本类中，没有给出构造方法，系统会默认提供一个无参的构造方法
b. 在代码中如果自己已经给出了构造方法，系统将不再提供默认的无参构造

class Student2{
private String name ;
private int age ;

public Student2(){
System.out.println("这是无参构造方法");
}

//构造方法是可以重载的:方法名相同,参数列表(参数个数/参数类型)不同,与返回值没有关系
public Student2(String name){
System.out.println("这是一个带String类型的一个有参构造方法");
this.name = name ;
}

public Student2(int age){
System.out.println("这是一个带int类型的一个有参构造方法..");
this.age = age ;
}

public Student2(String name,int age){
System.out.println("这是带多个类型的有参构造");
this.name = name ;
this.age = age ;
}