Java面相对象

封装性

//注意类写的位置与函数写的位置的不同。
package reward;

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Random;

class Person {
    private String name;
    private int age;

    public void tell() {
        System.out.println("本人" + name + "年龄" + age);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
public class test {

    public static void main(String[] args) {
        Person p = new Person();
        p.setAge(18);
        p.setName("eric");
        p.tell();
    }
}
// eric

//匿名对象，不实例化直接调用
new Person().tell();//像这样直接创建调用，不进行实例化。

• static 修饰过的是静态、全局的意思。
  -静态方法不能调用非静态的属性以及方法。
• java中基础类型存放于栈区，引用类型的名字存放于栈区，开辟的空间位于堆区。
• 闰年规定不是能被整除的就是，规定如后面的算法，闰年算法怎么总是忘记：( (year%4==0)&(year%100!=0 ))||year%400==0
• Scanner用法

int n;
//常见Scanner对象
Scanner s = new Scanner(System.in);
//调用对象方法从控制台获取数据
n= s.nextInt();

System.out.println(Person.name);//静态成员变量可以直接通过类名调用。也可以使用对象进行调用以及修改。

• 对类成员进行初始化的方法

package reward;

class Person {
    int n1;
    int n2;
    static int n3;

    // 构造函数初始化
    public Person() {
        this.n1 = 11;
        System.out.println("构造函数初始化");
    }

    // 初始化块进行初始化
    {
        this.n2 = 12;
        System.out.println("初始化块进行初始化");
    }
    // 静态初始化块进行初始化
    static {
        n3 = 13;
        System.out.println("静态初始化块进行初始化");
    }
}

public class test {

    public static void main(String[] args) {
        Person p = new Person();
        Person p2 = new Person();
    }

}
/*运行结果
静态初始化块进行初始化
初始化块进行初始化
构造函数初始化
初始化块进行初始化
构造函数初始化
*/
//注意静态变量首先进行初始化，并且执行一次，构造函数最后进行。

• 包的使用

不同包下可以有相同名字的文件，通过import 可以引用各包内的类。

- 内部类

问：什么是内部类呢？

答：内部类（ Inner Class ）就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类。

问：那为什么要将一个类定义在另一个类里面呢？清清爽爽的独立的一个类多好啊！！

答：内部类的主要作用如下：

1. 内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类

2. 内部类的方法可以直接访问外部类的所有数据，包括私有的数据

3. 内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便

问：内部类有几种呢？

答：内部类可分为以下几种：

成员内部类
静态内部类
方法内部类
匿名内部类

//成员内部类示例
package com.javase.lang;

public class test {
    int out1 = 12;
    private int out2 = 13;

    // 创建成员内部类
    public class inner {
        int in1 = 14;
        int in2 = 15;

        public void tell() {
            System.out.println(test.this.out1);// 调用外部类属性方法。
        }
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        test t = new test();
        // 通过外部类对象创建内部类对象；
        inner i = t.new inner();

    }

}

• 静态内部类就是在内部类的基础上增加static关键字
  创建静态内部类对象的时候不用先创建外部类对象\
  
  • 方法内部类，就是在方法中定义的类，作用域是类方法，不能用static修饰。

继承

final关键字

final 修饰类、方法、属性、变量
修饰类，类不能被继承；
修饰方法，方法不允许重写；
修饰属性，必须在初始化的时候或构造函数中赋值；
修饰变量，只能被赋值一次，之后变为常量。

• super 调用父类的
  注意：如果父类重写了有参的构造方法，子类中默认是调用无参的构造方法，所以会出错。

多态

• 引用多态：父类对象可以指向自己也可以指向子类。
• 方法多态：
• 类型转换
  
  • 向上类型转换：（隐式/直接类型转换）即小类型向大类型转换，无风险。
  • 向下类型转换：（强制类型转换）即大类型向小类型转换，存在风险。

animal ani =new Dog();//向上类型转换
    Dog dog = (Dog) ani;  //向下类型转换、强制类型转换
    //下句错误，因为ani已经是dog类，在进行强制转换成Cat是会出错的
    // Cat cat = (Cat)ani;

    //使用instanceof来判断是否可以进行强制类型转换
    if(ani instanceof Cat){
        Cat cat = (Cat)ani;
    }else{
        System.out.println("不可以乱来！");
    }

• 抽象类：不关注子类的实现 ，但约束子类要实现哪些方法。
• 接口定义类的规范，规定类必须提供哪些方法。

//定义了接口IPlay，并让两个类继承了接口，在主函数中使用如下：
        IPlay p1 = new cellphone();//理解为向上类型转换，接口对象指向实现了接口的对象。
        p1.play();
        IPlay p2 = new psp();
        p2.play();

//输出为各自实例化的play方法

        //使用内部匿名类实现接口
        IPlay p3 =new IPlay() {
            @Override
            public void play() {
                    System.out.println("使用内部匿名类实现接口");
            }
        };

        p3.play();//调用方法

//这样也是内部匿名类的方法实现接口
new IPlay() {

            @Override
            public void play() {
                // TODO Auto-generated method stub
                System.out.println("这样也可以！");
            }
        }.play();