面向对象+private+this

一.面向对象

1.概述

封装不同的步骤和功能,使用时直接使用,不必一步步写出

2.特征

封装 :把属性和方法封装到一个类中
继承:子类继承父类
		子类对父类方法的覆盖重写和同一个类中的方法的重载
多态:父类引用指向子类对象


重载:同一个类中,方法名相同,参数列表不同,称之为方法的重载,与返回值类型无关
重写:子类对父类方法的覆盖重写,方法名相同,参数列表相同,只是方法的方法体不同.

3.类与对象

属性:就是该事物的描述信息
功能:就是该事物能够做什么
			事物				       类
			
			属性	----------------- 成员变量
			功能	----------------- 成员方法
			
类：是一组相关的属性和行为的集合
对象：是该类事物的具体体现
定义类就是定义类的成员:(1)成员变量:定义在类中,方法外(2)成员方法

4.创建对象

格式:类名 对象名=new 类名();如Person person=new Person();
使用成员变量:对象名.变量名;如person.name;
使用成员方法:对象名.方法名(...);person.eat(){......};

案例一:

Person类

public class Person {
    //定义成员变量
    int age=22;
    String name="马飞飞";
    char sex='男';
    //定义成员方法
    public void eat(){
        System.out.println("吃饭");
    }
    public void sleep(){
        System.out.println("睡觉");
    }
    public void piay(){
        System.out.println("玩游戏");
    }
}

测试类

public class MyTest {
    public static void main(String[] args) {
        Person person=new Person();
        String name = person.name;
        int age = person.age;
        char sex = person.sex;
        System.out.println(name);//马飞飞
        System.out.println(age);//22
        System.out.println(sex);//男
        System.out.println("=====================");
        name="卢本伟";
        age=18;
        sex='女';
        System.out.println(name);//卢本伟
        System.out.println(age);//18
        System.out.println(sex);//女
    }

案例二:

手机类

public class Phone {
    //成员变量
    String brand="苹果";
    double price=3000.0;
    String color="白色";

    //定义成员方法
    public void call(String name){
        System.out.println("给"+name+"打电话");
    }
    public void sendMessage(String name,String content){
        System.out.println("给"+name+"发信息"+"内容是"+content);
    }
}

测试类

public class MyTest2 {
    public static void main(String[] args) {
        Phone phone=new Phone();
        String brand = phone.brand;
        String color = phone.color;
        double price = phone.price;
        System.out.println(phone);//@1540e19d
        System.out.println(brand);//苹果
        System.out.println(color);//白色
        System.out.println(price);//3000.0
        System.out.println("================");
        brand="华为";
        color="黑色";
        price=1000.0;
        System.out.println(brand);//华为
        System.out.println(color);//黑色
        System.out.println(price);//1000.0
    }
}

案例三:

成员变量不赋值会有默认值

学生类

public class Student {
    String name;
    int age;
    long id;
    double score;
    public void study(){
        System.out.println("学习");
    }
    public void eat(){
        System.out.println("吃饭");
    }

测试类

public class MyTest3 {
    public static void main(String[] args) {
        /*
        成员变量不赋值会有默认值
        * */
        Student student=new Student();
        int age = student.age;
        long id = student.id;
        String name = student.name;
        double score = student.score;
        System.out.println(age);//0
        System.out.println(id);//0
        System.out.println(name);//null
        System.out.println(score);//0.0
        System.out.println("===============");
        age=27;
        id=1111111;
        name="陈一发";
        score=100.0;
        System.out.println(age);//27
        System.out.println(id);//1111111
        System.out.println(name);//陈一发
        System.out.println(score);//100.0
    }
}

二.对象内存图

1.一个对象的内存图

2.两个对象的内存图

3.三个对象的内存图

三.成员变量和局部变量

1.定义:

成员变量:定义在类中,方法外
局部变量:定义在方法内部或者方法的声明上(形参)

2.区别:

1)
成员变量:成员变量属于对象,随着对象的创建的创建而产生，随着对象的消失而消失。
局部变量:局部变量属于方法,局部变量随着方法的调用而产生，随着方法的调用完毕而消失。
2)
成员变量有默认值
局部变量没有默认值,需要初始化才能使用
3)
成员变量在堆内存
局部变量在栈内存

public class Student {
    //定义成员变量
    String name;
    int age;
    
    //定义局部变量
    public  void  show(String name,int age){
        System.out.println(name);
        System.out.println(age);
    }
}

public class MyTest {
    public static void main(String[] args) {
        Student student = new Student();
        student.show("张三",20);
    }
}

//我们可以在一个Java文件中，并列定义多个类。要求是 只能这个有主方法的类前面加上public,要么全部都不加public
//但是我们建议 一个类就是一个Java文件
class MyTest2{
    
}

class MyTest3{
    
}

四.匿名对象

1.定义

没有名字的对象

2.应用场景

调用方法，仅仅只调用一次的时候。
匿名对象可以作为实际参数传递

案例

package org.westos.demo;

public class Student {
    //定义成员变量
    String name;
    int age;

    //定义局部变量
    public  void  show(String name,int age){
        System.out.println(name);
        System.out.println(age);
    }
}


package org.westos.demo;

public class MyTest4 {
    public static void main(String[] args) {
        Student student=new Student();
        student.show("里斯",33);

        //使用匿名对象,适用于调用方法，仅仅只调用一次的时候。
        new Student();
        new Student().show("王五",44);

        //方法调用多次时,不能使用匿名对象
        Student student2=new Student();
        student2.show("哈哈哈",88);
        student2.show("哈哈哈",88);
        student2.show("哈哈哈",88);
    }

    //匿名对象可以作为参数传递
 	show2(new Student());
 	
    public void show2( Student student){
        System.out.println(new Student().age);//88
    }
}

五.封装

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

封装好处:
		隐藏实现细节，提供公共的访问方式
		提高了代码的复用性
		提高安全性。
封装原则:
		将不需要对外提供的内容都隐藏起来。
		把属性隐藏，提供公共方法对其访问

六.private关键字

1通过对象直接访问成员变量是不被允许的，这样会导致一些未知的错误，所以在日常使用时，我们将成员变量通常设置成private权限，这样就不能在成员变量所在类外去通过对象直接调用成员变量，我们通过一个成员变量建立两个类来对成员变
2是一个权限修饰符
3可以修饰成员变量和成员方法
4被其修饰的成员只能在本类中被访问

public class Student {
    private String name;
    int age;

    public void show(){
        System.out.println(age);
    }
    public void setAge(int nianLing){
        age=nianLing;
    }
    public int getAge(int age){
        return age;
    }
}

public class MyTest {
    public static void main(String[] args) {
        Student student=new Student();
        //student.name="里斯";//报错,private只能访问本类
        student.age=19;
        student.show();//19
        student.setAge(22);
        student.show();//22
        student.getAge(44);//44
    }
}

四种权限修饰符

				本类       本包      子类         外包
 public 		可			可			可			可
protected 		可			可			可
(default) 		可			可
private			可

七.this关键字

1.引入this的原因

当我们的局部变量和成员变量相同的时候,如果我们不使用this关键字,那么
会导致一个问题:就是局部变量隐藏了成员变量的问题

变量访问就近原则:当成员变量与局部变量重名,先在局部范围类使用,找到即使用;
否则去成员范围找,找到就使用

2.特点:

它就代表当前类的一个对象。谁调用这个方法,那么该方法的内部的this就代表谁

局部变量和成员变量重名时,打印的是默认值

package org.westos.demo3;

public class MyTest {
    public static void main(String[] args) {
        Student student=new Student();
        student.setName(student,"李四");
        student.setAge(student,19);

        String name = student.getName();
        int age = student.getAge();
        System.out.println(name);//null
        System.out.println(age);//0

    }
}

class Student{
    private String name;
    private int age;

    public void setName(Student student,String name){
        name=name;
    }
    public String getName(){
        return name;
    }
    public void setAge(Student student,int age){
        age=age;
    }
    public int getAge(){
        return age;
    }
}

可以采用创建对象调用方法来解决
可以将对象换为this

package org.westos.demo4;

public class MyTest {
    public static void main(String[] args) {
        Student student=new Student();
        student.setName(student,"李四");
        student.setAge(student,19);

        String name = student.getName();
        int age = student.getAge();
        System.out.println(name);//李四
        System.out.println(age);//19

    }
}

class Student{
    private String name;
    private int age;

    public void setName(Student student,String name){
        student.name=name;
    }
    public String getName(){
        return name;
    }
    public void setAge(Student student,int age){
        student.age=age;
    }
    public int getAge(){
        return age;
    }
}

package org.westos.demo4;

public class MyTest {
    public static void main(String[] args) {
        Student student=new Student();
        student.setName("李四");
        student.setAge(19);

        String name = student.getName();
        int age = student.getAge();
        System.out.println(name);//李四
        System.out.println(age);//19

    }
}

class Student{
    private String name;
    private int age;

    public void setName( String name){
        this.name=name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age=age;
    }
    public int getAge(){
        return age;
    }
}

总结:

1.Java中基本数据类型是值传递,引用数据类型是引用传递
2.面向对象三大特征:
	1)封装:Java中的类封装了成员变量的属性和成员方法的功能
	2)继承:子类对父类的继承
			(1).在子类继承父类的时候,子类必须调用父类的构造函数。
			(2).如果父类有默认构造函数,子类实例化时自动调用,但如果父类没有默认构造函数,即无形参构造函数,子类构造函数必须通过super调用父类的构造函数。
			(3).还有在java的继承当中子类是不可以继承父类的构造函数只能调用,这是肯定的。
3.四种权限修饰符:
				本类       本包      子类         外包
 public 		可			可			可			可
protected 		可			可			可
(default) 		可			可
private			可
4.this关键字:
		使用this代表当前类的调用方法的对象