JavaSE学习总结第07天_面向对象2

 

07.01 成员变量和局部变量的区别

1.在类中的位置不同

成员变量    类中方法外

局部变量    方法内或者方法声明上

2.在内存中的位置不同

成员变量   堆内存

局部变量   栈内存

3.生命周期不同

成员变量   随着对象的存在而存在，随着对象的消失而消失

局部变量   随着方法的调用而存在，随着方法的调用完毕而消失

4.初始化值不同

成员变量   有默认的初始化值

局部变量   没有默认的初始化值，必须先定义，赋值，才能使用。

07.02 方法的形式参数是类名的调用

例:

 class Demo
 {
     public static void main(String[] args)
     {
         //创建学生对象
         Student s = new Student();
         StudentDemo sd = new StudentDemo();
         sd.method(s);
     }
 }
 class StudentDemo
 {
     //形式参数是引用类型
     public void method(Student s)
     {
         s.show();
     }
 }
 class Student
 {
     public void show()
     {
         System.out.println("学生爱学习");
     }
 }

07.03 匿名对象的概述和应用

匿名对象:就是没有名字的对象。是对象的一种简化表示形式

匿名对象的两种使用情况:

1.对象调用方法仅仅一次的时候

2.作为实际参数传递

例:

 class Demo
 {
     public static void main(String[] args)
     {
         //匿名对象调用方法
         new Student().show();
     }
 }
 class Student
 {
     public void show()
     {
         System.out.println("学生爱学习");
     }
 }

匿名对象调用完毕就是垃圾，垃圾回收器会在适当的时间回收，提高内存的使用效率

07.04 封装的概述

封装概述:是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

例:

 class Student
 {
     String name;
     //将age私有，只能在Student类中访问
     private int age; 

     //提供对外访问的方法获取age的值
     public int getAge()
     {
         return age;
     }
     //提供对外访问的方法，并可以对传入的a的值进行判断，满足条件则赋值给age，不满足则不赋值
     public void setAge(int a)
     {
         age = a;
     }
     public void show()
     {
         System.out.println("姓名:"+name+"   "+"年龄:"+age);
     }
 }

07.05 封装的好处和设计原则

封装好处:

1.隐藏实现细节，提供公共的访问方式

2.提高了代码的复用性

3.提高安全性

封装原则:将不需要对外提供的内容都隐藏起来。把属性隐藏，提供公共方法对其访问。

07.06 private关键字的概述和特点

private关键字:是一个权限修饰符。可以修饰成员(成员变量和成员方法)，被private修饰的成员只在本类中才能访问。

private最常见的应用:

1.把成员变量用private修饰

2.提供对应的getXxx()/setXxx()方法

07.07 private的应用标准案例

 class Demo
 {
     public static void main(String[] args)
     {
         Student s = new Student();
         //给成员变量赋值
         s.setName("小强");
         s.setAge(25);

         System.out.println(s.getName()+":"+s.getAge());
     }
 }
 class Student
 {
     private String name;
     //将age私有，只能在Student类中访问
     private int age; 

     //提供对外访问的方法获取name的值
     public String getName()
     {
         return name;
     }
     //提供对外访问的方法设置name的值
     public void setName(String n)
     {
         name = n;
     }
     //提供对外访问的方法获取age的值
     public int getAge()
     {
         return age;
     }
     //提供对外访问的方法设置age的值
     public void setAge(int a)
     {
         age = a;
     }
 }

07.08 this关键字的概述和应用

this:代表所在类的对象引用

方法被哪个对象调用，this就代表那个对象

当局部变量隐藏成员变量时使用this

例:

 class Student
 {
     private String name;
     //将age私有，只能在Student类中访问
     private int age; 

     //提供对外访问的方法获取name的值
     public String getName()
     {
         return name;
     }
     //提供对外访问的方法设置name的值
     public void setName(String name)
     {
         this.name = name;
     }
     //提供对外访问的方法获取age的值
     public int getAge()
     {
         return age;
     }
     //提供对外访问的方法设置age的值
     public void setAge(int age)
     {
         this.age = age;
     }
 }

07.09 this关键字的内存图解

07.10 标准的手机类代码及其测试

 class Demo
 {
     public static void main(String[] args)
     {
         Phone p = new Phone();
         System.out.println("品牌:"+p.getBrand()+" 价格:"+p.getPrice()+" 颜色:"+p.getColor());
         p.setBrand("小米");
         p.setPrice(1999);
         p.setColor("白色");
         System.out.println("品牌:"+p.getBrand()+" 价格:"+p.getPrice()+" 颜色:"+p.getColor());
     }
 }
 class Phone
 {
     private String brand;//品牌
     private int price;//价格
     private String color;//颜色

     public String getBrand()
     {
         return brand;
     }
     public void setBrand(String brand)
     {
         this.brand = brand;
     }

     public int getPrice()
     {
         return price;
     }
     public void setPrice(int price)
     {
         this.price = price;
     }

     public String getColor()
     {
         return color;
     }
     public void setColor(String color)
     {
         this.color = color;
     }
 }

运行结果:

品牌:null 价格:0 颜色:null
品牌:小米价格:1999 颜色:白色

07.11 构造方法概述和格式

构造方法作用概述:给对象的数据进行初始化

构造方法格式:

1.方法名与类名相同

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

3.没有具体的返回值

例:

07.12 构造方法的重载及注意事项

构造方法注意事项:

1.如果不提供构造方法，系统会给出默认构造方法

2.如果提供了构造方法，系统将不再提供

3.构造方法也是可以重载的

07.13 成员方法的分类及使用

方法具体划分:

根据返回值:1.有明确返回值方法    2.返回void类型的方法

根据形式参数:1.无参方法     2.带参方法

例:

 class Demo
 {
     public static void main(String[] args)
     {
         Student s = new Student();
         String str = s.getString();
         System.out.println(str);
         s.show();
         s.method("小强");
     }
 }
 class Student
 {
     private String name;
     private int age;
     //有明确返回值的无参方法
     public String getString()
     {
         return "hello";
     }
     //返回void类型的无参方法
     public void show()
     {
         System.out.println("show run");
     }
     //返回void类型的带参方法
     public void method(String name)
     {
         System.out.println("name:"+name);
     }
 }

07.14 一个标准学生类的代码及测试

类的组成:

1.成员变量

2.构造方法[无参构造方法 / 带参构造方法]

3.成员方法[getXxx() / setXxx()]

给成员变量赋值的方式

1.无参构造方法 + setXxx()

2.带参构造方法

 /*
 学生类:
         成员变量:name，age
         构造方法:无参，带两个参
         成员方法:getXxx()/setXxx()
         show():输出该类的所有成员变量值

     给成员变量赋值:
         A:setXxx()方法
         B:构造方法

     输出成员变量值的方式:
         A:通过getXxx()分别获取然后拼接
         B:通过调用show()方法搞定
 */
 //测试类
 class Demo
 {
     public static void main(String[] args)
     {
         //方式1给成员变量赋值
         //无参构造+setXxx()
         Student s1 = new Student();
         s1.setName("小明");
         s1.setAge(27);
         //输出值
         System.out.println(s1.getName()+"---"+s1.getAge());
         System.out.println("----------------------------");

         //方式2给成员变量赋值
         Student s2 = new Student("小强",30);
         s2.show();
     }
 }

 class Student
 {
     //姓名
     private String name;
     //年龄
     private int age;

     //构造方法
     public Student()
     {
     }

     public Student(String name,int age)
     {
         this.name = name;
         this.age = age;
     }

     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);
     }
 }

07.15 一个标准的手机的代码及测试

 //测试类
 class Demo
 {
     public static void main(String[] args)
     {
         //创建对象
         Phone p = new Phone();

         //给成员变量赋值
         p.setBrand("小米");
         p.setPrice(2299);
         p.setColor("白色");

         //获取值
         System.out.println(p.getBrand()+"---"+p.getPrice()+"---"+p.getColor());
     }
 }

 //定义手机类
 class Phone
 {
     //品牌
     private String brand;
     //价格
     private int price;
     //颜色
     private String color;

     //无参构造方法
     public Phone()
     {
     }

     //getXxx()和setXxx()方法
     public String getBrand()
     {
         return brand;
     }
     public void setBrand(String brand)
     {
         this.brand = brand;
     }

     public int getPrice()
     {
         return price;
     }
     public void setPrice(int price)
     {
         this.price = price;
     }

     public String getColor()
     {
         return color;
     }
     public void setColor(String color)
     {
         this.color = color;
     }
 }

07.16 创建对象做了哪些事情

Student s = new Student();在内存中做了哪些事情?

1.加载Student.class文件进内存

2.在栈内存为s开辟空间

3.在堆内存为学生对象开辟空间

4.对学生对象的成员变量进行默认初始化

5.对学生对象的成员变量进行显示初始化

6.通过构造方法对学生对象的成员变量赋值

7.学生对象初始化完毕，把对象地址赋值给s变量

07.17 什么时候定义成员变量

如果这个变量是用来描述这个类的信息的，那么，该变量就应该定义为成员变量。变量的范围越小越好，因为能及时的被回收。

07.18 长方形案例练习

定义一个长方形类,定义求周长和面积的方法，然后定义一个测试类Demo，进行测试。

 /*
 成员变量:长，宽
 成员方法:
          求周长:(长+宽)*2;
          求面积:长*宽
 */
 import java.util.Scanner;
 class ChangFangXing
 {
     //长方形的长
     private int length;
     //长方形的宽
     private int width;

     public ChangFangXing()
     {
     }

     //仅仅提供setXxx()即可
     public void setLength(int length)
     {
         this.length = length;
     }

     public void setWidth(int width)
     {
         this.width = width;
     }

     //求周长
     public int getZhouChang()
     {
         return (length + width) * 2;
     }

     //求面积
     public int getArea()
     {
         return length * width;
     }
 }

 //测试类
 class Demo
 {
     public static void main(String[] args)
     {
         //创建键盘录入对象
         Scanner sc = new Scanner(System.in);

         System.out.println("请输入长方形的长:");
         int length = sc.nextInt();
         System.out.println("请输入长方形的宽:");
         int width = sc.nextInt();

         //创建对象
         ChangFangXing cfx = new ChangFangXing();
         //先给成员变量赋值
         cfx.setLength(length);
         cfx.setWidth(width);

         System.out.println("周长是:"+cfx.getZhouChang());
         System.out.println("面积是:"+cfx.getArea());
     }
 }

07.19 员工类案例练习

 /*
 成员变量:员工编号，姓名，年龄
 构造方法:无参构造方法
 成员方法:
          getXxx()/setXxx();
          show();
 */

 class Employee
 {
     //员工编号
     private String employeeId;
     //姓名
     private String name;
     //年龄
     private int age;

     //构造方法
     public Employee()
     {
     }

     //getXxx()/setXxx()
     public String getEmployeeId()
     {
         return employeeId;
     }

     public void setEmployeeId(String employeeId)
     {
         this.employeeId = employeeId;
     }

     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("员工编号:"+employeeId+"  姓名:"+name+"  年龄:"+age);
     }
 }

 //测试类
 class Demo
 {
     public static void main(String[] args)
     {
         //创建对象
         Employee e = new Employee();

         //给成员变量赋值
         e.setEmployeeId("ID8899");
         e.setName("旺财");
         e.setAge(18);

         //获取数据
         //System.out.println(e.getEmployeeId()+"---"+e.getName()+"---"+e.getAge());

         //使用show方法
         e.show();
     }
 }

07.20 实现加减乘除并测试

 import java.util.Scanner;
 class MyMath
 {
     //加法功能
     public int add(int a,int b)
     {
         return a + b;
     }

     //减法功能
     public int sub(int a,int b)
     {
         return a - b;
     }

     //乘法功能
     public int mul(int a,int b)
     {
         return a * b;
     }

     //除法功能
     public int div(int a,int b)
     {
         return a / b;
     }
 }

 //测试类
 class Demo
 {
     public static void main(String[] args)
     {
         //创建键盘录入对象
         Scanner sc = new Scanner(System.in);

         System.out.println("请输入第一个操作数:");
         int num1 = sc.nextInt();
         System.out.println("请输入第二个操作数:");
         int num2 = sc.nextInt();

         //创建MyMath对象，并使用
         MyMath mm = new MyMath();

         System.out.println(num1+"+"+num2+"="+mm.add(num1,num2));
         System.out.println(num1+"-"+num2+"="+mm.sub(num1,num2));
         System.out.println(num1+"*"+num2+"="+mm.mul(num1,num2));
         System.out.println(num1+"/"+num2+"="+mm.div(num1,num2));
     }
 }

运行结果:

请输入第一个操作数:
8
请输入第二个操作数:
2
8+2=10
8-2=6
8*2=16
8/2=4

07.21 static关键字的引入

例:

 class Person
 {
     String name;
     //使用static修饰的数据称为对象的共享数据
     static String country = "中国";
     public void show()
     {
         System.out.println("姓名:"+name+"  国家:"+country);
     }
 }

 class Demo
 {
     public static void main(String[] args)
     {
         Person p1 = new Person();
         p1.name = "小明";
         p1.show();

         Person p2 = new Person();
         p2.name = "小红";
         p2.country = "美国";
         p2.show();
         p1.show();

     }
 }

运行结果:

姓名:小明  国家:中国
姓名:小红  国家:美国
姓名:小明  国家:美国

07.22 static关键字的特点

1.static是一个修饰符，用于修饰成员(成员变量和成员函数)

2.static修饰的成员被所有的对象共享

3.static优先于对象存在，因为static成员随着类的加载就已经存在了

4.static修饰的成员可以被对象调用，也可以直接被类名调用，格式为：类名.静态成员

5.static修饰的数据是共享数据，对象中存储的是特有数据

07.23 static的内存图解

07.24 static的注意事项

1.在静态方法中是没有this关键字的

2.静态方法只能访问静态的成员变量和静态的成员方法

3.主函数是静态的，如果要在主函数中调用非静态成员可以创建一个对象来调用

07.25 静态变量和成员变量的区别

1.所属不同

静态变量属于类，所以也称为为类变量

成员变量属于对象，所以也称为实例变量(对象变量)

2.内存中位置不同

静态变量存储于方法区的静态区

成员变量存储于堆内存

3.内存出现时间不同

静态变量随着类的加载而加载，随着类的消失而消失

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

4.调用不同

静态变量可以通过类名调用，也可以通过对象调用

成员变量只能通过对象名调用

07.26 main方法的格式详细解释