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方法的格式详细解释