提米 Java基础 类和对象

一：面向对象编程
面向对象与面向过程
面向对象(oop)与面向过程(pop)
二者都是一种思想，面向对象是相对于面向过程而言的。
面向过程，强调的是功能行为。面向对象能封装进对象，强调具备了功能的对象。
面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，
如 抽象、分类、继承、聚合、多态等。

面向对象的三大特征
封装 继承 多态

封装 ：：即将对象封装成一个高度自治和相对封闭的个体，对象状态（属性）由这个对象自己的行为（方法）来读取和改变。张三这个人，他的姓名等属性，要有自己提供的获取或改变的方法来操作。private name setName getName

继承 ：在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并可以加入若干新的内容，或修改原来的方法使之更适合特殊的需要，这就是继承。遗产继承

多态：是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。

Java类及类的成员（万物皆为对象）
现实中世界万事万物是由分子、原子构成的。同理，Java代码世界是由诸多个不同功能的类构成的。
（可以用Java语言来描述万事万物）
现实世界中的分子、原子又是由什么构成的呢？原子核、电子！那么，Java中用类class来描述事物也是如此。（把万事万物抽象成一个个的class类）
属性：对应类中的成员变量
行为：对应类中的成员方法
例子：人类
属性：高矮胖瘦
行为：吃饭、睡觉、工作。。。。
Field = 属性=成员变量，Method=(成员)方法=函数
类与对象的基本概念
类与对象时整个面向对象中最基础的组成单元。
类：是抽象的概念集合，表示的是一个共性的产物，类之中定义的是属性和行为（方法）；
对象：对象是一种个性的表示，表示一个独立的个体，每个对象拥有自己独立的属性，依靠属性来区分不同对象。
可以一句话来总结出类和对象的区别：类是对象的模板，对象是类的实例。类只有通过对象才可以使用，而在开发之中应该先产生类，之后再产生对象。类不能直接使用，对象是可以直接使用的。

二：类的写法
创建Java自定义类
步骤：
1、定义类（考虑修饰符、类名）。
类的修饰符：public，默认，abstract，final。

public class Test1 {}
class Test2{}
abstract class Test3{}
final class Test4{}

其中public表示任意位置都可以访问该类；
不写表示默认访问修饰符，即在同一个包中可以访问；
abstract是表示该类为一个抽象类，不能实例化该类，即不能使用Test3 test3 = new Test3();的方式获取Test3的实例。如果要使用它则需要找一个类继承该类；
注意：一个抽象类中可以没有抽象方法，但是有抽象方法的类必须是一个抽象类
final表示该类不能被子类继承，该类即为最终类，不可再被继承。

2、编写类的属性（考虑修饰符、属性类型、属性名、初始化值）

private（私有修饰符）、protected（保护访问修饰符）、public（权限修饰符）、缺省
访问范围：
public：可被所有类引用；
protected：可被该类自身、子类(只能在子类中通过子类对象来调用)、同一包中的其他类引用；
private：仅可被该类自身引用和修改，不能被其他任何类(包括子类)引用。
缺省(没有访问控制符)：可被该类自身、本包中的类引用。
3、编写类的方法（考虑修饰符、返回值类型、方法名、形参等）
public 、 private、 protected 、 默认修饰符（缺省）
访问范围：
public：可被所有类引用；
protected：可被该类自身、子类(只能在子类中通过子类对象来调用)、同一包中的其他类引用；
private：仅可被该类自身引用和修改，不能被其他任何类(包括子类)引用。
缺省(没有访问控制符)：可被该类自身、本包中的类引用。
例子

//人类Person
public class Person {

//属性，成员变量，类的成员变量可以先声明，不用初始化，类成员变量是有默认值
    String name;//姓名，String的默认值是null
    int age;//年龄，int的默认值是0

        //行为，方法也叫函数
    public void showName(){//打印姓名
        //方法的名称如果是多个单词，首个单词的首字母小写，其他的单词首字母大写，这样像一个驼峰一样，所以的叫驼峰命名法
        System.out.println("姓名是"+name);
    }
    public int getAge(){//获取年龄
        return age;
        //如果是一个有返回值的方法，那么方法的最后一行一定是返回相应的数据，使用return关键字，返回的数据类型与方法定义的一致
    }

三：对象的创建和使用
对象的创建和使用
Java类及类的成员（如何使用Java的类？）Java类的实例化，即创建类的对象。
例子：

public static void main(String[] args) {
    //实例化Person类，也就是创建Person对象
    Person person=new Person();
    //声明一个Person类型的变量，变量名person，实例化Person类并且给person赋值，赋值的值就是当前的实例化
    //new Person();就是实例化Person类
    person.name="提米";//给person对象的name属性赋值
    int i =person.getAge();  //对象的方法的调用
    //有返回值的方法，在调用之后就会有一个值，这个值就是方法中return的那部分。
    person.showName();//调用showName的方法
    System.out.println(person);//姓名是提米
    System.out.println(i);//0
    person.age=66;//给person对象的age属性赋值
    int a=person.getAge();
    System.out.println(a);//66
    //未来可能会学习更复杂的类，我们会给这些类创建对象，并且使用对象
    //对于对象的使用无外乎就两个地方，操作对象的变量，调用类方法
}

四：类的属性
类的成员之一：属性
语法格式：
修饰符 类型 属性名=初值；
说明：修饰符private:该属性只能由该类的方法访问。
修饰符public：该属性可以被该类以外的方法访问。
类型：任何基本类型，如int,boolean或任何类。
举例：

  public class Person{
private int age;//声明private变量age
public String name="timi"；//声明public变量name
}
//public 公有的，这样的类变量可以在类的外部使用，也可以在本类的方法使用
//private私有的，可以在本类的方法使用，不能做了类的外部使用
//修饰符可以用来修饰变量，可以指明变量是公有还是私有，私有的类变量不能通过对象.属性的方式调用。

成员变量（属性）和局部变量的区别？
成员变量：
成员变量定义在类中，在整个类中都可以被访问。
成员变量风分为类成员变量和实例成员，实例变量存在于对象所在的堆内存中。
（实例变量只能是在类实例化后的对象中可以使用）
成员变量有默认初始化值。
成员变量的权限修饰符可以根据需要，选择任意一个
局部变量：（局部变量只能在它所属的方法的范围内可以使用）
局部变量只定义在局部范围内，如：方法内，代码块内等。
局部变量存在于栈内存中。
作用的范围结束，变量空间会自动自动释放。
局部变量没有默认初始化值，每次必须显示初始化。
局部变量声明时不指定权限修饰符。

构造方法;
与类名同名，在创建对象时，对象成员可以由构造方法进行初始化。
构造方法的任务就是初始化一个对象内部的状态。
例子：

//人类Person
public class Person {
    String name;
       int age;
    public Person(){  } //无参构造
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }//有参构造

//get、set方法
    public String getName() {
        return name;
    }

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

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

    public int getAge() {
        return age;
    }

//toString 方法
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

静态static变量/方法在类加载的过程中被初始化，在内存中只存在一份，所以可以把它当作是全局变量/方法。
优点
属于类级别的，不需要创建对象就可以直接使用.
全局唯一，内存中唯一，静态变量可以唯一标识某些状态.
在类加载时候初始化，常驻在内存中，调用快捷方便.
应用场景：

1. 静态方法最适合工具类中方法的定义；比如文件操作，日期处理方法等.
2. 静态方法适合入口方法的定义；如单例模式，因为从外部拿不到构造函数，所有定义一个静态的方法获取对象非常有必要.
3. 静态变量适合全局变量的定义.（如布尔型静态成员变量做控制符）
   缺点
   静态方法不能调用非静态的方法和变量.（非静态方法可以任意的调用静态方法/变量）
   不能使用this和super关键字（属于类级别，没有创建对象签不可用this/super)
   常量
   1、定义一个接口常量
   2、定义枚举
   3、定义一个类，类中属性用static final修饰 public static final String SUNDAY = “SUNDAY”; （只有属性没有方法）
   4、定义一个类，类中熟悉用static final修饰
   例子：

public static final String SUNDAY = "SUNDAY"; （有属性还有静态方法）
public static String getSunday() {  
       return SUNDAY;  
  } 

方法
所谓方法，就是用来解决一类问题的代码的有序组合，是一个功能模块。
一般情况下，定义一个方法的语法是：

其中：
1、 访问修饰符：方法允许被访问的权限范围， 可以是 public、protected、private 甚至可以省略 ，其中 public 表示该方法可以被其他任何代码调用，其他几种修饰符的使用在后面章节中会详细讲解滴
2、 返回值类型：方法返回值的类型，如果方法不返回任何值，则返回值类型指定为 void ；如果方法具有返回值，则需要指定返回值的类型，并且在方法体中使用 return 语句返回值
3、 方法名：定义的方法的名字，必须使用合法的标识符
4、 参数列表：传递给方法的参数列表，参数可以有多个，多个参数间以逗号隔开，每个参数由参数类型和参数名组成，以空格隔开
根据方法是否带参、是否带返回值，可将方法分为四类：
Ø 无参无返回值方法
Ø 无参带返回值方法
Ø 带参无返回值方法
Ø 带参带返回值方法
Java 中无参无返回值方法的使用
如果方法不包含参数，且没有返回值，我们称为无参无返回值的方法。
方法的使用分两步：
第一步，定义方法
例如：下面代码定义了一个方法名为 show ，没有参数，且没有返回值的方法，执行的操作为输出 “ welcome to imooc. ”

注意哦：
1、 方法体放在一对大括号中，实现特定的操作
2、 方法名主要在调用这个方法时使用，需要注意命名的规范，一般采用第一个单词首字母小写，其它单词首字母大写的形式
第二步，调用方法
当需要调用方法执行某个操作时，可以先创建类的对象，然后通过 对象名.方法名(); 来实现（关于类和对象的概念在后面章节中会详细讲解滴，先熟悉语法，表着急哦~~）
例如：在下面的代码中，我们创建了一个名为 hello 的对象，然后通过调用该对象的 show( ) 方法输出信息

运行结果为： welcome to imooc.

方法重载的依据：
1、 必须是在同一个类中
2、 方法名相同
3、 方法参数的个数、顺序或类型不同
4、 与方法的修饰符或返回值没有关系

对象：

对象的引用
在Java语言中一切都可以看作对象，单正在的操作标识符实质上是一个引用，引用在Java中的语法如下：
类名 对象引用名称
Book book；这边是引用
Book book=newBook（）；这边是引用与对象相关联
引用只是存放一个对象的内存地址，并非存放一个对象。严格地说，引用和对象是不同的，但是可以将这种区别忽略，如可以简单地说book是Book的一个对象，而事实上应该是book包含Book对象的一个引用。

对象的比较
Java语言中有两种对象的比较方法，分别为“”运算符和equals()方法。
equals（）方法是String类中的方法，它用于比较两个对象引用所指的内容是否相等
而”“运算符比较的是两个对象引用的地址是否相等。

public static void main(String[] args) {
        String c1=new String("timi");
        String c2=new String("timi");
        System.out.println("==       c1和c2运算结果"+(c1==c2));//false
        System.out.println("equals   c1和c2运算结果"+c1.equals(c2));//true
    
}

对象的销毁
每个对象都有生命周期，当对象的生命周期结束时，分配给该对象的内存地址将会被回收。在其他语言中需要手动回收废弃的对象，但是Java拥有一套完整的垃圾回收机制，用户不必担心废弃的对象占用内存，垃圾回收器将回收无用的但占用内存的资源。
Java将下面两种情况视为垃圾：
1.对象引用超过作用范围。
2.将对象赋值为null。
回收机制只能回收使用new创建的对象，如果不是通过new在内存中获取了一块内存，这种对象可能不被垃圾回收机制所识别，所以java提供了一个finalize（）方法，这个方法是Object类的方法，它被声明为protected，用户可以在自己的类中定义这个方法，如果在类中定义了这个方法，在垃圾回收时，会首先调用该方法，在下一次垃圾回收动作发生时，才能真正回收内存。
java还提供了System.gc（）方法强制启动垃圾回收器。