java-面向对象的三个特征：封装、继承、多态

• 函数定义

函数：对功能代码的封装
public static 返回值类型 函数名（形参）｛
代码
return 值；
｝

• 函数类型

函数的类型；
1.无返回值，无参的 : void 函数名（）{}
2.有返回值，有参的 : int 函数名（类型 变量名，类型 变量名，。。。）{ return 1}
3.无返回值，有参的: void myAdd(int a,int b)
4.有返回值， 无参的：String 函数名（）{return 0 ;}

• 类

类：是一类东西
自定义一个数据类型 （属性， 方法）

class 类名｛
    //属性
    int age;
    String name;

    //方法（函数）  对象名.方法名（） 调用
    public 返回值类型 函数名(参数){

    }
    ...


｝

类名 对象名= new 类名();//定义变量并分配内容赋初始值
类名 对象名 ;//定义变量
对象名 = new 类名();//分配内容赋初始值
访问属性：
对象名.属性名

• 访问修饰符
  public:公开（公有的） ，所有人都可以访问, 用来修饰方法
  private:私有的，只能类本自身访问,用来修饰属性
  public
  公开程度最高，可被任意对象访问
  一般设置一些公用的方法为public
  除修饰方法和属性外，也修饰类
  private
  隐弊最高，只有类本身可访问，其实例不能访问
  protected
  继承此类的子类和类的实例可见
  package可以被同一个包中的类访问(使用)

• 构造函数

构造函数：没有返回值类型， 名子与类名相同， 访问修饰符为public
1.默认构造函数：无参的
2.自函定义的构造函数：只要有一个自定义的构造函数，默认构造函数不存在
public 类名（）｛｝
构造函数可以有多个，只要是 参数不同就是不同的构造函数
构造函数在new时被调用
封装：方法公有化， 属性私有化

public class Cat{//类
    private String name;//private属性私有化
    private int age;

    public Cat(){//构造函数无参，要调用有参的
        this（"未知",-1）;
    }
    public Cat(String name){
        this(name,-1);
    }
    public Cat(String name,int age){
        this.name = name;//this指的是类的name
        this.age = age;
    }
/*this: 当前对象的引用
    this.属性名    
调用构适函数,必须放在造构函数的开头
    this(参数); */
    public void  setName（String name）｛ //写函数
            this.name = name;
            ｝
    public String getName(){
        return name;
    }           
}

package cat;
impotr java.uilt.*

public class Test{
    public static void main(String[] args){
    Cat cat1 = new Cat("小花");
    cat1.getName();
    }
}

方法重载：
1、当前类
2、参数不同：个数、类型、顺序

方法重写：
1、继承关系、子重写父类；
2、参数相同

1.定义一个父类
2.定义子类
class 子类名 extends 父类名{
}
3.构造函数
1）、产生子类对象时， 默认子类先调用父类的无参构造函数，再调用子类的构造函数
2）、super()显示调用父类无参构造函数
super(参数)显示调用父类有参构造函数

super： 当前父类对象
1) super()显示调用父类无参构造函数
super(参数)显示调用父类有参构造函数
2)super.父类的方法名（）

多态：
1.相同操作，不同的执行结果
2.必须继承关系， 将子类对象赋父类对象， 父类对象.方法名()
3.子类重写父类中的方法， 父类对象.方法名()，调用的是子类的方法

多态的实现：
1.继承
2.子类重写父类中的方法
3.将子类对象赋给父类对象，通过 父类对象.重写的方法名（）

抽象方法:没有方法体的函数，abstract
抽象类： 具有抽象也没有方法的类叫抽象类，abstract
特点：1.抽象类不能实化
2.要实继承关系
3.含有抽象方法的类，是抽象类abstract
4.父类中的抽象方法必须在子类中实现
5.将子类对象赋给父类， 父类对象.抽象的方法名（）

接口：只做方法的声明，没有方法的实现(对方法签名的规定)
一个类可以实现多个接口
没有继承关系
不同的类，具有相同的方法，这时就可以将这个方法的声明抽象为一个接口
public class 子类名 extends 父类 implements接口名1, 接口名2，。。。{
实现接口的方法，
实现父类的抽象方法
}
接口中方法的声明：
public abstract 返回值 函数名(参数);
public void add();//abstract可省略

final ：变量， 类， 方法
final修饰变量这个变量为一个常量，后面不能修改final int num1 =10;
final修饰方法，这个方法不能被子类重写
final修饰类，这个类不能被继承

static:静态的 用于修饰类成员（属性，方法）
static修饰变量,这个变量为静态变量，用 类名.变量名, 对象名.方法名 访问
static的变量会初始化（不用调用构造 函数）
static修饰方法，这个方法有两种调用方法 对象名.方法名 ， 类名.方法名
静态方法中，只能出现静态变量

打包：
package:包实质是声明一个本类所在的目录结构
用于对java类分门 别类的管理和组织
package 对包的管理通常使用 com.goole.can 目录文件在 com文件夹下的 goole文件夹下的can文件夹
import 导入包：访问非本类所在包中的类时，需要用import显示引入包
import com.goole.can.* 引入com/goole/can下的所有类