java面向对象（上）

一、java面向对象学习的三条主线
    1.java类以及类的成员：属性、方法、构造器；代码块、内部类。
    2.面向对象的三大特征：封装性，继承性，多态性，（抽象性）。
    3.其他关键字：this，super，static，final，abstract，interface，package，import。

 

理解面向过程和面向对象的区别

/*
理解面向过程和面向对象的区别
例子：人把大象装进冰箱
    1.面向过程：强调的是功能性为，以函数为最小单位，考虑怎么做。
        1）把冰箱打开
        2）抬起大象，塞进冰箱
        3）把冰箱门关闭
    2.面对对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
        人{
            打开(冰箱){
                冰箱.打开门();
            }
            抬起(大象){
                大象.进入(冰箱)；
            }
            关闭(冰箱){
            冰箱.关门();
        }

        冰箱{
            打开门(){}
            关门(){}
        }

        大象{
            进入(冰箱){}
        }

 */

——

类和对象

面向对象程序设计的重点是类的设计，在一个就是设计类的成员。

• 类：类是对一类事物的描述，是抽象的、概念上的定义。
• 对象：对象时实际存在的该类事物的每个个体，因而也称为实例。

可以理解为：类=抽象概念的人；对象=实实在在存在的某个人。

常见的类的成员有：

                        属性：对应类中的成员变量。

                        行为：对应类中的成员方法。

• 属性和方法：

属性=成员变量=field=域或字段。

方法=成员方法=函数=method。

例如生活中如：人有身高和体重的属性，有说话和打球等行为。

/*
类和对象的使用：
    1.创建类，设计类的成员。
    2.创建类的对象。
    3.通过对象.属性/方法 来调用对象的结构。
*/
public class OOPTest {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.name = "Tom";
        p1.Male = true;
        System.out.println(p1.name);
        p1.eat();
        p1.sleep();
        p1.talk("Chainese");
    }

}

class Person{
    //属性
    String name;//姓名
    int age;//年龄
    boolean Male;//性别

    //方法
    public void eat(){
        System.out.println("吃饭");
    }
    public void sleep(){
        System.out.println("睡觉");
    }
    public void talk(String language){
        System.out.println("说话，说的语言是："+language);
    }

}

——————————

对象的内存解析

————

•  堆(Heap)：此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都是在这里分配内存。这一点在java虚拟机规范中的描述是：所有的对象实例以及数组都要在堆上分配。
• 栈(Stack)：是指虚拟机栈。虚拟机栈用来存储局部变量。局部变量表存放了编译期可知长度的各种基本数据类型、对象引用。方法执行完，自动释放。
• 方法区(Method Area)：用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。

属性与局部变量

/*
类中属性的使用：属性(成员变量) 与 局部变量
    1.相同点：
        1.1 定义变量的格式都一样。
        1.2 先声明，后使用。
        1.3 变量都有其对应的作用域。

    2.不同点：
        2.1 在类中声明的位置不同
            属性直接配置在{}内
            局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量。
        2.2 关于权限修饰符的不同
            属性：可以在声明属性时 指明其权限修饰符，使用权限修饰符。
            常用的权限修饰符：private,public,缺省(就是不写),protected
            局部变量：不可以使用权限修饰符。
        2.3 默认初始化值的情况：
            属性：类的属性，根据其类型都有默认初始化值。
            局部变量：没有默认初始化值，所以调用之前一定要设置其值。
        2.4 在内存中加载的位置：
            属性：堆空间中。(static除外)
            局部变量：栈空间中。

 */

public class UserTest {

}
class User{
    //属性
    int a;
    int b;
    int c;
    public void talk(int lange){
        System.out.println(lange); //lange就是方法形参，局部变量。
        int d; //d是在方法内声明的，也是局部变量。
    }

}

————————

方法的使用

/*
类中方法的声明和使用

    方法：描述类应具有的功能。
    例如：Scanner类,sort类......
    1. 举例：
        public void eat(){}
        public void sleep(int hour){}
        public String getName(){}
        public String getNation(String nation){}

    2. 方法的声明：权限修饰符 返回值类型 方法名(形参列表){
           方法体
    }
    3.1 权限修饰符：
        private:私有,public：公共,缺省,protected
    3.2 返回值类型：
        有返回值：

        无返回值：
    return关键字的使用：
    1. 使用范围：使用在方法体中
    2. 作用：
        结束方法体；
        对于偶遇返回值类型的方法，使用return可以结束方法并返回所要的数据。
    3. return 关键字后面不可以声明执行语句。
    方法的使用中，可以调用当前类的属性或方法
        特殊的：方法a中调用方法a，这就是递归，但是一定要注意无限循环，这样会栈溢出。
    方法中不可以定义方法

 */

——————

对象数组的内存解析

过程图

 匿名对象的使用

/*
匿名对象：
    理解：创建的对象没有显式的赋给一个变量名，则是匿名对象
    特征：匿名对象只能调用一次，一次性的
 */
public class Cussaa {
    public static void main(String[] args) {
        Phone p = new Phone();
        System.out.println(p);
        p.sendEmail();
        p.playGame();

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


        new Phone().price = 2999;
        new Phone().showPrice();//0.0
        //所以说上面算new了两个对象


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


    }

}

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

class Phone{
    double price;
    public void sendEmail(){
        System.out.println("发送邮件");
    }
    public void playGame(){
        System.out.println("玩游戏");
    }
    public void showPrice(){
        System.out.println("手机价格："+price);
    }
}

——————

方法的重载

重载的概念：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数
类型不同即可。

“两同一不同”：同一个类，同一个方法名；参数不同（参数列表，参数个数，参数类型）

重载的特点：与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类
型)。调用时，根据方法参数列表的不同来区别。

示例：

//返回两个整数的和
int add(int x,int y){return x+y;}
//返回三个整数的和
int add(int x,int y,int z){return x+y+z;}
//返回两个小数的和
double add(double x,double y){return x+y;}

————

• 判断是否是重载：根方法的权限修饰符，返回值类型，形参变量名，方法体都没有关系！
• 在通过对象调用方法时，如何确定某一个指定的方法：

        方法名-->参数列表-->

可变个数形参的方法

package day01;


/*
可变个数形参的方法：
    1. jdk 5.0后新增的内容
    2. 具体使用
        2.1 可变个数形参的格式：数据类型 ... 变量名
        2.2 当调用可变个数形参的方法时，传入的参数个数可以是：0,1,2...等等任意个
        2.3 可变个数形参方法与本类中方法名相同，形参不同的方法之间构成重载
        2.4 public void show(String[] strs),会与这种方法冲突，不可共存
        2.5 可变个数形参在方法的形参中，必须声明在末尾
        2.6 可变个数形参当中最多只能声明一个可变形参

 */
public class a2 {

    public static void main(String[] args) {
        a2 test = new a2();
        test.show(12);
        test.show("hello");
        test.show("sss","sss");
        test.show();

    }

    public void show(int i){
        System.out.println(i);
    }
    public void show(String s){
        System.out.println(s);
    }

    public void show(String ... strs){
        //类似于：public void shouw(String[] strs){}
        System.out.println(3);
        //把若干个参数当做数组来遍历调用就行
        for(int i=1;i<strs.length;i++){
            System.out.println(strs[i]);
        }
    }
//    public void show(String[] strs){
//        与可变个数形参冲突，不可共存
//    }
    //2.5 可变个数形参在方法的形参中，必须声明在末尾，例如下面的就不对
//    public void show(String ... strs,int i){
//
//    }
}

---

值传递机制

1. 形参：方法定义时，声明的小括号内的参数

实参：方法调用时，实际传递给形参的数据

2. 值传递机制：

        如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。

        如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值。

递归方法

有限循环，一定要注意防止陷入死循环。

封装和隐藏

package day01;

/*
封装与隐藏
1. 问题的引入
    当我们创建一个类的对象以后，我们可以通过“对象.属性”的方式，对对象的属性进行赋值，
    这里，赋值操作要受到属性的数据类型和存储范围的制约，除此之外，没有其他制约。
    但是，在实际为题当中我们需要给属性赋值加入额外的限制条件，这个条件不能在
    属性声明时体现，我们只能通过方法进行限制条件的添加。
    同时，我们需要避免用户再使用“对象.属性”的方式对属性进行赋值。则需要将属性声明为私有的（private）。
    以上，就是体现了属性的封装性。
2. 封装性的体现
    我们将类的属性私有化，同时，提供公共的（public）方法来获取（getxxx）和设置（setxxx）。
    
3. 拓展
    不对外暴露的私有方法
    单例模式
    
 */

public class a3 {
    public static void main(String[] args) {
        Animal a = new Animal();
        a.name = "猫猫";
        a.age = 1;
//        a.legs = 4;
        a.setLegs(4);
        a.show();
    }

}

class Animal{
    String name;
    int age;
    private int legs;
    //对属性的设置：set
    public void setLegs(int l){
        if(l>=0&&l%2==0){
            legs = l;
        }else{
            legs = 0;
        }
    }
    //对属性的获取
    public int getLegs(){
        return legs;
    }

    public void eat(){
        System.out.println("动物进食");
    }
    public void show(){
        System.out.println("name = "+name+",age = "+age+",legs = "+legs);
    }
}

---

四种权限修饰符

封装性的体现需要权限修饰符的配合。

java规定了四种权限（从小到大排列）：private，缺省（什么也不写），protected，public。

 

 四种权限可以用来修饰类及类的内部结构：属性，方法，构造器，内部类。

四种权限都可以用来修饰类的内部结构。

修饰类只能有缺省和public。

构造器（构造方法）

任何一个类都有构造器

package day01;

/*
类的结构：构造器的使用（constructor）
比如：new Person();
new后面的Person()就是一个默认构造器。
注意：构造器不等同于方法
1. 说明
    1.1 如果没有显式的定义类的构造器的话，则系统默认提供一个空参的构造器。
    1.2 定义构造器的格式：权限修饰符 类名(形参列表){}
    1.3 一个类中可以定义多个构造器
    1.4 一个类中定义的多个构造器可以重载
    1.5 一旦我们显式的定义了类的构造器之后，系统就不在提供默认的空参的构造器
    1.6 一个类中至少有一个构造器

2. 构造器的作用：
    构造器的作用就是创建对象。
    构造器可以给对象进行初始化。
 */

public class a4 {
    //new一个构造器
    Parsonn p = new Parsonn();
    Parsonn p1 = new Parsonn("tom");
}

class Parsonn{
    String name;
    int age;

    //构造器
    public Parsonn(){

    }
    public Parsonn(String n){
        name = n;
    }

    public void eat(){
        System.out.println(111);
    }
}

---

补充：默认构造器的权限和类的权限相同。

JavaBean

JavaBean是一种java语言写成的可重用组件。

所谓JavaBean是指符合如下标准的Java类：

• 类是公共的
• 有一个无参的公共的构造器
• 有属性，且有对应的get、set方法

用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用Java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关
心任何改变。

UML图

 

---

this关键字的使用

package java1;

/*
this关键字的使用
1. this可以用来修饰属性、方法、构造器
2. this来修饰属性和方法：
    this理解：代表当前对象或当前正在创建的对象
    2.1 this理解为当前对象
        在类的方法中，我们可以使用”this.属性“或者“this.方法”的方式，调用当前对象的属性方法。
        但是，通常情况下省略“this.”。
        特殊情况下，如果方法的形参和类的属性同名时，我们必须显式的使用“this.”来表明此变量是属性而非形参。
    2.2 构造器同2.1一样
3. this调用构造器
    3.1 我们在类的构造器中，可以显式的使用“this(形参列表)”方式来调用本类中指定的其他构造器。
    3.2 构造器中不能通过“this(形参列表)”的方式调用自己
    3.3 如果一个类中有n个构造器，则最多有n-1个构造器中使用了“this(形参列表)”
    3.4 规定：“this(形参列表)”必须声明在当前构造器的首行
    3.5 构造器内部：最多只有一个“this(形参列表)”，用来调用其他构造器


 */

public class PersonTest {
    public static void main(String[] args) {
        Person pp = new Person();
        pp.setAge(1);
        System.out.println(pp.getAge());
        pp.eat();

    }
}

class Person{
    private String name;
    int age;

    public void setName(String name){
        //name = name;//这样写用的都是参数中的name，服从就近原则，参数的name优先级高
        this.name = name;//this相当于代表的当前对象
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age = age;
    }
    public int getAge(){
        return age;
    }
    public void eat(){
        System.out.println("人吃饭");
        this.sleep();
    }
    public void sleep(){
        System.out.println("人睡觉");
    }
    public Person(){
        this.eat();
    }
    public Person(String name){
        this(); //表示调用无参的构造器：public void Person(){}

        this.name = name;
    }
    public Person(int age){

        this.age = age;

    }
    public Person(String name,int age){
        this(age); //同理，调用构造器
        this.name = name;
        //this.age = age;
    }

}

---

package关键字的使用

用来导包。

1. 为了更好的实现项目中的管理，提出了包的概念
2. 使用package声明类或接口所属的包，声明在源文件的首行
3. 包属于标识符，遵循标识符的命名规则
4. 每“.”一次就代表一层文件目录

补充：

• 同一个包下，不能命名同名的接口和类
• 不同的包下，可以命名同名的接口和类

---

 import关键字的使用

1. 在源文件中使用import显式的导入指定包下的类或接口
2. 声明在包的声明和类的声明之间
3. 如果需要导入多个类或接口，那么就并列的显式多个import语句即可
4. 举例：可以使用java.util.*的方式，一次性导入util下所有的类或接口
5. 如果导入的类或接口是java.long包下的，或者是当前包下的，则可以省略此import语句
6. 如果在代码中使用不同包下的同名的类，那么就需要使用类的全类名的方式指明调用的是哪个类
7. 如果已经导入java.a包下的类，那么如果需要使用a包下的子类的话，仍然需要导入
8. import static组合的使用：调用指定类或接口下的静态的属性或方法