java基础知识

一、类和对象

类和对象

类是一种实体类型的抽象，它是一个新的数据类型，从语言层面来看，类就是一个数据结构，类定义数据类型的数据（字段）和行为（方法）。而对象是基于类的具体实体，有时称为类的实例。
一般的这些个类都有一些内部状态数据，就是对于类而言，它包括属性和方法，比如苹果这个对象，它有甜度，大小等等这些属性特征，然后 苹果还可以被吃，这属于一种行为特征，其实就是一种方法，这里的方法其实就是面向过 程中的函数，表示一个功能，这里就可以表示苹果被吃了。（类的简单图示）

在Java中定义类，用关键字class完成`。

class Animal{//类名称的首字母大写
    //属性
    String name;
    int age;
    //方法
    public void eat(){
        System.out.println("动物吃肉");
    }
    public void sleep(){
        System.out.println("动物睡觉");
    }
}

一个类中可以包括的变量：

1. 局部变量：在方法或者语句块中定义的变量叫做局部变量。变量在方法中声明和初始化。
2. 成员变量：成员变量定义在类中，方法体外。这种变量在创建对象的时候实例化（分配内存）；成员变量可以被类中的方法和特定类的语句访问。
3. 类变量：类变量也声明在类中，方法之外，必须声明为static类型。

二、面向对象的三大特征思想

封装

• 封装机制：把描述对象属性的变量及实现对象功能的方法结合起来，定义一个程序单位，并保证外界不能任意更改内部属性，能任意调动内部的方法接口。
  优点：
  1.实现了低耦合高内聚；
  2.类内部的结构可以自由修改；
  3.隐藏实现细节，提出公共的访问方式。

class Person{
    
    String name;
    String age;
    public Person(String name, String age){
        this.age=age;
        this.name=name;
    }

    public void setAge(String age) {
        this.age = age;
    }

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

    public String getAge() {
        return age;
    }

    public String getName() {
        return name;
    }
}

即为封装，现对代码进行测试

public class Test {
    public static void main(String[] args) {
    Person person = new Person("李四", "15");
    String name = person.getName();
    String age = person.getAge();
    System.out.println("我的名字"+person.getName()+"年龄"+person.getAge());
}
}

此时创建了一个Person对象，实例化时赋值，并通过getName和getAge方法获取对象名字和年龄。
输出如下：

在其他类中可以通过这样的构造方法设置name和age

 public Person(String name, String age){
        this.age=age;
        this.name=name;
    }

Person提供了这样的设置name和age的方法：

    public void setAge(String age) {
        this.age = age;
    }

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

此均为在Person内部定义的方法，也就是其他类不能直接控制name和age，所以在设定name和age时让这两个属性成为这个类的私有的，外界不能随意改动。

    private String name;
    private String age;

访问限定符：public protected 默认 private
public范围最广：在同类，同包，子类，不同包中都能被访问
protected范围次之：在同类，同包，子类。中都能被访问
默认限定符其次：在同类，同包中可以访问。
private限定符最后：只能在同类中访问

继承

• 继承：大大增强了代码的可复用性，提高了软件的开发效率为程序的修改扩充了材料。继承通过extends关键字进行实现，并且java.long.Object类是所有类的父类。
  局限性：
  1.Java中继承是单继承，即一个子类只能继承一个父类；
  2.支持多重继承，即一个父类可以有多个子类；
  3.在继承中只能继承非私有化的属性和方法；
  4.构造方法不能都被继承。

class Animal{
    private  String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public void show(){
        System.out.println(name+"会叫");
    }
}
public class Test1 {
    public static void main(String []args){
        Animal animal=new Animal();
        animal.setName("动物");
        animal.show();
    }
}

这里首先定义了一个动物类，运行结果

此时在定义一个小狗类来继承动物类

class Dog extends Animal{
}

定义后再使用以下方法得

 Dog dog=new Dog();
        dog.setName("小狗");
        dog.show();

虽然再小狗类中并无其他定义，但在创建小狗对象后仍可以调用setName和show方法。
小狗不仅会叫，还会吃肉，此时就可以在小狗类中编写自己特有得属性和行为。

class Dog extends Animal{
    public void eat(){
        System.out.print("还爱吃肉");
    }
}

继续调用小狗对象得方法

 Dog dog=new Dog();
        dog.setName("小狗");
        dog.show();
        dog.eat();

运行结果如下：

重载与重写

• 重写的规则
  1.参数列表必须完全与被重写的方法相同。
  2.返回的类型必须一直与被重写的返回类型相同。
  3.访问修饰符的限制一定要大于被重写的访问修饰符（public>protected>default>private）。
  4.重写方法一定不能抛出新的检查异常或比被重写的方法的申明更加宽泛的检查型异常。
  5.重写的主要优点是能够定义某个子类特有的特征。
  6.父类的成员方法只能被其子类所重写。
  7.声明static、private的方法不能被重写。
• 重载的规则
  1.方法名称必须相同。
  2.参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）。
  3.方法的返回类型可以相同也可以不相同。
  4.仅仅返回类型不同不足以成为方法的重载。
• 区别
  1.发生的位置：重载在一个类中，重写在子类中。
  2.参数列表限制：重载必须不同，重写必须相同。
  3.返回值类型：重载与返回值类型无关，重写返回值类型必须一致。
  4.访问权限：重载与访问权限无关，重写方法不能抛出比被重写方法更高层次的被检查异常。
  5.异常处理：与异常无关，重写不能抛出心得异常，但异常范围可以更小。

多态

• 多态：多态是同一个行为具有多种不同的表现形式或形态的能力。允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。(发送消息就是函数调用)。
  发生动态绑定（动多态)的三个条件:
  1.继承
  2.方法的重写
  3.向上造型基类引引用引用派生类对象)
  多态的优点：
  1.可替换性。多态对已存在代码具有可替换性。例如，多态对Animal类设计，对其他任何动物，如狐狸，也同样具有吃饭的行为，以及工作的能力。
  2.可扩充性。多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性，以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。例如:在实现了dog吃饭行为之后，还可以添加小狗特有的行为抓老鼠等。
  3.接口性。多态是父类通过方法声明，向子类提供了一个共同接口，由子类来完善或者覆盖它而实现的。

class Animal{
    private  String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public void show(){
        System.out.print(name+"会叫");
    }
    public void eat(){
        System.out.println("动物吃饭");
    }
}
class Dog extends Animal{
    public  void eat(){
        System.out.print("小狗爱吃肉");
    }
}
public class Test1 {
    public static void main(String []args){
        Animal animal=new Dog();
        animal.eat();

    }
}

运行结果

此时可以看到输出得结果时子类所具有得方法。
在调用时，子类得实现将父类得方法进行地址覆盖，进而运行出得结果时调用得子类得方法。

• 向上造型
  向上选型就是定义重类的引月入引用派生类的对象。Animal animal=new Dog(); animal引用.出来的方法是父类的方法接口，但是方法的实现却是子类的实现方式。
• 转型过程中需要注意的问题
  向上转型时，子类单独定义的方法会丢失。子类引用不能指向父类对象。
• 向上转型的好处
  令减少重复代码，使代码变得简洁。
  令提高系统扩展性。