面向对象3

Object类

1.“==和equals”的区别

1.“==”运算符：判断值是否相等
可以使用在基本数据类型和引用数据类型中
1).基本数据类型中：比较两个变量保存的数据是否相等（类型不一定要相同）
2).引用数据类型中：比较两个对象的地址值是否相同，即两个引用是否指向同一个对象实体

int a = 10;
char c = 10;
syso(c==a);//true

int b = 10;
double c = 10.0;
syso(b == c);//true

char a = 'A';
char b = 65;
syso(a == b );//true

2.“equals”方法
是一个方法，而非运算符；只 能适用于引用数据类型；Object中“equals和==”作用相同，都比较地址值；像String、Data、File等重写了Object中的equals方法，比较的不再是地址值，而是“实体”内容

Customer c1 = new Customer("zhangsan");
Customer c2 = new Customer("zhangsan");
syso(c1.equals(c2));//false,使用的Object中的equals方法

String s1 = new String("aa");
String s2 = new String("aa");
syso(s1.equals(s2));//true，重写了Object中的equals方法

2.重写equals方法：比较内容是否相同

int age;//基本数据类型直接比较数据值
String name;//重写了Object中的equals，比较的是内容
public boolean equals(Object obj){
if(this == obj){//地址相同
return true;
}
if(obj instanceof Customer){
Customer c = (Customer)obj;//强转
//比较两个对象的每个属性是否相同
return this.age == c.age && this.name.equals(c.name)；//基本数据类型使用==比较，引用数据类型用equals比较
}
}

equals和==的区别

1.==对基本数据类型来说比较的是数据，对引用数据类型来说，比较的是地址
2.equals，未重写Object中的equals时，和==作用相同，即比较地址是否相同；重写Object的equals方法后，比较的是内容是否相同

toString

1.输出对象的引用时，其实就是调用当前对象的toString()

        Array01 test = new Array01();
        System.out.println(test);//com.vv.array.Array01@15db9742

2.像String、Date、File等都重写了Object中的toString方法，即返回的是“实体内容”信息
3.自定义类重写toString，调用此方法时，也返回对象的“实体内容”信息

包装类

针对8种基本数据类型定义相应的引用类型-包装类（封装类）
1.基本数据类型---------》包装类

        Float f1 = new Float("12.3f");
        System.out.println(f1);//12.3
        Float f2 = new Float(12.3f);
        System.out.println(f2);//12.3
        
        Boolean b = new Boolean("tRue");
                Boolean b = new Boolean("tRue123");
        System.out.println(b);//true，定义的方法只和true字符有关，和大小写无关
                System.out.println(b);//false，非标准true字符
        Person p = new Person();
        System.out.println(p.isMan);//true，此时调用基本数据类型，默认为true
        System.out.println(p.isFemale);//false,此时调用的是引用数据类型，默认为null
    }
}
class Person{
    boolean isMan;
    Boolean isFemale;
}

2.包装类--------------》基本数据类型，调用xxValue方法
包装类无法进行基本加减乘除运算，必须转换为基本数据类型

Float f1 = new Float("12.3f");
        float floatValue = f1.floatValue();

3.自动装箱和自动拆箱（jdk5.0新特性）

        //自动装箱
        int num1 = 10;
        Integer j = num1;
        System.out.println(j.toString());
        //自动拆箱
        Boolean b1 = true;
        boolean f = b1;
        System.out.println(f);

4.基本数据类型、包装类与String的相互转化
（1）基本数据类型、包装类----》String类

//基本数据类型、包装类----》String类
        int i = 10;
        //方式一：连接运算
        String s = i + " ";
        System.out.println(s);
        //方式二：调用String的ValueOf方法
        String s1 = String.valueOf(i);
        System.out.println(s1);

（2）String类----》基本数据类型、包装类

//String类----》基本数据类型、包装类
        String s2 = "abc";
        int i2 = Integer.parseInt(s2);
        System.out.println(i2);//java.lang.NumberFormatException,abc不能被转化为int类型，因此转换类型时要确保能够转型
        String s2 = "123";
        int i2 = Integer.parseInt(s2);
        System.out.println(i2);//123

        String b = "true";
        boolean boolean1 = Boolean.parseBoolean(b);
        System.out.println(boolean1);//true
        
        String b1 = "true1";
        boolean boolean2 = Boolean.parseBoolean(b1);
        System.out.println(boolean2);//false

例题1.

三元运算符要求编译时两个结果是同一类型，因为定义时赋值符号左边只返回一个结果，此结果要能适用于true和false对应的结果

//要求结果类型相同
        Object o = true ? new Integer(1):new Double(2.0);
        System.out.println(o);//1.0;将Integer类型自动提升成Double类型
//非三元运算符，不要求类型相同
        Object o1;
        if(true){
            o1 = new Integer(1);
        }else{
            o1 = new Double(2.0);
        }
        System.out.println(o1);//1

例题2.

        Integer i = new Integer(1);
        Integer j = new Integer(1);
        System.out.println(i == j);//false;比较的是对象地址
        
        Integer m = 1;
        Integer n = 1;
        System.out.println(m == n);//true;自动装箱
        //Integer中定义了IntergerCache结构，IntergerCache中定义了Integer[ ],范围是-128~127的整数，若超过此范围，会重新创建对象。
        Integer x = 128;//即相当于new Integer
        Integer y = 128;//即相当于new Integer
        System.out.println(x == y);//false

static

1.修饰属性，方法，代码段，内部类（静态内部类或嵌套内部类）
2.修饰属性：静态属性（static）和非静态属性（实例变量）
实例变量：每个对象独立拥有一套类中的非静态属性
静态变量：多个对象共享同一个静态变量
3.静态变量随着类的加载而加载，“类.静态变量”；静态变量的加载早于对象的创建；类只加载一次，因此静态变量在内存中只存在一份，存在于方法区的静态域中
4.在静态方法内，不能使用this或super关键字

代码块

1.作用：初始化类、对象
2.代码块有修饰类时，只能使用static
3.分类：静态代码块、非静态代码块
（1）静态代码块：随着类的加载而执行，只执行一次；类中定义多个静态代码块，则按顺序执行；静态代码块内只能调用静态属性或方法；作用：初始化类信息
（1）非静态代码块：随着对象的创建而执行，每创建一个对象，就执行一次；非静态代码块内可调用静态或非静态属性或方法；作用：可以在创建对象时，对对象的属性进行初始化

由父及子，静态先行

对属性赋值先后顺序

(1)默认初始化
(2)显示初始化/代码块中赋值（先后顺序）
(3)构造器中初始化
(4)有对象后，通过“对象.属性”或“对象.方法”方式赋值

final

1.修饰类、方法、变量
（1）final修饰类，不能被继承，例如String类、System类等
（2）final修饰方法，不能被重写，如Object的getClass方法
（3）final修饰变量，此时的“变量”称为常量；

final修饰属性：变量赋值有三种方式：显示初始化、代码块、构造方法初始化

final int m = 10;//显示赋值
    final int n;
    final int x;
    
    {
        n = 2;//代码块中赋值
    }
    Test(){//构造方法赋值
        x = 3;
    }
    Test(int y){//构造方法赋值
        x = y;
    }

final修饰局部变量，尤其是使用final修饰形参时，表明此形参是一个常量。当调用此方法时，给该形参赋值一个实参，只能在方法体内使用此形参，但不能重新赋值

//1.
void test(){
        final int x = 0;//此时是一个常量
        x += 1;//编译不通过
    }
//2.
void test1(final int x){
        x = 1;//编译不通过
    }
syso(x);
Test.test1(2);//2

static final修饰类、属性

1.修饰属性：全局常量
2.修饰方法：表示该方法不能重写，可以在不new对象的情况下调用

例题：

int test1(final int x){
        return ++x;//编译不通过
        return x+1;//可以，x的值没有改变
    }

    class Other{
        int i;
    }
    public class Test{
    private void addOne(final Other o) {
         o = new Other();//编译不通过，因为重新创建了一个对象
        o.i++;//可以执行
        }
    public static void main(String[] args) {
            Other o = new Other();
            new Test().addOne(o);
}}

抽象类和抽象方法

1.abstract修饰类、方法
2.抽象类：不能被实例化；一定有构造器，便于子类实例化调用（涉及：子类对象实例化的全过程）；
3.抽象方法：只有方法的声明，没有方法体；包含抽象方法的类一定是抽象类，但抽象类中可以没有抽象方法；若子类重写父类中所有抽象方法后，此子类可以实例化，若未重写，则子类也是一个抽象类，需要用abstract修饰
4.abstract注意：不能修饰静态方法、私有方法、final的方法或类

抽象类的匿名子类对象

public class Test01 {
public static void main(String[] args) {
    Person p = new Person(){

        @Override
        void eat() {
            // TODO Auto-generated method stub
            
        }
        
    };
method(p);
}
private static void method(Person p ) {
    p.eat();
}
}
public abstract class Person {
     abstract void eat();
    
}

接口interface

继承是一个“是不是”的关系，接口是“能不能”的关系，接口和类是并列关系
1.定义接口中的成员
（1）jdk7以前，只能定义全局常量和抽象方法
全局常量：public static final（书写时可以省略）
抽象方法：public abstract（书写可以省略）
（2）jdk8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法等
知识点1.接口中的静态方法只能通过接口来调用

public interface CompareA {
//静态方法
    public static void method1() {
        System.out.println("CompareA:    method1");
    }
//默认方法
    public default void method2() {
        System.out.println("CompareA:    method2");

    }
}
main方法中{CompareA.method1();}

知识点2.实现类的对象，可以调用接口中默认的方法，若实现类重写了接口中的默认方法，则调用时，仍然调用重写后的方法

public static void main(String[] args) {
        SubClass s = new SubClass();
        s.method2();//实现类调用接口中默认的方法
    }
    public void method2(){
        System.out.println("SubClass ");
    }

知识点3.若子类（或实现类）继承的父类和实现的接口中声明了同名同参的默认方法，那么在子类没有重写的情况下，默认调用父类的同名同参默认方法-----》类优先原则

public interface CompareA {
    public default void method2() {
        System.out.println("CompareA:    method2");
    }
}
public class SuperClass  {//父类
    public void method2() {
        System.out.println("SuperClass        ");
    }
    }
//子类SubClass继承父类SuperClass，其中SuperClass父类和CompareA
//接口拥有相同的默认方法，SubClass 的对象调用的是父类同名同参方法
public class SubClass extends SuperClass implements CompareA {
    public static void main(String[] args) {
        SubClass s = new SubClass();
        s.method2();//SuperClass
    }
}

知识点4.若实现类实现了多个接口，而这多个接口中定义了同名同参的默认方法，则在实现类没有重写该方法的情况下，报错------》接口冲突
解决办法，在实现类中重写此方法

public class SubClass implements CompareA,CompareB {//SubClass 报错，编译不通过
    public static void main(String[] args) {
        SubClass s = new SubClass();
        s.method2();
    }

}

知识点5.如何在子类（或实现类）的方法中调用父类、接口中被重写的方法

public class SubClass extends SuperClass implements CompareA,CompareB {

public void myMethod(){
    method2();//调用自己重写的方法
    super.method2();//调用父类中声明的方法
    //调用接口中默认的方法
    CompareA.super.method2();
}
@Override
public void method2() {
    System.out.println("SubClass");

}

2.接口中不能定义构造器，意味着接口不能实例化
3.若实现类覆盖了接口中的所有抽象方法，则此实现类可以实例化；若没有全覆盖，则此类仍为一个抽象类
4.java可以实现多个接口，弥补了单继承的局限性
格式：class A extends B implements CC,DD,EE
5.接口和接口之间可以继承，而且可以多继承

interface A {
}
interface B{
}
interface C extends A,B{
}

6.接口的具体使用，体现多态性
7.接口实际上可以看作是规范

public class USBTest {
    public static void main(String[] args) {
        Computer computer = new Computer();
        //1.创建接口的非匿名实现类的非匿名对象
        Flash flash = new Flash();
        computer.transferData(flash);
        //2.创建了接口的非匿名实现类的匿名对象
        computer.transferData(new Flash());
        //3.创建了接口的匿名实现类的非匿名对象
        USB u = new USB() {

            @Override
            public void stop() {
                System.out.println("手机结束");
            }

            @Override
            public void start() {
                System.out.println("手机开始");
            }
        };
        computer.transferData(u);
        //4.创建接口的匿名实现类的匿名对象
        computer.transferData(new USB() {
            
            @Override
            public void stop() {
                System.out.println("ps结束");
                
            }
            
            @Override
            public void start() {
                System.out.println("ps开始");
                
            }
        });
    }
}

class Computer {
    public void transferData(USB usb) {
        usb.start();
        System.out.println("传输数据");
        usb.stop();
    }
}

interface USB {
    void start();

    void stop();
}

class Flash implements USB {// u盘implements USB接口

    @Override
    public void start() {
        System.out.println("u盘启动");
    }

    @Override
    public void stop() {
        System.out.println("u盘结束");
    }

}

例题：抽象类和接口的异同

public interface A {
    int x = 0;
}
public abstract class B {
    int x = 2;
}
public class C extends B implements A{
    public void get(){
//      System.out.println(x);编译无法通过，原因是不能确定x属于哪个
        System.out.println(super.x);//调用父类的x
        System.out.println(A.x);//调用接口的x，接口中的x是static final类型的
    }
    public static void main(String[] args) {
        C c = new C();
        c.get();
    }
}

内部类

成员内部类：可以被static修饰、被4种不同权限修饰
1.如何实例化成员内部类对象

public class InnerClass {
    public static void main(String[] args) {
        Anmail.Dog a = new Anmail.Dog();//创建Dog实例
        a.show();
        Anmail a1 = new Anmail();
        Bird bird = a1.new Bird();//通过对象调用内部结构
        bird.show();
    }
        
}
class Anmail{
    //静态成员内部类
    static class Dog{
        void show(){
            System.out.println("汪汪");
        }
    }
    //非静态成员内部类
    class Bird{
        void show(){
            System.out.println("gugu");
        }
    }
}

2.如何在成员内部类中区分调用外部类结构

class Anmail{
    String name = "动物";
    //非静态成员内部类
        class Bird{
            String name = "鸟";
            void show(){
                System.out.println("gugu");
            }
            public void display(String name){
                System.out.println(name);//形参name
                System.out.println(this.name);//内部类属性
                System.out.println(Anmail.this.name);//外部类属性    
                }
        }
}

3.开发中局部内部类的使用

    // 返回实现了Comparable接口的类的对象
    public Comparable getComparable() {
        // 创建一个实现了Comparable接口的类：局部内部类
        /*// 方式一：
        class MyComparable implements Comparable {

            @Override
            public int compareTo(Object o) {

                return 0;
            }
        }
        return new MyComparable();*/
        //方式二：
        return new Comparable() {
            @Override
            public int compareTo(Object o) {
                // TODO Auto-generated method stub
                return 0;
            }
        };
    }

局部内部类使用注意

在局部内部类的方法中（如：show）如果调用局部内部类所在的声明的方法（如：method）中的局部变量（如：num），要求此局部变量声明为final

class A{

void method(){
    //局部变量
    int num  = 0;
    class B{//局部内部类
        void show(){
            int num = 2;
            System.out.println(num);
        }
    }
}
}