JavaSE基础01-类和对象相关概念

Java类和对象

回顾历史发展，从低级语言到高级语言的过程中，出现过面向机器、面向过程、面向对象编程等概念。
1.面向机器： 程序=数据+指令
2.面向过程： 程序=数据结构+算法
3.面向对象： 程序=对象+消息
在这里我们主要阐述面向对象的思想，其他编程思想仅作了解扩展即可。

对象：类的实例
消息：对象之间的交互方式
类：一个具有某些共同特征的实体（对象）的集合
继承：在现有类的基础上，对父类（超类）进行扩展
封装：主要是把变量成员变成私有的，不让外界直接访问；即对外只提供一个接口，调用者只需调用，无需了解如何实现。其实可以有很多种解释方式，选择其中一个自己最能理解的即可。

类和对象

类是一种对象的设计蓝图，对象是类的实例；如果设计了一个类我们从来不去使用它，那么这个类就是垃圾代码。

//A 是一个类
   class A{
                int i;
                void  aaa(){}
          }
     A a = new A();//a是一个实例对象

类定义格式

Notice：[]表示可选的

[修饰符关键字] class 类名 [extends 父类名] [implements 接口列表(多个接口用逗号隔开)]
public private final strictfp 都是修饰关键字
{
//类体的内容
}
所有的类都是object的子类
public 公开的
abstract 表示这个类不能被实例化 ，只能被继承
final 表示这个类不能被继承
strictfp 表示这个类处理数值遵守某种严格的规范；使用较少，感兴趣自行google

	类的主要成员： 变量成员和方法成员
	变量成员的定义格式：	[修饰关键字]  类型  变量名;
	方法成员的定义格式：	[修饰关键字]  返回类型 方法名([类型 参数名，类型 参数名]){方法体内容};

Java类和成员的修饰符

修饰符	可修饰对象	含义
public	类、接口、成员方法、成员变量	可跨包访问
private	成员变量、成员方法	类内可访问
protected	成员变量、成员方法	同一个包内可访问，跨包子类可访问
static	类、接口、成员变量、成员方法	静态内部类不能有对外调用，成员独立于任何实例对象；
synchronized	成员方法	用于保持线程同步
final	类、接口、成员变量、成员方法	没有子类的类；不能改变变量的值，不能改变值得字段；不能被重写的方法
abstract	类、接口、成员方法	定义抽象类，抽象类不能被实例化，类中能定义抽象方法；所有接口都是抽象的，是接口缺省修饰符；抽象方法是等待被实现的方法。

//abstract 表示这个类不能被创建，只能声明；只有抽象类，才能定义抽象方法
public  abstract class abstractClass {
        public String 变量1;
        public String 变量2;

        public  void 抽象类的方法(){//有方法体的方法

        }

        //抽象方法没有方法体，没有大括号，用分号结束； 目的：用来规定子类的方法
        public abstract void 抽象类的抽象方法();
}

//final 表示该类不能被继承，扩展的
public  final class MyClass {
    private String 私有实例变量;//最小范围 ：当前类的内部可以访问
    public String 公共实例变量;//最大范围
    protected  String 受保护的实例变量;//同包下的类，和不同包的子类可以访问
    String 默认包的实例变量;//自己类和同包下的类可以访问
    public static String 静态变量;//全局变量，公共的，不受实例限制，大家共用一个
    public final Double PI=3.1415926;//表示这个是一个常量，一经赋值，不能改变

    public final void 我的final实例方法(){//表示这个方法不能子类（派生类）被重写;  Notice:注意重载和重写的区别
        System.out.println("我的final实例方法");
    }


    //synchronized同步:当多个线程调用这个方法时，同步访问;保持线程同步
    public synchronized  void 我的同步方法(){

    }

    public  static void 我的静态方法(){
        System.out.println("我的静态被调用了 静态变量="+静态变量);
    }

    void 我的实例方法(){
        System.out.println("我的默认包方法被调用了");
    }

    public void 我的public实例方法(){
        System.out.println("我的public方法被调用了");
    }


    private void 我的private实例方法(){
        System.out.println("我的private方法被调用了");
    }

    protected void 我的protected实例方法(){
        System.out.println("我的protected方法被调用了");
    }
}

public class Test1 {
    public static void main(String[] args) {
        MyClass obj = new MyClass();
        //实例方法和变量只能创建出来的实例对象才可以调用
        obj.公共实例变量="abc";
        obj.我的public实例方法();
        //静态方法和静态变量不属于实例对象，使用时通过类名直接调用
        MyClass.静态变量="china";
        MyClass.我的静态方法();
    }
}

//abstract 表示这个类不能被创建，只能声明；只有抽象类，才能定义抽象方法
abstract class abstractClass {
        public String 变量1;
        public String 变量2;

        public  void 抽象类的方法(){//有方法体的方法

        }

        //抽象方法没有方法体，没有大括号，用分号结束； 目的：用来规定子类的方法
        public abstract void 抽象类的抽象方法();
}

public class test2Abstract extends abstractClass {

    //抽象类的子类（非抽象的）要求必须实现父类中的所有抽象方法
    public void 抽象类的抽象方法() {

    }
}

Java初始化

构造器返回当前的类，如果没有写构造器，java编译器会自动添加构造器；如果自己添加了构造器，java编译器则不会添加了
在java中初始化和创建是捆绑在一起，无法分离的；
构造器在new className();时自动调用
可以重载构造器，在new className();时根据参数的不同，编译器会自动匹配对应的构造器。

方法重载：重载方法时只能以方法名和参数列表来区分；不能以返回值类型来区分。
方法重写：继承父类的方法，并重写。

class Tree{

    int height;
    Tree(){
        System.out.println("这是一个构造器");
    }
    Tree(int initialHeight){
        this.height=initialHeight;
    }

    void info(){
        System.out.println("Tree is"+height+" feet tall");
    }

    void info(String s){//方法重载

    }
}

this关键字

直接在类中使用this 表示调用当前类；即对当前对象的引用
this可以在构造器中调用构造器

java垃圾回收基础了解

1.finalize()的用途
finalize（）跟垃圾回收器有关，垃圾回收器跟内存有关
垃圾回收器当内存不够的时候才会工作，但我们可以调用System.gc()方法强制垃圾回收器工作，但不建议频繁使用；因为调用System.gc()本身也耗费资源和内存。

2.java垃圾回收器如何工作？
java垃圾回收器是自适应的方式，追踪所有活动对象的地址，找其引用；然后根据其内存中的情况调用不同的清除方法。
停止-复制 ：垃圾比较多的时候用这种方法；主程序要先暂停工作，再执行停止-复制。
标记-清扫 ：垃圾比较少的时候用这种，速度相当慢；剩下堆空间通常是不连续的。

public class TestFinalize {
    public static void main(String[] args) {
        TestFinalize testFinalize = new TestFinalize();
        testFinalize.Test();
        System.gc();
    }

    public void Test(){
        A obj= new A("Tom");
    }
}

class A{
    String name ="";
    A(String name){
        this.name=name;
    }


    //当这个类的实例对象被垃圾回收时，就会调用这个方法
    @Override
    protected void finalize() throws Throwable {
        super.finalize();
        System.out.println(name+" 对象被销毁了");
    }

}