Java面向对象（2）

package com.use;

import com.xiaoming.Dog;

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        System.out.println(dog);
        com.xiaoqiang.Dog dog1 = new com.xiaoqiang.Dog();
        System.out.println(dog1);
    }
}

4.包的命名

命名规则：只能包含数字，字母，下划线，点（不能以数字开头，不能是关键字或保留字）

命名规范：com.公司名.项目名.业务模块名

5.常用的包

java.lang.* //基本包，默认引入，不需要再引入
java.util.* //系统提供的工具包，工具类，使用Scanner
java.net.* //网络包，网络开发
java.awt.* //做Java的界面开发，GUI

6.如何引入包

语法：import 包名；

引入一个包的主要目的是要使用该包下的类

import java.util.Scanner; //只引入一个Scanner类
import java.util.*        // 将java.util包全部引入

实例：用系统提供的Arrays完成数组排序

import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        //使用系统提供的Arrays完成数组排序
        int[] arr = {-1, 43, 55, 0, 4};
        Arrays.sort(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

7.注意事项

package的作用是声明当前类所在的包，需要放在类的最上面，一个类最多只有一句package
import指令放在package的下面，在类定义前面，可以有多句且无顺序要求

二，访问修饰符

1.基本介绍

java 提供四种访问控制修饰符号，用于控制方法和属性(成员变量)的访问权限（范围）:

公开级别:用 public 修饰,对外公开
受保护级别:用 protected 修饰,对子类和同一个包中的类公开
默认级别:没有修饰符号,向同一个包的类公开.
私有级别:用 private 修饰,只有类本身可以访问,不对外公开.

2.访问修饰符的访问范围

3.注意事项

修饰符可以用来修饰类中的属性，成员方法以及类
只有默认的和public才能修饰类，并且遵循上述访问权限的特点
成员方法的访问规则和属性完全一样

三，封装

1.基本介绍

封装就是把抽象出的数据[属性]和对数据的操作[方法]封装在一起，数据被保护在内部，程序的其他部分保护在内部，程序的其他部分只有通过被授权的操作[方法]，才能对数据进行操作。

2.作用

隐藏实现细节
可以对数据进行验证，保证安全合理

3.实现步骤

将属性进行私有化private【不能直接修改属性】
提供一个公共的（public）set方法，用于对属性判断并赋值

public void setXxx(类型 参数名){//Xxx表示某个属性
    //加入数据验证的业务逻辑
    属性=参数名;
}

提供一个公共的（public）get方法，用于获取属性的值

public 数据类型 getXxx(){//权限判断，Xxx某个属性
        return xx;
}

eg.

package com.Encapsulation;
/*
不能随便查看人的年龄,工资等隐私，
并对设置的年龄进行合理的验证。年龄合理就设置，
否则给默认年龄, 必须在 1-120, 年龄，
 工资不能直接查看 ， name 的长度在 2-6 字符 之间
 */
public class Encap {

    public static void main(String[] args) {

        Person person = new Person();
        person.setName("Leonsssssssssss");
        person.setAge(1200);
        person.setSalary(0.1);
        //person.salary person.age 将报错
        System.out.println(person.getInfo());

        //如果使用构造器指定属性
        Person leon = new Person("Leon", 20, 2345);
        System.out.println("========Leon========");
        System.out.println(leon.getInfo());
    }
}

class Person {

    public String name;
    private double salary;
    private int age;

    public Person() {
    }

    public Person(String name, double salary, int age) {
//        this.name = name;
//        this.salary = salary;   
//        this.age = age;
        //发现利用构造器可以绕过封装的保护机制
        //于是可以采用在构造器中调用set方法来避免保护失效
        setName(name);
        setSalary(salary);
        setAge(age);
        //此时封装机制的作用范围扩大到构造器
    }
    
    public String getName() {
        return name;
    }

    public void setName(String name) {
        //加入对数据的校验
        if (name.length()>=2&& name.length()<=6) {
            this.name = name;
        } else {
            System.out.println("Wrong length of name");
            this.name="nullname";
        }
    }

    public double getSalary() {
        //添加获取salary信息的条件
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age >= 1&&age<=120) {//如果合理
            this.age = age;
        }else {
            System.out.println("The age shoud between 1~120 ");
            this.age=1;                         //否则赋默认年龄
        }

    }

    public String getInfo(){
        return "信息为： name="+name +" age="+age+" salary="+salary;
    }
}

四，继承

1.基本介绍

继承可以解决代码复用,让我们的编程更加靠近人类思维.当多个类存在相同的属性(变量)和方法时,可以从这些类中抽象出父类,在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过 extends 来声明继承父类即可

2.作用

代码的复用性提高
代码的扩展性和维护性提高

3.基本语法

class 子类 extends 父类{

}

子类就会自动拥有父类定义的属性和方法
父类又叫超类，基类
子类又叫派生类

4.注意事项

子类继承了所有的属性和方法，非私有的属性和方法可以在子类直接访问, 但是私有属性和方法不能在子类直接访问，要通过父类提供公共的方法去访问
子类必须调用父类的构造器，完成父类的初始
当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中用 super 去指定使用父类的哪个构造器完成对父类的初始化工作，否则，编译不会通过
如果希望指定去调用父类的某个构造器，则显式的调用一下 : super(参数列表）
super 在使用时，必须放在构造器第一行(super 只能在构造器中使用）
super() 和 this() 都只能放在构造器第一行，因此这两个方法不能共存在一个构造器
java 所有类都是 Object 类的子类, Object 是所有类的基类.
父类构造器的调用不限于直接父类！将一直往上追溯直到 Object 类(顶级父类)
子类最多只能继承一个父类(指直接继承)，即 java 中是单继承机制
不能滥用继承，子类和父类之间必须有包含关系

五，super关键字

1.基本介绍

super 代表父类的引用，用于访问父类的属性、方法、构造器

2.基本语法

访问父类的属性，但不能访问父类的private属性--super.属性名
访问父类的方法，但不能访问父类的private方法--super.方法名(方法参数列表)
访问父类的构造器，但出现且仅出现在构造器的第一句--super(构造器参数列表)

3.作用与细节

调用父类构造器(分工明确,父类属性由父类初始化,子类属性由子类初始化)
当子类中有和父类的成员,属性或方法重名时,为了访问父类的成员,必须通过super,否则使用super,this,直接访问三种是一样的效果
super的访问不限于直接父类,如果多个基类(上级类)中都有同名的成员,使用super访问遵循就近原则,且同时遵守访问权限的相关规则

4.super 和 this 的比较

六，方法重写/覆盖

1.基本介绍

方法覆盖就是子类有一个方法,和父类的某个方法的名称,返回类型,参数一样,那么我们就说子类的这个方法覆盖了父类的方法

2.使用细节

子类方法的返回类型和父类方法返回类型一样,或者是父类返回类型的子类
子类方法不能缩小父类方法的访问权限 //public > protected >默认>private

3.重载和重写的区别

七，多态

1.基本介绍

方法或对象具有多种形态。是面向对象的第三大特征，多态是建立在封装和继承基础之上的

2.具体体现

(1)方法的多态(重写和重载就体现多态)

public class duotai {
    public static void main(String[] args) {
        //方法重载体现多态
        A a = new A();
        //这里我们传入不同的参数，就会调用不同 sum 方法，就体现多态
        System.out.println(a.sum(10, 20));
        System.out.println(a.sum(10, 20, 30));
        //方法重写体现多态
        B b = new B();
        a.say();
        b.say();
    }
}

class B { //父类
    public void say() {
        System.out.println("B say() 方法被调用...");
    }
}

class A extends B {//子类

    public int sum(int n1, int n2) {//和下面 sum 构成重载
        return n1 + n2;
    }

    public int sum(int n1, int n2, int n3) {
        return n1 + n2 + n3;
    }

    public void say() {
        System.out.println("A say() 方法被调用...");
    }
}

(2)对象的多态

一个对象的编译类型和运行类型可以不一致
编译类型在定义对象时,就已确定
运行类型可以改变
定义时:编译类型 = 运行类型 ( Animal animal=new Dog() )

3.多态注意事项

(1)多态的前提

两个对象（类）存在继承关系

(2)多态的向上转型

本质：父类的引用指向了子类的对象
语法：父类类型引用名 =new 子类类型（）； Animal animal=new Cat（）；
特点：编译类型看左边，运行类型看右边；可以调用父类的所有成员（注意访问权限）；不能调用子类的特有成员；最终运行效果看子类的具体实现（运行类型）；

(3)多态的向下转型

语法：子类类型引用名=（子类类型）父类引用； Cat cat = (Cat) animal；
特点：只能强转父类的引用，不能强转父类的对象；要求父类的引用必须指向的是当前目标类型的对象；当向下转型后，可以调用子类类型中所有的成员；

(4)属性没有重写之说

属性的值看编译类型

public class duotai {
    public static void main(String[] args) {
         //属性没有重写之说！属性的值看编译类型
        Base base = new Sub();//向上转型
        System.out.println(base.count);//10
        Sub sub = new Sub();
        System.out.println(sub.count);//20
    }
}

class Base { //父类
    int count = 10;//属性
}

class Sub extends Base {//子类
    int count = 20;//属性
}

(5)instanceOf比较操作符

用于判断对象的类型是否为XX类型或其子类型

package com;

public class duotai {
    public static void main(String[] args) {
        BB bb = new BB();
        System.out.println(bb instanceof BB);// true
        System.out.println(bb instanceof AA);// true
//aa 编译类型 AA, 运行类型是 BB
//BB 是 AA 子类
        AA aa = new BB();
        System.out.println(aa instanceof AA);//T
        System.out.println(aa instanceof BB);//T
        Object obj = new Object();
        System.out.println(obj instanceof AA);//false
        String str = "hello";
//System.out.println(str instanceof AA);
        System.out.println(str instanceof Object);//true
    }
}
class AA {} //父类
class BB extends AA {}//子类

4.JAVA的动态绑定机制

当调用对象方法时，该方法会和该对象的内存地址/运行类型绑定；
当调用对象属性时，没有动态绑定机制，哪里声明，哪里使用；

public class DynamicBinding {
    public static void main(String[] args) {
//a 的编译类型 A, 运行类型 B
        A a = new B();//向上转型
        System.out.println(a.sum());//?40 -> 30
        System.out.println(a.sum1());//?30-> 20
    }
}

class A {//父类
    public int i = 10;

    //动态绑定机制:
    public int sum() {//父类 sum()
        return getI() + 10;//20 + 10
    }

    public int sum1() {//父类 sum1()
        return i + 10;//10 + 10
    }

    public int getI() {//父类 getI
        return i;
    }
}

class B extends A {//子类
    public int i = 20;

    // public int sum() {
    // return i + 20;
    // }
    public int getI() {//子类 getI()
        return i;
    }
    // public int sum1() {
    // return i + 10;
    // }
}

八，object类详解

1.equals方法

（1）==与equals的比较

==是一个比较运算符：如果判断基本类型，则判断值是否相等，如果判断引用类型，则判断地址是否相等，即判断是否为一个对象
equals是object类中的方法，只能判断引用类型。默认判断的是地址是否相等，子类中往往重写该方法，用于判断内容是否相等（Integer String）

（2）源码（Ctrl+B查看）

//Object 的 equals 方法默认就是比较对象地址是否相同
//也就是判断两个对象是不是同一个对象. 
    public boolean equals(Object obj) {
        return (this == obj);
}

String.equals

    public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

Integer.equals

    public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false;
    }

2.hashcode方法

hashCode可以提高具有哈希结构的容器的效率
哈希值主要根据地址得来的，但不能完全将哈希值等

3.toString方法

默认返回：全类名+@+哈希值的十六进制，子类往往重写 toString 方法，用于返回对象的属性
重写 toString 方法，打印对象或拼接对象时，都会自动调用该对象的 toString 形式

//重写 toString 方法, 输出对象的属性
//使用快捷键即可 alt+insert -> toString
@Override
    public String toString() { //重写后，一般是把对象的属性值输出，当然程序员也可以自己定制
        return "Monster{" +
        "name='" + name + '\'' +
        ", job='" + job + '\'' +
        ", sal=" + sal +
        '}';
}

当直接输出一个对象时，toString 方法会被默认的调用, 比如 System.out.println(dog)；就会默认调用 dog.toString()

package com.use;

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        System.out.println(dog);
    }
}

Object 的 toString() 源码

(1)getClass().getName() 类的全类名(包名+类名 )

(2)Integer.toHexString(hashCode()) 将对象的 hashCode 值转成 16 进制字符串

    public String toString(){
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

4.finalize方法

1) 当对象被回收时，系统自动调用该对象的 finalize 方法。子类可以重写该方法，做一些释放资源的操作

2) 什么时候被回收：当某个对象没有任何引用时(AA=null;)，则 jvm 就认为这个对象是一个垃圾对象，就会使用垃圾回收机制来销毁该对象，在销毁该对象前，会先调用 finalize

3) 垃圾回收机制的调用，是由系统来决定(即有自己的 GC 算法), 也可以通过 System.gc() 主动触发垃圾回收机制

vⅤ_Leon

关注

7
点赞
踩
7

收藏

觉得还不错? 一键收藏
打赏
10
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录