Java学习笔记三

1、面向过程思想，强调的是过程(即动作,函数)；面向对象思想,强调的是对象。

2、类与对象关系:类是对事物的描述(属性和行为-方法),对象是类的实例。对象通过new生成。属性也称成员变量;方法也称成员函数。

/*Java代码都是在类中的,以下是Java的两种不同类:区别在于是否有main方法。
 * 有main函数的可以独立运行,且main函数是程序的入口
 * 如果没有main函数,就像其他面向对象的语言一样,通过new一个实例来运行
 */

public class Object{
    public static void main(String[] args){
        Car c=new Car();
        setColor(c,"red");
        c.run();
        /*0、Java中,如果一个对象只是为了执行 一个方法(而非访问变量) 一次,可以使用匿名对象
         * 匿名对象的特点是,在创建对象时可以执行 一次操作 ,之后就不能找到该对象,所以不能继续对其操作
         * 由于只能进行一次操作,所以只能执行方法,如果是操作成员变量,只能设置值或夺取默认值(无意义)
         * 这也是对这种用法的一种简化操作
         */
        new Car().run();
    }
    //1、有了对象,就有了一种新类型的参数:类类型,就是以类名为一种类型的参数,这种类型就是传入该类的一个实例进行操作
    public static void setColor(Car c,String color){
        c.color=color;
    }
}
class Car{
    //2、成员变量和下面的局部变量名字相同,但指向不同,所以值也不同
    //3、成员变量有初始值,如果没有显式设置,则使用默认值;成员变量也可以在实例化对象后用  对象.变量来访问和修改。
    int tyrenum=4;
    String color;
    void run(){
        int tyrenum=10;
        //4、this是在实例化对象时产生的变量,保存着当前对象,用于访问对象中的成员变量和成员方法
        System.out.println(this.tyrenum+"..."+color+"..."+tyrenum);
    }
}

3、对象的第一个特点就是封装：封装就是将一个类所需的变量和方法集中到一起,然后加上权限和相应的访问途径

小知识:main函数详解

public class ObjectPerson {
    public static void main(String[] args){
        Person p=new Person("asd",10);
        /*下面的操作是直接访问成员变量,如果是普通数据则没有问题,但是如果是重要数据且有存储/访问要求时
         * 例如年龄的值需要>0&&<130时就不能控制,此时就需要权限控制
         */
        //ming.age=10;
        p.speak();
        Person p1=new Person();
        p1.speak();
        /*下面打印main函数的参数,返回[Ljava.lang.String;@15db9742
         * 可以直到是一个字符串数组类型实体,并且检测长度为0,这是由用户输入参数的入口,在编译时可以传入,这里没有传入所以为0
         * 那为什么是字符串数组类型,因为字符串是使用最广泛的的类型,其他所有类型在传输时都是先转换为字符串然后在转为原来类型,
         */
        System.out.println(args+","+args.length);    
    }
}

class Person{
    //int age;    成员变量也称实例变量
    private int age;
    //编辑器中将鼠标放在属性名上,会弹出一个框,可以选择生成对应的set和get方法,及其位置
    private String name;
    /*1、类中除main以外另一个特殊的方法就是 类同名 方法,该方法在new一个新对象时自动执行
     * 称为 构造函数 ,用于初始化一个对象,并进行一些操作,如赋值操作
     * 如果没有显式设置构造函数,Java会设置一个空的构造函数进行使用。
     */
    /*2、构造函数和一般函数的区别:
     *  1、形式:构造函数没有返回值,不需要设置返回值类型,
     *  2、调用:构造函数在创建对象时自动调用一次,
     * 注意:一般函数也可以以类为名,只要有返回值类型就可以和构造函数区别,但是不要使用。
     */
    /*3、Java是强类型语言,参数必须符合相应类型,否则不能调用。但是Java也提供了一种重载技术,即同名函数只要参数类型或个数不同
     * 就认为是两个函数,在调用时根据参数来选择调用那个函数。所以说明:重载和强类型语言有关。
     * 这对于构造函数也同样适用。即构造函数也可以重载。
     */
    Person(){
        setName("baby");
        setAge(1);
    }
    Person(int age){
        setAge(age);
    }
    Person(String name){
        setName(name);
    }
    /*2、构造函数和一般函数的区别:
     *  3、调用:创建完对象之后不能显式的调用构造函数(包括构造函数的重载函数),但是可以用this在构造函数中调用其他构造函数(的重载)
     *     见下例,但是有要求:必须在构造函数的第一句执行(所以也只能有一个),因为其他重载的构造函数也是进行初始化,所以要首先进行  
     */
     Person(String name,int age){
        this(name);
        setAge(age);
    }
     /*4、构造代码块:从上面可以看到在Java中允许存在多个构造函数,针对不同的参数进行不同对象的初始化
      * 这样方便了产生不同对象,但是如果对象有相同的部分需要初始化就很麻烦
      * 此时就可以使用构造代码块,就是在类中定义一段代码块,不需要指定任何标示,
      * 这个代码块就会在new一个对象时自动运行一次,类似构造函数,但是又不针对具体对象
      * 注意:狗杂代码块先于构造函数执行
      */
    public void speak(){
        System.out.println("my name is "+this.name+",and i'm "+this.age+" old.");
    }
    //成员变量的最主要作用就是存储和读取,私有成员变量也是,但只能被 本类 中的方法访问。规范是使用set变量()和get变量()来存取
    public void setAge(int age){
        if(age>0&&age<130){
            this.age=age;
        }
    }
    public int getAge() {
        return this.age;
    }
    /*为什么要使用this关键字:就是为了解决下面的局部变量(即参数name)和成员变量name重名的问题,
     * 因为所有的函数都会在栈中执行,参数也就是局部变量,如果和成员变量同名,就会优先指向局部变量,
     * 所以此时对变量的所有操作都会在函数结束后消失,和成员变量没有关系,为了解决这个问题,就用this来代替对象,
     * 这样就和成员变量产生关系,操作就是对成员变量进行的。
     * this是在创建对象时产生的,代替当前对象
     */
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return this.name;
    }
    public void cry(){
        System.out.println("wuwu...");
    }

}

 

4、静态修饰符:

public class ObjectStatic {
    public static void main(String[] args){
        //为了不把所有main函数调用的方法和数据变成static的变通方法,即用对象调用。
        new ObjectStatic().show();
        /*下面打印main函数的参数,返回[Ljava.lang.String;@15db9742
         * 可以直到是一个字符串数组类型实体,并且检测长度为0,这是由用户输入参数的入口,在编译时可以传入,这里没有传入所以为0
         * 那为什么是字符串数组类型,因为字符串是使用最广泛的的类型,其他所有类型在传输时都是先转换为字符串然后在转为原来类型,
         */
    }
    public void show(){
        System.out.println("这个方法不是静态的,但是可以被静态的main函数内部调用,其实是对象调用的。");
    }
    
}
class Static{
    /*static修饰静态成员变量和方法,这些方法是属于类的,而非对象。并且先于对象而存在,可以由类/对象调用。
     * 静态成员的好处是在内存中只有一份,而多有对象都可以共享.
     */
    static int head=1;
    static String name;
    static void cry(){
        System.out.println("wuwuwu...");
    }
    /*静态代码块:像该类中,所有的成员都是静态的,所以不需要new对象来操作,可以直接用类来调用
     * 但是有一个问题,就是不能进行初始化,因为需要构造函数,此时可以使用静态代码块来进行初始化
     * 静态代码块是一个代码块,用static修饰,在类加载是加载并能直接运行(和构造函数相似,但不需要对象)
     * 下面只是简单实例,实际并不是如此简单的操作(没有太大意义),只是了解有这样的操作
     * ！！！注意:static代码块只在类加载时执行,而类只需加载一次以后直接使用,所以static代码块只执行一次
     */
    static {
        name="asd";
    }
}

小知识:

1、类加载流程:Java编译器会先将Java源代码编译为class文件然后执行,如果在一个类文件中引用另一个类,需要先在./classpath中寻找是否有对应的class文件,如果没有则检测是否有对应的源文件,有则编译并执行；还有就是引用系统类文件,使用import方法,会在jvm中进行编译。

2、Javadoc操作简介:Java提供Javadoc.exe程序来将一个类文档化。这需要使用/** */的注释格式,Java会将这种注释中的内容提取出来(只能是public权限的方法)。如果需要表现特殊内容,需要@开头(如@version)。需要注意:1是需要文档化的类必须为public或protected权限;2是所有方法的参数和返回值都需要进行解释。下附为javadoc的操作格式和命令(详叙见后)：