一.方法：

1.语法格式：

/*
	修饰符 返回值类型  方法名（.....）{
		//方法体
		return 返回值;
	}
*/

2.方法类型：

静态方法：含有static修饰
非静态方法：不含有static修饰

调用：
1>.静态方法调用：

类名.方法名

public class Application {

    public static void main(String[] args){
        Student.study();
    }
}
 class Student {
    public static void study(){
        System.out.println("我爱学习Java");
    }
}

2>.非静态方法的调用：

实例化类，然后可以进行调用
public class Application {

    public static void main(String[] args) {
        Student s1 = new Student();//先要对类进行实例化，否则会编译错误
        s1.study();
    }
}
class Student {
    public  void study(){
        System.out.println("我爱学习Java");
    }
}

方法调用时，当两个方法的类型相同时。均为静态类或者非静态类时，可以相互调用；若不同时，非静态类可以调用静态类，但时静态类不可以调用非静态类（静态类和类一起加载，静态类加载时，非静态类还没有加载）

3.方法参数：

方法可以修改按引用传递的变量的值，但不能修改按值传递的变量的值
1>.按值调用：（基本数据类型）表示方法接收的是调用者提供的值

public static void main(String[] args) {
          int a = 6;
        System.out.println(a); //6
        System.out.println("!!!!!!!!!!!!!!!!!!!!!!!!!!");
        change(a);
        System.out.println(a);  //6
    }
    public static void change(int a){
        a = 10;
    }

 方法得到是所有参数值的一个副本，不能修改传递给它的任何参数变量的内容
2.按引用调用：（对象引用）表示方法接收的是调用者提供的变量的地址
举个例子：

public class Student {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.age);
        System.out.println("!!!!!!!!!!!!!!!!!!!!!!");
        change(person);
        System.out.println(person.age);
    }
    public static void change(Person person){
        person.age = 10;
    }
}
class Person{
    int age;
}

代码运行

方法得到是对象引用的副本，原来的对象引用和这个副本的引用都指向同一个对象

总结：
1.方法不能修改基本数据类型的参数
2.方法可以改变对象参数的状态

二.类

定义： 类相当于是一个对象的模板，对象就像是类的具体化
举个例子：

public static void main(String[] args){
        //类实例化后会返回一个自己的对象！
        Student student = new Student();//student对象是一个Student类的具体实例
        student.name = "小明";
        student.age = 3;
        System.out.println(student.name);
        System.out.println(student.age);
    }
    class Student {
    String name，
    int age;
}

在使用new关键字创建的时候，除了分配内存空间，还会给创建好的对象进行默认的初始化，及对类中构造器的调用

三.构造器

1.构造器的特点：

   必须与类的名字相同
   没有返回类型，也不能写void

2.构造器的作用：

  用来初始化值

初始化数据字段的方法：
1，在构造器中设置值；在使用new关键字创建的时候，除了分配内存空间，还会给创建好的对象进行默认的初始化，及对类中构造器的调用
2，声明中赋值
3，初始化块

3.注意：

 仅当类中没有其他任何构造器的时候，才会得到一个默认的无参数构造器；但若在编写了自己一个有参构造器，则必须提供一个无参构造器

4.构造器应用实例：

public class Person {

    String name;
    int age;
    public Person() {   //无参构造器
    }
    public Person(String name，int age) {    //有参构造器
        this.name = name;  //前者是当前类，后者是当前的参数
        this.age = age;
    }
}

四.封装

1.封装的概念：

 将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法对隐藏信息进行访问 实现数据的隐藏
高内聚：类的内部数据操作细节自己完成，不允许外部干涉
低耦合：仅暴露少量的方法给外部使用

2.封装的意义：

1.提高程序的安全性，保护数据
2.隐藏代码的实现细节
3.统一接口
4.系统可维护性增加

3.封装实现的步骤：

设置属性的可见性为：private -> 创建setter/getter方法 -> 在方法中添加属性控制语句

举个例子：

public class Student {
    private String name;
    private int id;
    private char sex;
    private int age;

    //提供一些可操作的方法，get set

    //get 获得这个数据
    public String getName(){
        return this.name;
    }

    //set 给这个数据设置值
    public void setName(String name){
        this.name = name;
    }
    //alt + insert

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age>120||age<0)  this.age=3;
        else this.age = age;
    }
}

四.方法重写：

1.定义：

 重写：是父类与子类之间的多态性，实质是对父类函数的重新定义。在子类中定义某方法与其父类有相同的名称和参数则该方法被重写，但子类函数的访问修饰权限不能小于父类；

 若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法，如需父类中原有的方法则可使用 super 关键字。

2.重写的注意点：

1.方法名必须相同
2.参数列表必须相同
3.修饰符的范围可以扩大，但不能缩小
4.抛出异常：范围可以被缩小，但不能扩大

注意：静态方法与非静态方法：

静态方法：可以被继承，但不能被覆盖，既不能被重写
非静态方法：可以被重写，但关键词不能是private

举个例子：

//父类代码块
public class B {

        public  void test(){
            System.out.println("B->test");
        }
}

//子类代码块
public class A extends B{

    //重写
    @Override //注解：有功能的注释
    public void test() {
        System.out.println("A->test");
    }
}

//测试代码块
public class Application {
    public static void main(String[] args){

        A a = new A();
        a.test();
        //父类的引用指向子类
        B b = new  A();
        b.test();
    }

父类引用指向子类对象：
 定义了父类B的引用，指向新建的A类型的引用。子类是对父类的一个改进和扩充，所以子类较父类的功能一般更强大，定义父类类型指向子类的可以使子类的功能更加强大，属性较父类更加特别，且可以调用父类中所有的属性和方法，而对于子类中定义而父类中没有的方法，是不可以调用的。

父类中定义的方法，如果子类中重写了该方法，那么父类类型的引用将会调用子类中的这个方法

上述代码的输出结果：

五.继承

1.继承的实现：

语法：class 子类 extends 父类{}

举个例子：

public class Person {
    protected String name = "张三";
    public void print(){
        System.out.println("Person");
    }
}

public class Student extends Person{
      private String name = "李四";
      public void print(){
          System.out.println("Studnet");
      }
}

注意：子类对象在进行实例化之前，先调用父类中的构造方法，再调用子类中的构造方法实例化子类对象
举个例子：

//父类
public class Person {
    public Person() {
        System.out.println("Person无参构造执行");
    }
}
//子类
public class Student extends Person{
     public Student() {
      System.out.println("Student无参执行");
    }
}
public class Teacher {
    public static void main(String[] args){
        Student student = new Student();
    }
}

补充：1.Java四种权限修饰符

2.super关键字的使用

注意：
1.super调用父类的构造方法，必须在构造方法的第一个
2.super 必须只能出现在子类的方法或者构造方法中
3.super和this不能同时调用构造方法

举个例子：

//父类代码
public class Person {
    protected String name = "张三";
    public void print(){
        System.out.println("Person");
    }
    public Person() {
        System.out.println("Person无参构造执行");
    }
}

//子类代码
public class Student extends Person{
      private String name = "李四";
      public void print(){
          System.out.println("Student");
      }
    public void test1(){
        print(); //调用当前类
        this.print();  //调用当前当前类
        super.print();  //调用父类的
    }
      public void test(String name){
          System.out.println(name);  //输出传入的名字
          System.out.println(this.name); //输出本身调用者的对象的名字
          System.out.println(super.name); 输出父类的名字
      }

    public Student() {
          //隐藏代码，调用了父类的无参构造
        super();//调用父类构造器，必须在子类的构造器的第一行
        System.out.println("Student无参执行");
    }
}
//调试代码
public class Teacher {
    public static void main(String[] args){
        Student student = new Student();
        student.test("王五");
       student.test1();
    }
}

输出结果显示：

总结：继承的限制：
1.子类在进行实例化前首先调用父类的构造方法，再调用子类的构造的方法实例化子类对象
2.Java继承只允许多继承，不允许多继承，即一个子类只能有一个父类，但一个父类可以有多个子类
3.Java继承的时候，子类会继承父类的所有结构，但对于父类私有的不可以直接调用，但可以通过其他方式

六.多态

1.概念：

 按字面的意思就是“多种状态”。在面向对象语言中,接口的多种不同的实现方式即为多态。

多态的注意事项：
1.多态是方法的多态，属性没有多态。
2.父类和子类之间有联系才可以进行转化
3.存在条件：继承关系 方法需要重写 父类引用指向子类对象

父类引用变量在调用方法的时，会调用子类重写后的方法

2.语法：

父类类型 变量名 = new 子类类型();

3.多态中成员的特点

1>.多态成员变量：编译运行看左边

举个例子：

//父类：
public class Person {
    public int num = 10;
    public void run(){
        System.out.println("run");
    }
}
//子类：
public class Student extends Person {
    public int num = 15;
    @Override
    public void run() {
        System.out.println("son");
    }
}
//调用函数
public class Application {
public static void main(String[] args) {
        Student s1 = new Student();//Student能调用的方法都是自己的或者父类的
        Person s2 = new Student();//Person 父亲类可以指向子类，但是不能调用子类独有的方法
        System.out.println(s2.num);
    }
}

输出结果为：10

2>.多态成员方法：编译看左边，运行看右边

举个例子：

//子类和父类的代码如上
//调用函数
public class Application {
public static void main(String[] args) {
        Student s1 = new Student();//Student能调用的方法都是自己的或者父类的
        Person s2 = new Student();//Person 父亲类可以指向子类，但是不能调用子类独有的方法
        s2.run();  
        s1.run();
    }
}

运行结果：

4.instanceof关键字

测试左边的对象是否是右边类或者该类的子类创建的实例对象，是，则返回true，否则返回false。

注意： 返回类型为布尔类型
举个例子：

//父类
public class Person {
}
//子类1
public class Student extends Person {
}
//子类2
public class Teacher extends Person{
}
//测试代码
public class Application {
public static void main(String[] args) {
        Object object = new Student();
        System.out.println(object instanceof Student);
        System.out.println(object instanceof Person);
        System.out.println(object instanceof Object);
        System.out.println(object instanceof Teacher);
        System.out.println(object instanceof String);
        //instanceof可以判断不同的类之间是否是父与子的关系，若没有关系则编译会报错
        System.out.println("--------------------------------");
        Person person = new Student();
        System.out.println(person instanceof Student);
        System.out.println(person instanceof Person);
        System.out.println(person instanceof Object);
        System.out.println(person instanceof Teacher);
    }
}

运行结果：

5.多态的转型
多态的转型分为向上转型和向下转型两种
向上转型：子类转化为父类
向下转型：父类转化为子类，可能会导致方法的丢失