类和对象的介绍

1.方法和对象的简单介绍

类的特性包含封装，继承，多态。

多个方法不能相互嵌套
可变参数必须是最后一个参数
栈里有一个缓冲区存，直接存放字符串缓冲内容，当不new创建对象时，都会先去缓冲区里面找，若没有则直接创建新的缓冲内容。

访问权限	public	protected	default	private
本类	可以	可以	可以	可以
同包	可以	可以	可以	不可
子类	可以	可以	不可	不可
其他	可以	不可	不可	不可

2.super可以调用父类的方法，也可以调用父类的构造器（必须在构造器的第一行）

super 和 this的用法大体相通
public Child() {
//super();
}
在子类的构造器中默认包含一个父类的无参构造器，如上述代码所示
在子类中可以重写overreading父类的方法

在父类构造器中如果调用了抽象方法（调用子类抽象方法的实现），然后调用子类的构造方法。

public abstract class UseCase1 {
    abstract void testAbstract();//i
    UseCase1(){//（1）首先执行父类构造方法
        System.out.println("before testAbstract()");
        testAbstract();//如果调用了抽象方法，调用子类覆盖的方法。这里调用Atest类的testAbstract（）方法
        System.out.println("after testAbstarcat()");
    }
    public static void main(String args[]){
        new Atest();
    }
}
class Atest extends UseCase1{
    private int i=1;//（2）使成员变量进行初始化
    void testAbstract(){
        System.out.println("testAbstract()"+i);
    }
    public Atest(){//（3）调用子类构造方法
        System.out.println(i);
    }
}
//输出
before testAbstract()
testAbstract()0
after testAbstarcat()
1

3.重写与多态结合使用，父类的引用指向子类的对象，一般在子类方法中加@override

this 指调用方法的对象（在方法中指的是调用该方法的那个对象）

//当对象在父类中使用到对象中方法时使用子类的方法（父类和子类中的方法名相同）

this（“参数”）；会调用本类的构造器，必须在第一行，在构造器中时，不能同时使用this和super.

//属于同一个类中
    public Dog() {
        this("黄狗"); 
    }
    public Dog(String name) {   
    }

封装类

自动拆箱和装箱

自动装箱：Integer h=10;
自动拆箱：int j=new Integer(8);

Integer.parseInt(str,进制数）；不加进制数，默认为10进制
当拿一个简单数据类型和一个引用数据类型比较时，会自动拆箱

记录什么时候使用封装类
Integer number=new Integer(7);
Integer number=new Integer(“45”);//用String型变量做参数

既然提供了基本类型，为什么还要使用封装类呢？

某些情况下，数据必须作为对象出现,此时必须使用封装类来将简单类型封装成对象。

1. 比如，如果想使用List来保存数值，由于List中只能添加对象，因此我们需要将数据封装到封装类中再加入List。在JDK5.0以后可以自动封包，可以简写成list.add(1)的形式，但添加的数据依然是封装后的对象。
2. 另外，有些情况下，我们也会编写诸如func(Object o)的这种方法，它可以接受所有类型的对象数据，但对于简单数据类型，我们则必须使用封装类的对象。
   某些情况下，使用封装类使我们可以更加方便的操作数据。比如封装类具有一些基本类型不具备的方法，比如valueOf(), toString(), 以及方便的返回各种类型数据的方法，如Integer的shortValue(), longValue(), intValue()等。

基本数据类型与其对应的封装类由于本质的不同，具有一些区别：

1. 基本数据类型只能按值传递，而封装类按引用传递。
2. 基本类型在堆栈中创建；而对于对象类型，对象在堆中创建，对象的引用在堆栈中创建。基本类型由于在堆栈中，效率会比较高，但是可能会存在内存泄漏的问题。
   基本数据类型存在内存泄露问题

方法	返回值	功能描述
byteValue()	byte	以byte类型返回该Integer的值
comepareTo(Integer anotherInter)

instanceof

1. if(animal instanceof Dog){
   ((Dog)animal).voice(“刘皎锐”);
   }
   判断某个对象是否是某个类产生的对象，然后进行类型的强制转换

static修饰类的属性，方法是所有对象所共有的

static修饰中不能有this，super
调用：类名.属性；类名.方法名；

静态方法

在java中定义全局变量，通常使用public static final修饰，这样的常量只能在定义时被赋值。

final

1. final修饰的类是最终类，没有子类
2. final修饰方法，不允许被复写（重写），效率较高。
3. final修饰的变量为常量 （全部大写，中间用下划线隔开）

我们知道一个被定义的final对象引用只能指向一个唯一一个对象，不可以将它在指向其他对象，但是一个对象本身的值却是可以改变的，那么为了使一个常量正真做到不可更改，则定义为static final。这样的常量只能在定义时赋值。

public class FinalStaticData {
    private static Random rand = new Random(); // 实例化一个Random类对象
    // 随机产生0~10之间的随机数赋予定义为final的a1
    private final int a1 = rand.nextInt(10);
    // 随机产生0~10之间的随机数赋予定义为static final的a2
    private static final int a2 = rand.nextInt(10);

    public static void main(String[] args) {
        FinalStaticData fdata = new FinalStaticData(); // 实例化一个对象
        // 调用定义为final的a1
        out.println("重新实例化对象调用a1的值：" + fdata.a1);
        // 调用定义为static final的a2
        out.println("重新实例化对象调用a1的值：" + fdata.a2);
        // 实例化另外一个对象
        FinalStaticData fdata2 = new FinalStaticData();
        out.println("重新实例化对象调用a1的值：" + fdata2.a1);
        out.println("重新实例化对象调用a2的值：" + fdata2.a2);
    }
}

Object是祖类

1. 重写Object的方法，判定传递值不为空。

public boolean equals(Object obj) {
        if(obj!=null){
            if(obj instanceof Child){
            //str.equals(str1);this.id为str的，obj.id为str2的
                boolean isSame=this.id==((Child)obj).id;
             return isSame; 
            }   
        }
        return false;//如果为空的返回值 ，必须要有所有情况返回值
    }

多态

父类的引用 指向 （多种）子类的对象
Animal animal = new Dog();
类 ——- 引用 ——–新对象

然后animal调用相同的方法产生（多种）不同的响应。