java中面向对象的一些知识点

类和对象关系:
什么是类：一组事物的共有的特征和属性的描述 是对象实现的具体内容的抽象，只包含对象的结构，不包含具体的数组
什么是对象：实实在在存在的物体
类是创建对象的模板
对象是类的实例化

如何创建类:
public class 类名{
属性：成员变量
数据类型 属性名
行为：方法
对象需要做的一些内容
修饰符 返回值类型 方法名(参数列表){}
}
使用类:
创建对象
类名 对象名=new 类名();
对象名.属性名=值：属性进行赋值
对象名.属性名：获取属性
对象名.方法名()
对象名.方法名(参数)
返回值类型 变量名=对象名.方法名()

构造方法：
        语法格式
            修饰符  方法名(参数列表){}
        作用：
           创建对象使用
           给类中的属性进行赋值
        特点：
            1方法名和类名一致
            2不用定义返回值类型
            3不需要return 语句
            4.如果一个类中不写构造方法，提供一个默认的无参数的构造方法

抽象类:
抽象类必须使用abstract class声明 一个抽象类中可以没有抽象方法。抽象方法必须写在抽象类或者接口中。
格式： abstract class 类名{ // 抽象类 }

抽象方法:
只声明而未实现的方法称为抽象方法（未实现指的是：没有“{}”方法体），抽象方法必须使用abstract关 键字声明。 
格式：    abstract class 类名{  // 抽象类        public abstract void 方法名() ;    // 抽象方法，只声明而未实现    }


不能被实例化：
在抽象类的使用中有几个原则：    · 抽象类本身是不能直接进行实例化操作的，即：不能直接使用关键字new完成。  
一个抽象类必须被子类所继承，被继承的子类（如果不是抽象类）则必须覆写(重写)抽象类中的全 部抽象方法。


常见问题：
1、抽象类能否使用final声明？  
不能，因为final属修饰的类是不能有子类的 ， 而抽象类必须有子类才有意义，所以不能。
2、抽象类能否有构造方法？    
能有构造方法，而且子类对象实例化的时候的流程与普通类的继承是一样的，都是要先调用父类中的 构造方法（默认是无参的），之后再调用子类自己的构造方法。


 抽象类和普通类的区别： 
 1、抽象类必须用public或procted 修饰(如果为private修饰，那么子类则无法继承，也就无法实现其 抽象方法）。默认缺省为 public 
 2、抽象类不可以使用new关键字创建对象， 但是在子类创建对象时， 抽象父类也会被JVM实例化。
 3、如果一个子类继承抽象类，那么必须实现其所有的抽象方法。如果有未实现的抽象方法，那么子类也必 须定义为 abstract类

static:
static表示“静态”的意思，可以用来修饰成员变量和成员方法(后续还会学习 静态代码块 和 静态内部类)。
static的主要作用在于创建独立于具体对象的域变量或者方法
简单理解：被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问。
并且不会因为对象的多次创建 而在内存中建立多份数据。

    重点：
           1.  静态成员 在类加载时加载并初始化。
           2.  无论一个类存在多少个对象 , 静态的属性, 永远在内存中只有一份( 可以理解为所有对象公用 )
           3.  在访问时： 静态不能访问非静态 , 非静态可以访问静态 !
    特点：
            1，随着类的加载而加载
            2，所有对象共享的
            3，直接使用类名调用
    语法格式：
          static 数据类型 属性名;
          public static void 方法名(){
          }
     使用：
            static:所有对象共享的属性
            在本类中：
                   1.属性名
                   2.类名.属性名
                   3.对象名.属性名
            其他类中：
                    1类名.属性名
                    2对象名.属性名

匿名对象：
没有名字的对象
new 类名():
属性或者方法只进行一次调用，使用一次，对象就消失

this:
指向当前对象 this在那个类中指向的就是那个类
语法格式：
属性 this.属性名
方法：this.方法名
如何使用this关键字：
全局变量和局部变量重名的时候，this.属性名区分全局变量名和局部变量
构造方法内
pubic class 类名{
private String name;
private int age;
public 类名(String name,int age){
this.name=name;//等号左边：类中的属性 等号右边：方法的参数名
}
this():调用当前类中的构造方法
this(参数)：调用的是当前类中有参数的构造方法
this():最多使用在构造方法内。它必须方法的第一行位置
super:
调用父类的全局变量
父类的变量和子类的变量重名的时候，super.属性名调用父类中的全局变量
super():调用的父类中无参数的构造
super(参数)：调用的父类中有参数的构造方法
super()最多使用在构造方法，方法内的第一行位置

java面向对象三大特性：
封装：
隐藏对象的功能实现的细节和字段
private 数据类型 属性名;
特点：
只能在当前类中访问
如果想在其他类中访问
public void set属性名(参数数据类型 参数名){
return 属性名;
}
public 返回值 get属性名(){
return 属性名;
}

继承：
语法格式：
class 子类 extends 父类{}
特点：
1子类可以继承父类中所有的属性和方法，不包括private修饰的
2.java支持单继承
3.子类除了继承父类的所有的属性和方法之外，可以扩展自己的属性和方法

多态：
一种事物（对象）的多种形态
对象的多态性，从概念上非常好理解，在类中有子类和父类之分，子类就是父类的一种形态 ，对象多态性 就从此而来。
ps: 方法的重载 和 重写 也是多态的一种， 不过是方法的多态（相同方法名的多种形态）。
重载： 一个类中方法的多态性体现 重写： 子父类中方法的多态性体现

多态的体现
类似于基本数据类型的转换：
· 向上转型：将子类实例变为父类实例 |- 格式：父类 父类对象 = 子类实例 ；
· 向下转型：将父类实例变为子类实例 |- 格式：子类 子类对象 = （子类）父类实例

重点：
1继承 2方法重写3类型转换：

       向上类型转换(自动类型转换）
         父类  对象名=new 子类()  子类对象向父类对象转换
       向下类型转换
         子类  对象名=(子类)父类的对象名
           instanceOf:两个地下之间判断
            A instanceOf B:
            A对象是否由B类创建出来
    方法的重载和重写：
    重载：
            当前类的方法不能满足需求
            当前类中个
    语法格式：
            方法名必须相同
            修饰符和返回值类型无关
            参数列表：
                    参数个不同，数据类型可以相同或者不同
                    参数个数相同：数据类型不同，顺序可以相同也可以不同
     重写：
         继承
         语法格式：
                方法名 返回值类型 参数列表和父类的方法保持一致
                子类的修饰符要比父类的修饰符大

访问修饰符的权限

                    类的内部      同一个包中          子类   任何类        
   private           是              否               否       否
   protected         是              是               是       否
   default           是              是               否       否
   public            是              是               是       是

接口：
如果一个类中的全部方法都是抽象方法，全部属性都是全局常量，那么此时就可以将这个类定义成一个接口。
定义格式： interface 接口名称{ 全局常量 ; 抽象方法 ; }

     面向接口编程思想
     这种思想是接口是定义（规范，约束）与实现（名实分离的原则）的分离。
     优点：     1、  降低程序的耦合性    2、  易于程序的扩展    3、  有利于程序的维护


    因为接口本身都是由全局常量和抽象方法组成 ， 所以接口中的成员定义可以简写：    
    1、全局常量编写时， 可以省略public static final 关键字，
         例如：        public static final String INFO = "内容" ;        
         简写后：        String INFO = "内容" ;    
    2、抽象方法编写时， 可以省略 public abstract  关键字，
         例如：        public abstract void print() ;       
         简写后：        void print() ；

   接口的实现 implements
   接口可以多实现： 格式：    class 子类 implements 父接口1,父接口2...{        }    
   以上的代码称为接口的实现。那么如果一个类即要实现接口，又要继承抽象类的话，则按照以下的格式编写  
   即可：    class 子类 extends 父类 implements 父接口1,父接口2...{        }

   接口的继承
   接口因为都是抽象部分， 不存在具体的实现， 所以允许多继承,例如：    interface C extends A,B{        }
    

    不关心内部数据实现，只需要用实现的方法
    语法格式：
    修饰符  inteface 接口名{
           常量：static final 数据类型  常量名-
           方法：
                    抽象方法
                    jdk1.8 static default
    }

    inteface 接口名{}
    class Student implements 接口名{
        重写接口中的抽象方法
    }

    注意事项：
        1没有构造方法
        2接口之间只能继承接口(多继承)，不能继承类
        3接口的属性全是常量 public static final
        4接口中可以由抽象方法  public abstract 返回值类型  方法名()
        5接口中可以实现多个接口

接口和抽象类的区别：
1、抽象类要被子类继承，接口要被类实现。
2、接口只能声明抽象方法，抽象类中可以声明抽象方法，也可以写非抽象方法。
3、接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。
4、抽象类使用继承来使用， 无法多继承。 接口使用实现来使用， 可以多实现
5、抽象类中可以包含static方法 ，但是接口中不允许（静态方法不能被子类重写，因此接口中不能声明 静态方法）
6、接口不能有构造方法，但是抽象类可以有

final:最终的 最后的
final:变量：常量  final 数据类型 变量名=值
fina类：不能被继承   final class 类名{}
final方法：不能被重写  public final 返回值类型  方法名(){}