类和对象

面向对象

在java里一切皆视为对象，对象具有属性和方法，对象具有唯一性，对象是某个类的实例

面向对象的三大特性

继承，封装，多态

继承

继承通过extends关键字来实现继承就是子类可以继承父类的属性和方法，比如A类和B类有一些共同的属性和方法，如果写两个类就会造成代码的冗余量高，代码重复，所以我们可以将A和B共同的属性和方法都放在C类里，然后A类和B类去继承C类

 class A{
    public String name="A";
 }
 class B extends A {
    public int age=18;
 }
 //B继承了A 这就是继承

封装

封装就是在于保护信息，java的基本封装单位是类，类里边提供了私有和共有的访问模式，私有的属性和方法只能通过该类的成员代码来访问。

多态

多态即是一个接口，多个方法，当父类中的属性和方法被子类继承后，可以具有不同的属性和表现方式，多态性允许一个接口被多个同类使用

类的定义

java里的类是通过class关键字来定义的

class demo{
    //这样就定义了一个类
    public static String name; //定义了一个属性
    public static int getAge(){ //定义了一个方法
      return 18;
    }
}

关键字

以下是定义类和类的属性和方法的关键字

   public 公共的，可以被成员访问的
   
   abstract  用来修饰抽象类，如果类被abstract修饰则表示抽象类，抽象类不能被实例化，但是可以有方法，继承该抽象类的所有子类必须实现该类的
   所有抽象方法

   final 如果类被final修饰则不允许被继承

   extends 继承其他类
   
   private 私有的 不能被继承
    
   static 静态
   
   protected 私有的 可以被继承
   
   final 定义属性时视为
   常量，不可以被修改

成员方法

成员方法可以定义类的行为，一个完整的方法通常包括，方法名，方法主体，方法的返回类型，方法的参数

this

this是指针，它可以调用当前类的属性和方法，也可以通过this()相当于当前类的构造方法

 //类实战
 import java.util.Calendar;

public class ClassDemo {
 private boolean Sex;
 public String name;
 public int age;
 public boolean isSex(){
     return this.Sex;
 }
 public void setSex(boolean sex){
     this.Sex=sex;
 }
 public static void main(String [] args){
     ClassDemo one=new ClassDemo();
     one.name="张三";
     one.age=18;
     one.setSex(true);
     String isMan=one.isSex()?"男":"女";
     System.out.println("姓名:"+one.name+"年龄"+one.age+"性别"+isMan);
     ClassDemo two=new ClassDemo();
     two.name="凤霞";
     two.age=16;
     String isWoMan=two.isSex()?"男":"女";
     System.out.println("姓名:"+two.name+"年龄"+two.age+"性别"+isWoMan);
 }
}

创建对象

对象是类的实例化，对象具有状态和行为，java里的对象是有声明周期的，创建，使用，清楚

显式创建

class Demo{
   public static void main(String [] args){
       Demo demo=new Demo(); 
       
       //这是一种显式创建对象的一种方法
       // 除了这种还有通过java.lang.Class.newInstance创建
   }
}

无论是哪种方法创建对象,java虚拟机在创建一个对象时都要经过:给对象分配内存，将对象的实例变量自动初始化为其变量类型的默认值，初始化对象给实例变量赋予正确的初始值。 java里的每个对象都是相互独立的，在内存中占有独立的内存地址，并且每个对象都有自己的生命周期，当一个对象的生命周期结束时，对象就变成了垃圾，由java虚拟机带的垃圾回收处理

匿名对象

匿名对象就是直接通过new 类名().方法来使用类的方法，而且匿名对象一般只使用一次，且匿名对象只在堆里来开辟空间，不存在栈的引用

 new Demo();//这就是匿名对象
 //且匿名对象只使用一次就等待被垃圾回收机制回收

访问对象的属性和方法

可以直接通过对象名.属性/方法来访问

 String student=new Student();
 System.out.println(student.name);

 //访问对象的属性或者方法，对象一定要被实例化，如果不实例化而去直接使用则会报错

对象的销毁

对象使用完之后就需要对其进行清楚，在创建对象时，用户必须使用new操作符为对象分配内存。不过在清楚内存时由系统自动进行垃圾回收

一个对象被，垃圾回收有两种情况

Object o=new Object();
 //当超过对象o的作用范围时，这个对象将被视为垃圾

 o=null;
 //当对象被赋值为null时被视为垃圾。

之前提过Object类是所有类的父类，Object类中提供了一个finalize方法，因此任何java类都可以覆盖这个方法，在这个方法中进行释放对象所占有资源的操作

在堆内村里每个对象都可能处于以下三种状态

  1. 可触及状态:只要对象还在被引用就处于可触及状态。
  2. 可复活状态:当程序不再有任何变量引用该对象时，对象就进入可复活状态，在这个状态下，垃圾回收器会准备释放它的内存，在释放之前，会调用它及其他处于可复活状态的对象的finalize方法，这些finalize方法可能使该对象重新转到可触及状态
  3. 不可触及状态，当执行完所有的finalize方法后，如果没有使对象转到可触及状态，垃圾回收器会进行回收占用的内存。

修饰符解释

private 只能被该类自身的方法访问，不能被其子类访问
friendly 这个修饰符是默认的，只能被同一个包中的类访问
protected 可以被当前类访问，在同一个包中的其他类访问，在其他包中的该类的子类访问
public可以被任意类访问

static 静态

 被static修饰的可以被称为:静态变量/静态类/静态方法


  静态方法不能调用非静态成员否则会报错

  在当前类的内部，可以在任何方法里访问静态变量，其他类需要通过类名.静态成员

  在当前类，如果是非静态方法可以直接访问实例变量，在静态方法里需要通过类的实例对象来进行访问

  静态变量可以被所有类的实 例共享


  静态方法不需要通过实例就可以调用，但是静态方法里不能使用this关键字和super,但是可以访问当前类的静态变量和静态方法

  静态代码块，静态代码块可以在类中的任何地方，但是不能存在任何方法体中，非静态代码块是在创建对象时直接执行的

 static { } //静态代码块
 {} //代码块

静态导入

正常的导入通过import ，静态导入是通过import static 进行导入但是import static 只用于导入指定类的某个静态成员变量，方法或者全部的静态成员变量，方法

import static com.Demo.*;  // 导入包com下的Demo类的所有静态成员变量，方法
import static com.Demo.test;
// 导入包com下的Demo的静态方法test

final

final 用于修饰常量，希望被重写发的方法，不希望被继承的类

final修饰的变量，不能被重新赋值

final 修饰的方法不能被重写

final 修饰的类不能被其他类继承

mian方法

main方法是java的入口方法，程序在运行的时候第一个执行的就是main方法，一个类只能有一个main方法，main方法只接口一个字符串参数(这个参数是在命令行运行的时候命令行传入的),main方法没有返回值只能使用void,mian方法是静态的如果要调用当前类的其他方法只能通过实例调用

public class Test {
    public static void main(String [] args){
        //这里的args就是参数
    }
}

方法的可变参数

因为在实际的开发中，根据业务场景，方法的参数个数是不确定的，所有java有了可变参数

 public void print(String ...names){
         System.out.println("参数的个数有"+names.length);
         for(int i=0;i<names.length;i++){
             System.out.println(names[i]);
         }
    }
    // names这时候是一个数组，它包含了传递的参数

类的构造方法

在类里边与类名一样的方法，就是当前类的构造方法，而且类的构造方法不能被static 和final等关键词修饰。构造方法是在new 的时候执行的可以传递参数。如果不在类里写构造方法那么java会自动有一个构造方法

public class demo{
   public  demo(){
      //demo就是demo类的构造方法
    }
}

析构函数(finalize)

构造函数是当对象脱离其作用域时，系统自动执行析构方法。其实就是当我们用完对象之后不再进行引用，垃圾回收器会执行finalize方法，但是垃圾回收器何时执行以及执不执行都是不确定的，如果垃圾回收器在执行finalize方法的时候出现异常，不会报错，程序继续运行。

public class demo{
 public static void main(String [] args){
     count ct1=new count();
     System.out.println(ct1.get_counts());
     count ct2=new count();
     System.out.println(ct2.get_counts());
     ct2=null;
     try{
         System.gc();    // 清理内存
         Thread.currentThread().sleep(1000);    // 延时1000毫秒
         System.out.println("数量："+ct1.get_counts());    // 输出
     }catch (InterruptedException e){
         e.printStackTrace();
     }
 }
}
 class count{
    private static int counts=1;
    public count(){
         this.counts++;
    }
    public int get_counts(){
        return this.counts;
    }
    protected void finalize(){
        this.counts--;
        System.out.println("销毁");
    }
}

因为finalize的不稳定，在高版本java中已经被删除，如果我们想提示系统尽快垃圾回收，使用System.gc方法或者Runtime.gc()方法

包(package)

随着项目的实际开发，我们需要的类越来越多不便于管理，所以有了包这个概念。

定义包

使用package关键字定义包

//package 包名.类名
package com.demos;
//每个文件只能有一个package
// 且package语句要放在文件的第一行

导入包

导入包使用import关键字

import 包名.类名;
//这是导入单个类
import 包名.*;
//这是导入包下的所有i类

系统包

java给我们提供了一些系统包

 lang 核心类库，包含了基本数据类型，数学函数，字符串处理，异常处理和线程类

 io 输入输出类库，夺取文件等

 awt 构建界面，图形界面组件，用户交互

 image 操作图片

 peer 是java在不同的平台上运行

 net 实现网络功能的类库

 reflect 反射对象的工具

 util.zip 压缩工具

 awt.datatransfer 剪贴板，字符串发送等

 sql 

 rmi 提供远程连接

 security 安全

java的类和对象