java基础之面对对象(上)

1、简介

一、java面对对象学习的三条主线:(第4-6章)
1.java类及类的成员:属性、方法、构造器:代码块、内部类
2.面对对象的三大特征:封装、继承、多态性、（抽象性）
3.其它关键字:this、super、static、final、abstract、interface、package、import等
"大处着眼，小处着手"
三、面向对象的两个要素:
类:对一类事物的描述,是抽象的、概念上的定义
对象:是实际存在的该类事物的每个个体，因而也称为实例(instance)

 面对对象程序设计的重点是类的设计
 设计类:就是设计类的成员

2、类的设计:

一、设计类，就是设计类成员
属性 = 成员变量 = field = 域、字段
方法 = 成员方法 = 函数 = method

创建类的对象 = 类的实例化 = 实例化类

二、类和对象的使用(面向对象思想落地的实现)
1.创建类,设计类的成员
2.创建类的对象
3.通过"对象.属性"或"对象.方法"调用对象结构

三、如果创建了一个类的多个对象，则每个对象都独立的拥有一套属性。(非static的)
意味着:如果我们修改一个对象属性a，则不影响另外一个对象属性a的值。

四、对象的内存解析:略

举例：

   public static void main(String[] args) {
        //2.创建Person对象
        Person p1=new Person();

        //3.调用对象的结构:属性、方法

        //调用属性:"对象.属性"
        p1.name = "Tom";
        p1.isMale =true;
        System.out.println(p1.name);

        //调用方法:"对象.方法"
        p1.eat();
        p1.sleeep();
        p1.talk("Chinese");

        //*******************************
        Person p2 = new Person();
        System.out.println(p2.name);//null
        System.out.println(p2.isMale);//false

        //**********************************
        //把p1变量保存的地址赋值给p3,导致p1和p3指向堆空间中的同一个对象实体
        Person p3= p1;
        System.out.println(p3.name);

        p3.age=10;
        System.out.println(p1.age);
    }
}

//1.创建类,设计类的成员
class  Person{
    //属性
    String name;
    int age = 1;
    boolean isMale;

    //方法
    public  void eat(){
        System.out.println("人在吃饭");
    }
    public  void sleeep(){
        System.out.println("人在睡觉");
    }
    public void talk(String language){
        System.out.println("人可以说话，使用的是:"+language);
    }

三、类中属性的使用:

属性(成员变量) VS 局部变量
1.相同点:
1.1定义变量的格式:数据类型 变量名 = 变量值
1.2先声明，后使用
1.3变量都有其对应的作用域
2.不同点:
2.1在类中声明的位置不同
属性:直接定义在类的一对{}内
局部变量:声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
2.2关于权限修饰符的不同
属性:可以在声明属性时，指明其权限，使用权限修饰符
常用的权限修饰符:private、public、确省、protected —>封装性
目前:大家声明属性时，都使用缺省就可以了
局部变量:不可以使用权限修饰符
2.3默认初始化值的情况
属性:类的属性,根据其类型，都有默认初始化值
整型:(byte、short、int、long) 0
浮点型:(float、double) 0.0
字符型:(char):0 (或’\u0000’)
布尔型:(boolean) false
引用数据类型(类、数组、接口):null

局部变量:没有默认的初始化值.
意味着:我们在调用局部变量之前，一定要显示赋值
特别地:形参在调用时，我们赋值即可。
2.4在内存中加载的位置:
属性:加载到堆空间中(非static)
局部变量:加载到栈空间

举例：

 public static void main(String[] args) {
        User u1=new User();
        System.out.println(u1.name);
        System.out.println(u1.age);

        u1.talk("日语");
}
class User{
    //属性(或成员变量)
    //private String name;
    String name;
    public int age;
    boolean isMale;

    public void talk(String language){//language:形参,也是局部变量
        System.out.println("我们使用" + language +"进行交流");
    }

    public void eat(){
        //private String food ="烙饼";//局部变量,不可以使用权限修饰符
        //可以理解为方法代替了，方法时public局部变量就是public
        String food ="烙饼";//局部变量
        System.out.println("北方人喜欢吃"+food);
    }

}

四、类中方法的声明和使用：

方法:描述类应该具有的功能。
比如:Math类:sqrt()\random()…
Scanner类:nextXxx()…
Arrays类:sort()\binarySearch()\toString()\equals()…

1.举例:

 public void eat(){}
 public void sleep(int hour){}
 public String getName(){}
 public String getNation(String nation){}

2.方法的声明:

权限修饰符 返回值类型 方法名(形参列表){
         方法体
}
注意:static、final、abstract来修饰的方法，后面再讲

3.说明:
3.1关于权限修饰符:默认方法的权限修饰符先都使用public
java规约的4钟权限修饰符:private、public、缺省、protected -->封装性再说
3.2返回值类型:有返回值vs没有返回值

3.2.1如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时,方法中,需要使用
return关键字来返回指定类型的变量或者常量:"return 数据"
    如果没有返回值，则方法声明时，使用void来表示。通常，没有返回值的方法中，就不需要
使用return。但是，如果使用的话,只能"return;"表示结束此方法的意思。
3.2.2  我们定义方法该不该有返回值？

3.3 方法名:属于表示符，遵循表示符的规则和规范，“见名知意”
3,4 形参列表:方法可以声明0个，1个，或多个形参

 3.4.1 格式:数据类型1 形参1,数据类型2 形参2,...
 3.4.2 我们定义方法时,该不该定义形参?
       1.题目要求
       2.经验

3.5 方法体:方法功能的体现

4.return关键字的使用:

1.使用范围:使用在方法体中
2.作用: 1、结束方法
        2、针对有返回值类型的方法，使用"return 数据"方法返回所要的数据。
3.注意点:return关键字后面不可以声明执行语句

5.方法的使用:可以调用当前类的属性或方法

 特殊的:方法A中又调用了方法A:递归方法
 方法中,不可以定义方法。

举例:

 public static void main(String[] args) {
        Customer customer=new Customer();
        customer.eat();

        //声明Customer类型的数组
        Customer[] cs=new Customer[20];//对象数组 String[] arr=new String[20];
        for (int i = 0; i <cs.length ; i++) {
            //给数组元素赋值
            cs[i] = new Customer();
            //给Customer对象的属性赋值
            cs[i].age=i+1;
        }
        for (int i = 0; i <cs.length ; i++) {
            System.out.println("年龄"+cs[i].age+","+cs[i].isMale);

            //方式二:
            System.out.println(cs[i].infoOut());
        }
    }
}
//客户类
class Customer{
    //属性
    String name;
    int age;
    boolean isMale;

    //方法
    public void eat(){
        System.out.println("客户吃饭");
        return;//结束方法

        //System.out.println("hello");//return后不可以声明表达式
    }

    public void sleep(int hour){
        System.out.println("休息了 "+ hour +"个小时");
    }

    public String getName(){
        return name;
    }

    public String getNation(String nation){
        String info="我的国籍是:"+nation;
        return info;
    }

    public void info(){
        //public void swim(){} //方法中不能定义方法
    }
    //显示信息方法
    public String infoOut(){
        return "年龄"+ age + "性别" +isMale;
    }

五、匿名对象的使用

1.理解:我们创建的对象，没有显式的赋给一个变量名。即为匿名对象
2.特征:匿名对象只能调一次。
3.使用:

     public static void main(String[] args) {
        Phone p =new Phone();

        p.sendEmail();
        p.playGame();

        //匿名对象
        new Phone().sendEmail();
        new Phone().playGame();

        new Phone().price=100;
        new Phone().playGame();//0.0

        //********************************************
        PhoneMall phoneMall=new PhoneMall();
        //匿名对象的使用
        phoneMall.show(new Phone());
}

class PhoneMall{
    public void show(Phone phone){
        phone.sendEmail();
        phone.playGame();
    }
}

class Phone{
    double price;//价格

    public void sendEmail(){
        System.out.println("发送邮件");
    }
    public void playGame(){
        System.out.println("玩游戏"+price);
    }

六、方法的重载(overload)loading…

1.定义:

在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
   "两同一不同":同一个类、相同方法名
               参数列表不同:参数个数不同，参数类型不同(参数的顺序)

2.举例:
Arrays类中重载的sort() / binarySearch()

3.判断是否重载:
跟方法的权限修饰符、返回值类型、形参变量名、方法体都没关系!

4.在通过对象调用方法时，如何确定一个指定的方法:
方法名—>参数列表

public class OverLoad {
    public static void main(String[] args) {
        OverLoad test=new OverLoad();
        test.getSum(1,2);
    }

    //如下4个方法构成了重载
    public void getSum(int i,int j){
        System.out.println("1");
    }
    public void getSum(double d1,double d2){
        System.out.println("2");
    }
    public void getSum(String s,int i){
        System.out.println("3");
    }
    public void getSum(int i,String s){
        System.out.println("4");
    }

//    public int getSum(int i,int j){
//
//    }

//    public void getSum(int m,int n){
//
//    }

补充:
关于变量赋值

• 如果变量是基本数据类型,此时赋值的是变量所保存的数据值。
• 如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。

方法形参的传递着值:值传递
1.

• 传参:方法定义时，声明的小括号的参数
• 实参:方法调用时，实际传递给形参的数据

2.值传递机制:

• 如果参数是基本数据类型，此时实参赋给形参的是，实参真实存储的数据值。
• 如果参数是引用数据类型，此时实参赋给形参是实参存储数据的地址值。
  递归方法的使用(了解)
• 1.递归方法:一个方法体内调用它自身
• 2.方法的递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无需循环体控制。