java：对象与类

面向对象思想概述

1.面向对象的编程思想力图使计算机语言中对事物的描述与现实世界中该事物的本来面目尽可能的一致。

2.类(class)和对象(object)是面向对象方法的核心概念。类是对一类事物描述，是抽象的、概念上的定义；对象是实际存在的该类事物的每个个体，因而也称实例(instance)。

面向对象的三大特征
封装 (Encapsulation)
继承 (Inheritance)
多态 (Polymorphism)

tips：
类的访问机制：
1.在一个类中的访问机制：类中的方法可以直接访问类中的成员变量。（有一个例外）
2.在不同类中的访问机制：先创建要访问类的对象，再用对象访问类中定义的成员。

信息的封装和隐藏

1.使用者对类内部定义的属性(对象的成员变量)的直接操作会导致数据
的错误、混乱或安全性问题。

2.Java中通过将数据声明为私有的(private)，再提供公开的（public）方法:getXXX和setXXX实现对该属性的操作，以实现下述目的：

（1）隐藏一个类的实现细节；
（2）使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作；
（4）便于修改，增强代码的可维护性；

理解：
不允许使用者创建实例对象时修改一些重要属性，只能通过方法调用，故有了Private声明。

构造器的定义与作用

构造方法的特征
–它具有与类相同的名称；
–它不含返回值；
–注意：在构造方法里不含返回值的概念是不同于“void”的，在定义构造方法时加了“void”，结果这个方法就不再被自动调了。
构造方法的作用：当一个类的实例对象刚产生时，这个类的构造方法就会被自动调用，我们可以在这个方法中加入要完成初始化工作的代码。

函数的重载

def:函数的重载就是在同一个类中允许同时存在一个以上的同名函数，只要它们的参数个数或类型不同即可。

1.不能通过参数名去区分两个方法；
2.不能通过返回值的类型来区分两个方法；
3.可以通过参数列表：参数的个数，参数的类型来区分两个同名方法。

类的继承

Java只支持单继承，不允许多重继承
1.一个子类只能有一个父类
2.一个父类可以派生出多个子类

规则：
1.子类继承了父类，就继承了父类的方法和属性。
2在子类中，可以使用父类中定义的方法和属性，也可以创建新的数据和方法。
因而，子类通常比父类的功能更多。
3.在Java 中，继承的关键字用的是“extends”，即子类不是父类的子集，而是对父类的“扩展”。
4.子类不能继承父类中私有的(private)的成员变量和方法。

访问控制

可以对Java类中定义的属性和方法进行访问控制----规定不同的保护等级： public、protected、default、private

覆盖方法

1.在子类中可以根据需要对从父类中继承来的方法进行改造—覆盖方法(方法的重置、重写)，在程序执行时，子类的方法将覆盖父类的方法。
2.覆盖方法必须和被覆盖方法具有相同的方法名称、参数列表和返回值类型。
3.覆盖方法不能使用比被覆盖方法更严格的访问权限。

关键字super

在Java类中使用super来引用父类的成分
1.super可用于访问父类中定义的属性
2.super可用于调用父类中定义的成员方法
3.super可用于在子类构造方法中调用父类的构造方法
4.super的追溯不仅限于直接父类

调用父类构造方法
1.在子类的构造方法中可使用super(参数列表)语句调用父类的构造方法
2.如果子类的构造方法中没有显示地调用父类构造方法，也没有使用this关键字调用重载的其它构造方法，则系统默认调用父类无参数的构造方法
3.如果子类构造方法中既未显式调用父类构造方法，而父类中又没有无参的构造方法，则编译出错

多态

1.多态—在Java中，子类的对象可以替代父类的对象使用
2.一个变量只能有一种确定的数据类型
3.一个引用类型变量可能指向(引用)多种不同类型的对象

Person p = new Student();
Object o = new Person();//Object类型的变量o，指向Person类型的对象
o = new Student(); //Object类型的变量o，指向Student类型的对象

父类类型的变量可以指向子类的对象

4.一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，那么该变量就不能再访问子类中添加的属性和方法

tips:

1. 直接通过对象名称访问成员变量：看等号左边是谁就优先用谁，没有则向上找（不会向下找）。
2. 直接通过成员方法访问成员变量：看该方法属于谁就优先用谁，没有则向上找。
   口诀：编译看左边，运行看右边。

1.当父类类型的变量指向一个子类的对象，调用父类中已经被重写的方法的时候。
2.在多态的情况下（当父类类型的变量指向一个子类的对象），不能调用子类新添加的方法。
3.在多态的情况下，可以对对象进行强制的类型转换。
(只有在有父子关系的情况下，才能进行强制的类型转换)
（父类的对象可以转化为任何子类的类型，但有可能会发生java.lang.ClassCastException异常）

对象的向上转型：
其实就是多态写法
格式： 父类 对象名 = new 子类()；
*含义：*右边创建一个子类对象，把它当作父亲来看待使用。
*注意事项：*向上转型一定是安全的，从小范围转向了大范围。
*缺点：*一但向上转型为父类，就无法调用子类原本持有的内容，故需要向下转型。

对象的向下转型：
其实就是一个向上转型的还原动作。
格式： 子类 对象名 = new 父类()；
含义：将父类对象，【还原】成为本来的子类对象
注意事项：
a.必须保证对象本来创建的时候是猫，才能向下转型成猫。
b.如果对象创建的时候本来不是猫，现在非要向下转型为猫，就会报错（classCastException）。

多态的好处：
1.无论右边new的时候换成哪个子类对象，等号左边调用方法都不会变化。

instanceof 操作符

x instanceof A：检验x是否为类A的对象，返回值为boolean型。
要求x所属的类与类A必须是子类和父类的关系，否则编译错误。
如果x属于类A的子类B，x instanceof A值也为true。

Object 类

Object类是所有Java类的根父类,如果在类的声明中未使用extends关键字指明其父类，则默认父类为Object类

==操作符与equals方法
==操作符与equals方法的区别:

==：引用类型比较引用(是否指向同一个对象)；

Person p1=new Person();   Person p2=new Person();
	if (p1==p2){…}

基本类型比较值；

int a=5; if(a==6){…}

用==进行比较时，符号两边的数据类型必须一致(可自动转换的基本数据类型除外)，否则编译出错；
equals()方法是Object类的方法，由于所有类都继承Object类，也就继承了equals()方法。只能比较引用类型，其作用与“==”相同,比较是否指向同一个对象。格式:obj1.equals(obj2)
特例：当用equals()方法进行比较时，对类File、String、Date及封装类（Wrapper Class）来说，是比较类型及内容而不考虑引用的是否是同一个对象；加入了一些健壮性的判断。
原因：在这些类中覆盖了equals()方法。

toString 方法
toString()方法在Object类中定义，其返回值是String类型，返回类名和它的引用地址。
在进行String与其它类型数据的连接操作时，自动调用toString()方法

封装类

关键字 static

1.在Java类中声明变量、方法和内部类时，可使用关键字static做为修饰符。
2.static标记的变量或方法由整个类(所有实例)共享，如访问控制权限允许，可不必创建该类对象而直接用类名加‘.’调用。
3.static成员也称类成员或静态成员，如：类变量、类方法、静态方法等。

tips：
1.static是一个关键字：用于修饰类的成员（属性，方法，内部类）。
2.若访问权限允许的情况下，static修饰的成员可以通过类名.方法来访问，即可以在不创建对象的情况下进行访问，当然也可以通过对象.方式来访问
3.static修饰的成员为类成员，为类所有的实例所共享。
4.在static方法内部只能访问类的static属性，不能访问类的非static属性，反之，非static方法可以访问static成员。因为不需要实例就可以直接访问static方法，因此static方法内部不能有this，也不能有super。

内存图：
根据类名称来访问静态成员变量时，全程和对象没关系，只和类有关系，只会去静态内存区取数据。

静态初始化

一个类中可以使用不包含在任何方法体中的静态代码块(static block )，当类被载入时，静态代码块优先被执行，且只被执行一次，静态块经常用来进行类属性的初始化。

static块通常用于初始化static (类)属性

class Person {
	public static int total;
	static {
	        total = 100;//为total赋初值 
	}
	…… //其它属性或方法声明
 }

单子 Singleton 设计模板

所谓类的单态设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例

方法：
如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构造方法的访问权限设置为private，这样，就不能用new 操作符在类的外部产生类的对象了，但在类内部仍可以产生该类的对象。因为在类的外部开始还无法得到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象，静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象的变量也必须定义成静态的。

理解main方法的语法

由于java虚拟机需要调用类的main()方法，所以该方法的访问权限必须是public，又因为java虚拟机在执行main()方法时不必创建对象，所以该方法必须是static的，该方法接收一个String类型的数组参数，该数组中保存执行java命令时传递给所运行的类的参数。

关键字 final

1。在Java中声明类、属性和方法时，可使用关键字final来修饰。
2.final标记的变量(成员变量或局部变量)即成为常量，只能赋值一次。
3.final标记的类不能被继承。提高安全性，提高程序的可读性。
4.final标记的方法不能被子类重写。增加安全性。
5.final标记的成员变量必须在声明的同时或在每个构造方法中显式赋值，然后才能使用。

tips:
1.final关键字，可以修饰类，属性和方法，表示最终的。
2.final修饰的属性，是最终的属性-属性值不能被修改，即常量
3.final修饰的方法，是最终方法-该方法不能被修改-该方法不能被重写
4，final修饰的类，是最终的类-该类不能被扩展，该类不能被继承

final不能与abstract一起使用，因为自相矛盾！！！

抽象类(abstract class)

1.随着继承层次中一个个新子类的定义，类变得越来越具体，而父类则更一般，更通用。类的设计应该保证父类和子类能够共享特征。有时将一个父类设计得非常抽象，以至于它没有具体的实例，这样的类叫做抽象类。
2.用abstract关键字来修饰一个类时，这个类叫做抽象类；用abstract来修饰一个方法时，该方法叫做抽象方法。
3.抽象方法：只有方法的声明，没有方法的实现。以分号结束。
abstract int abstractMethod1( int a );
4.含有抽象方法的类必须被声明为抽象类。
5.抽象类不能被实例化。抽象类是用来被继承的，抽象类的子类必须重写父类的抽象方法，并提供方法体。
6.不能用abstract修饰私有方法，构造方法，静态方法。

tips:
abstract:关键字，用于修饰类和方法。
abstract修饰的方法：没有方法体，只有方法的声明，这样的方法称为抽象方法。
abstract修饰的类，称为抽象类，不能被实例化

ps：有抽象方法的类一定是抽象类，但抽象类中可以没有抽象方法。

接口interface

接口(interface)是抽象方法和常量值的定义的集合。

从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。

接口的特点：
1.用 interface 来定义。
2.接口中的所有成员变量都默认是由public static final修饰的。
3.接口中的所有方法都默认是由public abstract修饰的。接口没有构造方法。
4.实现接口的类中必须提供接口中所有方法的具体实现内容。
5.多个无关的类可以实现同一个接口
6.一个类可以实现多个无关的接口
7.与继承关系类似，接口与实现类之间存在多态性
8.接口也可以继承另一个接口，使用extends关键字。

tips：
1.使用interface声明
2.接口是抽象方法和常量的集合，不能再有其他的任何成分。
3.接口中方法的默认修饰为，public abstract
4.接口中常量的默认修饰为public static final
----常量的命名规范，多个单词组成，每个字母都需要大写，且多个单词使用_连接。
5.实现接口使用Implements关键字
6.一个类可以实现多个接口
7.接口之间可以继承
8.同时有接口与继承时，extends在implements前面。

接口小结：
1.成员变量其实是常量，格式：
public static final 数据类型 常量名称 = 数据值；
注意 ：常量必须进行赋值，而且一旦赋值不能改变。常量名称完全大写，用下划线进行分割。
2.接口中最重要的就是抽象方法，格式：
public abstract 返回值类型 方法名称(参数列表);
注意：实现类必须覆盖重写接口所有抽象方法，除非实现类是抽象类
3.从java8开始，接口里允许定义默认方法，格式：
public default 返回值类型 方法名称(参数列表){方法体}
注意：默认方法也可被覆盖重写
4.从java8开始，接口里允许定义静态方法，格式：
public static 返回值类型 方法名称(参数列表){方法体}
注意：应该通过接口名称进行调用，不能通过实现类对象调用接口静态方法。
5.从java9开始，接口里允许定义私有化方法， 格式：
普通私有方法:private 返回值类型 方法名称(参数列表){方法体}
静态私有方法：private static 返回值类型 方法名称(参数列表){方法体}
注意：private的方法只有接口自己才能调用，不能被实现类或别人使用。

抽象类与接口都不能直接创建对象！！！！！

内部类

1.在Java中，允许一个类的定义位于另一个类的内部，前者称为内部类
2.内部类和外层封装它的类之间存在逻辑上的所属关系
3.Inner class一般用在定义它的类或语句块之内，在外部引用它时必须给出完整的名称。 Inner class的名字不能与包含它的类名相同；
4.Inner class可以使用包含它的类的静态和实例成员变量，也可以使用它所在方法的局部变量；

内部类特性
1.Inner class可以声明为抽象类 ，因此可以被其它的内部类继承。也可以声明为final的。
2.和外层类不同，Inner class可以声明为private或protected；
3.Inner class 可以声明为static的，但此时就不能再使用外层封装类的非static的成员变量；
4.非static的内部类中的成员不能声明为static的，只有在顶层类或static的内部类中才可声明static成员；

tips：
1.对于非静内部类，必须先创建外部类对象，然后再创建内部类对象
2.静态内部类：内部类使用static来修饰，所以创建该类的对象可以没有外部类。

四种权限修饰符总结

           	public > protected > (default) > private
同一个类      yes        yes         yes        yes
同一个包      yes        yes         yes        no
不同包子类  	 yes         yes         no         no
不同包非子类   yes        no          no         no

String类

	字符串是常量，它们的值在创建之后不能更改，底层是一个被final修饰的数组，不能改变，是一个常量。

原始代码：private final byte[] value;
StringBulider类
字符串缓冲区，可以提高字符串的操作效率（看成是一个长度可以变化的字符串）底层也是一个数组，但是没有被final修饰，可以改变数组长度。
原始代码： byte[] value = new byte[16]
StringBulider在内存中始终是一个数组，占用空间少，效率高。如果超出了StringBuilder的容量，会自动的扩容。

包装类

基本数据类型，使用起来非常方便，但是没有对应的方法来操作这些基本数据类型。
可以使用一个类，把基本数据类型装起来，在类中定义一些方法，这个类叫做包装类，我们可以使用类中的方法来操作这些基本类型的数据。

装箱与拆箱
装箱：从基本数据类型转换为对应的包装类数据
拆箱：从包装类对象转换为对应的基本类型

自动装箱与拆箱：基本类型的数据和包装类之间可以自动的互相转换

基本数据类型与字符串类型之间的相互转换：
基本类型 -> 字符串（String）
1. 基本类型的值+" "
2. 包装类的静态方法toString(参数)，不是Object类的toString()重载
static String toString(int i) 返回一个表示指定整数的String对象。
3.String类的静态方法valueOf(参数),static String valueOf(int i) 返回int 参数的字符串表示形式。
字符串(String) ->基本类型
使用包装类的静态方法parseXXX(“数值类型的字符串”)；
Interger类： static int parseInt(String s)
Double类： static double parseDouble(String s)