Java杂学

1.无参与有参构造

构造器在新建类会默认一个无参构造
例如

public class Student{
}

那么里面就会藏着一个

public class Student{
public Student(){            //不能用void 而且和构造名必须和类名一致
}
}

有参构造

public class Pet{
String name;                       //定义name类型
public Pet(String name){
this.name=name;                    //this.name指pet类下的name参数;
}
}

2.类的实例化

Pet cat =new Pet();
代表把Pet类实例成一个cat并把Pet里面的参数传给cat
比如cat.name就是调用Pet里面的name属性

类：
静态的属性：属性
动态的行为：方法

例如：创建一个B.java和Application.java（同个包内）

package com.test;

public class B {
    public void test(){
        System.out.println("hello,b");
    }
}

package com.test;

public class Application {
    public static void main(String[] args) {//主方法
        B bb=new B();
        bb.test();//这样就可以调用B类的test方法

    }
}

3.new对象

1.new girfriend();
2.Pet cat =new Pet();
这个就是创造了Pet类的实体对象。

4.代码

一个分类：
public class Student{

String name;
int age;
char sex;

}

主函数：
public class test{                        //主类
public staitc void main(String[] args){   //主函数
Student xiaoming =new Student();          //实例化
xiaoming.name="liziming";                 //赋值给主函数
}
}

这样就完成了一个对象和累的实例化的创建

5.属性私有，get，set

private转public几种方法

1.set方法

private String name;

public void setName(String name){
this.name=name;
}
//调用setName方法即可在另一个类获得或者赋值数据

2.get方法

private String name;

public String getName(){
return this.name;
}
//调用getName即可

有什么用？
1.对程序进行检查，比如name是传值的
在接受另一个类传值后可以在getName或者setName中进行一些参数过滤。
2.隐藏代码实现细节
可以有效防止源码泄露等不安全的因素。
3.统一接口
4.提高系统的可维护性，其实这就封装的过程。

6.方法重载

public String name(String num){
}
public String name(String num,int age){
}
//上面两个方法的类型不同，当程序满足不同条件会调用不同的方法，这就是方法的重载。

7.继承：

是一种类跟类之间的关系，用extends表示（可以翻译成is a）（final类无子类）
java只有单继承没有多继承（一个类只能有一个父类，但可以有多个子类）
子类可以继承父类的所有方法！(定义的值也可继承)，但是private无法继承。
所有的类都默认继承Object类，所以Object就是老祖宗，extends就是做了一个违背老祖宗的决定(hhhhhh)
这就意味着父类有的都可以在子类中取到。

student extends Person
//可以理解成student is a Person
//所以子类中的方法一定是比父类中方法要多或者相等。

代表student是Person的子类，或者叫做派生类

    //方法继承注意点
    //加上静态变量后，new对象得值跟左边有关，因为左边一定是父类或者自己所以无需担忧输出
    //不加static变量，new对象的值跟右边有关(调用方法时父类也要有这个方法，这就是方法重写)，如果子类没有该名字的方法（也就是子类没有重写父类方法）则输出父类的同名方法
    B bb=new A();//非static时，输出的是A的方法，加static时，输出的是B的方法
    //当左边和右边不一样时，一定是左边是右边的父类或者是父类的父类
    //也可通俗解释为父类的引用指向子类的类型

8.方法重写

B bb=new A();//这就是方法重写
1.只能非static（static方法属于类不属于实例，不能被重写）非final（final属于常量），且不能为private
所以子类有父类的方法就叫方法重写
这和上面的继承不加static变量有着密切的联系
A.java

package com.test;

public  class A extends B{
}

B.java，是A.java的父类

package com.test;

public class B {
    public  void test(){
        System.out.println("hello,b");
    }

}

如果此时写

        A aa=new A();
        aa.test();
        System.out.println("---------------");
        B bb=new A();
        bb.test();

那么都会输出hello,b,因为A中为test方法，但是A继承了B所以有B的test方法，所以调用后会显示hello,b
如果A有test方法且继承B，那么就代表A重写了B的test方法，此时调用就都会显示hello,a

9.static变量

public class Application {

    public static int age;//静态属性
    public double num;

    public static void main(String[] args) {
        Application application=new Application();
        System.out.println(application.age);
        System.out.println(application.num);
        System.out.println(Application.age);
        System.out.println(Application.num);
    }
}
//前三句正确，最后一句错误

static变量就可以看做一个类，跟类一块加载，主方法调用类当然可以，但是age只是Application类的一个变量，所以无法调用
static常用于多线程，能被多次调用

同理，类里面有多个方法，如果是static方法即可直接调用，而非静态方法需要new后调用

public class Application {
    
    public static void run(){
    }
    public void stop(){
    }

    public static void main(String[] args) {
        run();
        stop();//这个方法不能直接调用
        new Application().stop();//需要new出来才能调用
    }
}

静态方法只执行一次，后面就不再执行，所以可以用来赋初始值

public class Application {

    {
        System.out.println("匿名模块");
    }
    static{
        System.out.println("静态模块");
    }
    public  Application(){
        System.out.println("方法模块");

    }

    public static void main(String[] args) {

        Application a=new Application();
        System.out.println("-------");
        Application B=new Application();
    }
}

输出结果:

静态模块
匿名模块
方法模块
-------
匿名模块
方法模块