java的类和对象

类和对象

## 面向对象 在java里一切皆视为对象，对象具有属性和方法，对象具有唯一性，对象是某个类的实例 ## 面向对象的三大特性 继承，封装，多态 ### 继承 继承通过extends关键字来实现 继承就是子类可以继承父类的属性和方法，比如A类和B类有一些共同的属性和方法，如果写两个类就会造成代码的冗余量高，代码重复，所以我们可以将A和B共同的属性和方法都放在C类里，然后A类和B类去继承C类 java class A{ public String name="A"; } class B extends A { public int age=18; } //B继承了A 这就是继承

封装

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

多态

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

类的定义

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

java 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()相当于当前类的构造方法 ```java //类实战 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里的对象是有声明周期的，创建，使用，清楚 ### 显式创建 ```java class Demo{ public static void main(String [] args){ Demo demo=new Demo();

//这是一种显式创建对象的一种方法
    // 除了这种还有通过java.lang.Class.newInstance创建
}

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

匿名对象

匿名对象就是直接通过new 类名().方法 来使用类的方法，而且匿名对象一般只使用一次，且匿名对象只在堆里来开辟空间，不存在栈的引用 java new Demo();//这就是匿名对象 //且匿名对象只使用一次就等待被垃圾回收机制回收

访问对象的属性和方法

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

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

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

对象的销毁

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

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

```java 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,但是可以访问当前类的静态变量和静态方法

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

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

java 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方法是静态的如果要调用当前类的其他方法只能通过实例调用 java public class Test { public static void main(String [] args){ //这里的args就是参数 } }

方法的可变参数

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

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会自动有一个构造方法

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

析构函数(finalize)

构造函数是当对象脱离其作用域时，系统自动执行析构方法。其实就是当我们用完对象之后不再进行引用，垃圾回收器会执行finalize方法，但是垃圾回收器何时执行以及执不执行都是不确定的，如果垃圾回收器在执行finalize方法的时候出现异常，不会报错，程序继续运行。 java 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关键字定义包 java //package 包名.类名 package com.demos; //每个文件只能有一个package // 且package语句要放在文件的第一行

导入包

导入包使用import关键字 java import 包名.类名; //这是导入单个类 import 包名.*; //这是导入包下的所有i类

系统包

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

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

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

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

 image 操作图片

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

 net 实现网络功能的类库

 reflect 反射对象的工具

 util.zip 压缩工具

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

 sql 

 rmi 提供远程连接

 security 安全