本期知识点：
面对对象入门
封装
成员变量&局部变量
匿名对象
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. 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 ;
}