面向对象思想

概述:找一个对象来干活.不用再关注过程.
基本步骤:
定义类--创建对象--调用方法.

类与对象

类:对事物的描述
对象: 事物的实体.
关系: 类就是对对象的描述.  
      对象就是类的具体体现.
      
      类 : 虚的
      对象:实的 

定义类格式:

class 类名{

           //成员变量 : 属性
           //构造方法 : 创建对象用的
           //成员方法 : 行为,功能
       }

面向对象的三大特征

封装

    步骤:1.private私有成员
         2.提供公共的访问方式  
            get/set : 可以更改对象的值  
                 
            构造方法: 创建对象就赋值了
    private:
        作用:私有化,保护数据,隐藏实现细节 
        特点:只有本类可以访问. 外部的类都看不见.
    
    this: 
        作用: 指代本类当前对象
        1. 局部变量隐藏成员变量   
        setXxx(String name){
            this.name = name; 
        }
        
        int num=20;
        show(){
            int num =30 ;  // 就近 隐藏了 
            syso(this.num);
        }
        2.调用自己的构造 
        this ( 参数);   调用自己的有参构造  
            
    static: 静态
        特点:随着类的加载而加载.  
             修饰成员
        1.成员方法调用
            类名.方法名(); (看情况,比较方便)
        2.成员变量
            类名.变量名; (不常用)
            所有对象共享其值. 

继承

    概述:子类集成父类  
    class Zi extends Fu { }  

    特点:1.单继承, 只有一个亲爹
         2.多层继承 , 还可以有爷爷 
         3.父类有的,子类可以直接用. 
    注意事项:
        1.private的东西 不能继承. 
        2.构造方法不能继承, 但是可以访问 
            默认通过super(); 访问父类的无参构造    
            super(参数);  手动方法父类有参 
        3.不能随便继承.
        4.is a 的关系时候,才能使用.  

    super:
    成员关系
        成员变量(同名):
            super.父类成员变量. 访问父类成员. 
        构造方法:
            注意事项:默认访问父类无参  
                1.super(); 
                2.super(name,age);
                3.必须在构造方法中第一行 
        成员方法(同名):重写
            重写概述:子父类中, 一模一样的方法. (方法名,返回值类型 ,参数列表 )
            注意事项:
                1.private的不能重写 
                2.权限不能更低.解决方案 :  一模一样.
        静态方法: 
            重写: 使用静态才能静态方法.   
            
    final:  
        概述:最终的 
        特点:被修饰的不能改变 
            类:   不能继承
            变量: 不能赋值,只能初始化一次.  
            方法: 不能重写. 

多态:

    概述:一种事物多种形态 
    前提: 
        1.继承或者实现 (二选一)
        2.方法重写(才有意义)
        3.父类引用指向子类对象 
        Fu f = new Zi(); 
            
    成员关系:
        成员变量:编译看左边,运行看左边
        构造方法:编译看左边,运行看左边
        成员方法:编译看左边,运行看右边 * 
        静态方法:编译看左边,运行看左边
            
    子类特有的方法:
        向上转型: 子--> 父
            格式: fu f = new Zi(); 
        向下转型: 父 --> 子
            格式: 
            Zi z = (Zi)f; 

抽象类

概述:描述不清楚的类 
特点: 
    1.格式:
    abstract class 类名{  
        public abstract void 方法名(); 
    }           
    2.方法特点: 可以抽象 ,也可以非抽象
    3.构造方法: 有,不能new 
    4.如何使用抽象类?
        使用它的子类. 
    5.子类特点: 
        1.要么抽象
        2.要么重写它所有的抽象方法
    
成员特点:
    a:成员变量：变量/常量
    b:构造方法：有
    c:成员方法：抽象/非抽象
面试题: abstract 不能和哪些关键字共存(定义方法来测试)?
        private    冲突 -- 对子类隐藏,而 abstract 必须让子类重写 
        final      冲突 -- 不能被重写,矛盾 
        static     无意义-- 类名调用,没有方法体,无意义

接口

概述:把很多功能封装到接口中,用类去实现接口 ,重写里面的功能 . 
本质:就是一种规则
特点:
    1.格式: interface 接口名{
    }
      使用: 
      class  A implements 接口名 {
      }
      

    2.成员变量: 常量
    3.成员方法: 抽象
    4.构造方法: 无 
    5.实例化: 
        方式1:new 子类
        方式2: new Inter(){};  // 加一个 {} 重写方法
    6.子类要求:  
         1.要么抽象
        2.要么重写它所有的抽象方法

内部类

概述: 类里面的类 (人里面的心脏)
成员内部类:成员位置 ,类中方法外
    格式:
class Outer{
            private class Inner{
            }

            public void method(){
                new Inner(); 
            }
        }
    
注意:如果private 修饰内部类,那么就不能直接创建,提供公共的访问方式.

局部内部类:在方法内部 
    格式:
class Outer{
            show(){
                
                final int num =10;
                class Inner {
                    
                }
            }
        }
    问题:只能访问被final修饰的局部变量吗?
    肯定的.使用final把局部变量变成常量.

匿名内部类:

前提:有一个接口或者类(抽象类)
本质: *匿名对象*-- 这个对象时实现了接口或者继承了类的子类对象 ,必须重写所有抽象方法 
new 接口(){
    重写抽象方法 
}.方法名();

代码块:

静态:成员位置, 类加载的执行,只有一次
构造:成员位置, 每次构造方法前执行
局部:方法内,提供效率.

权限修饰符:

                    本类      同包      不同包子类       不同包其他类
private           *                                        
default           *          *                               
protected            *         *            *                 *
public             *         *          *                 *         

常用 public 修饰 类 和方法
；private 修饰 成员变量