面向对象基本概念(面向对象是什么)

面向对象是一种符合人们思维的编程方式。在程序中使用对象来映射现实中的事物，使用对象的关系来描述事物之间的联系，这种思想就是面向对象。面向对象的特性分为三种，如封装，继承，多态。
封装就是将一个对象的属性和方法放进盒子里，不让外界知道具体细节，也就是说不允许外部类随意进行访问。
继承就是类与类之间的一种关系，通过继承，可以在无需编写原有类的基础上，在现有类的基础上对原有类的功能进行扩展，提高了代码的复用性，并提高了开发的效率。
多态是在继承的基础上，不同的对象对同一个方法调用，产生不同结果的这么一个事情。
这三个特性这么一小行文字也不会让我对面向对象有什么很深的理解，还是要在使用的时候多去理解，多去体会。

定义在类中的变量被叫做成员变量，定义在方法中的变量叫做局部变量，一个类中成员变量和局部变量可以是相同的，通过方法名只能访问到局部变量而不是成员变量。

package com.xiao;
class P {
    int age = 10;//成员变量

    void speak() {
        int age = 30;//局部变量
        System.out.println("我今年" + age + "岁了");
    }
}
public class Person_one {
    public static void main(String[] args) {
        P p=new P();
        p.speak();
    }
}

Person p = new Person();
这样就创建了一个p对象，Person p是声明了一个Person类型的变量p，
new Person（）用于创建一个Person类的实例对象，中间的等号是Person对象在内存中的地址赋值给变量p，Person p是放在栈内存里，new Person（）是存放在堆内存里。
内存分为两种，一种是栈内存，一种是堆内存，栈内存用于存放一些引用变量，如Person p，堆内存用于存放由new创建的对象和数组。

由小到大
private（当前类），default（包），protect（子类），public（公共）

不封装会产生什么影响

package com.xiao;
class Person_zeo{
    String name;
    int age;
    public void speak(){
        System.out.println("我叫"+name+",今年"+age+"岁了");
    }

}
public class Example03 {
    public static void main(String[] args) {
        Person_zeo p = new Person_zeo();
        p.name="张三";
        p.age=-18;
        p.speak();
    }
}

可以得出年龄为-18岁，语法上不会报错但是实际中这是不合理的，这就需要类的封装了

package com.xiao;

class Person2 {
    private String name;
    private int age;
    public String getName(){
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age<=0){
            System.out.println("你的输入不合理");
        }else{
            this.age = age;
        }
    }
    public void speak(){
        System.out.println("我叫"+name+",今年"+age+"岁了");
    }
}
public class Example04{
    public static void main(String[] args) {
        Person2 p2 = new Person2();
        p2.setName("张三");
        p2.setAge(-18);
        p2.speak();

    }
}

当年龄小于0时，会输出打印你的输入的年龄不正确，由于此时age未被赋值，所以还是为初始默认值0；

普通方法是为了和构造方法区别开来，本质就是方法。
6.1重载

package com.xiao;

public class Example05 {
    public static int add01(int x,int y) {
        return x+y;
    }
    public static int add02(int x,int y,int z) {
        return x+y+z;
    }
    public static double add03(double x, double y) {
        return x+y;
    }

    public static void main(String[] args) {
        int sum=add01(1,2);
        int sum2=add02(3,4,7);
        double sum3=add03(0.2,5.3);
        System.out.println(sum);
        System.out.println(sum2);
        System.out.println(sum3);

    }
}

从代码可以看出来，针对求和每一种方法都定义一种方法，如果名称不相同就很难知道要调用哪一种方法，emmmm，就是说你得先去一堆参数中确定参数的类型与个数，三个类还是可以很明显找到要用的那个方法，但是如果有三百个类呢？这个时候重载的作用就体现出来了，重载需要满足两个条件，1，方法名相同，2，参数的个数或类型不同。

package com.xiao;

public class Example06 {

    public static int add(int x, int y) {
        return x + y;
    }

    public static int add(int x, int y, int z) {
        return x + y + z;
    }

    public static double add(double x, double y) {
        return x + y;
    }

    public static void main(String[] args) {
        int sum = add(1, 2);
        int sum2 = add(3, 4, 7);
        double sum3 = add(0.2,5.3);
        System.out.println(sum);
        System.out.println(sum2);
        System.out.println(sum3);

    }
}

6.2递归
递归就是指自己调用自己的过程。递归需要有结束条件不然就无法结束调用。

package com.xiao;

public class Example07 {
    public static int getSum(int n) {
        if(n==1){
            return 1;
        }
        int temp=getSum(n-1);
        return temp+n;
    }

    public static void main(String[] args) {
        int sum=getSum(4);
        System.out.println("sum="+sum);
    }
}

这个过程多去debug下就知道怎么调用的了。

构造方法又叫构造器，他会在类实例化对象的时候被自动调用。
构造方法需要满足三个条件
1·方法名与类名相同
2·在方法名前面没有返回值类型的声明。
3·在方法中不能使用return语句返回一个值，但是可以单独写return语句作为方法的实现。

package com.xiao;
class Person10{
    public Person10(){
        System.out.println("调用了无参的构造方法");
    }
}
public class Example08 {
    public static void main(String[] args) {
        Person10 p10 = new Person10();
    }
}

7·1构造方法的重载
在一个类中定义多个构造方法，只需要每个构造方法的参数类型或参数个数不同即可。

package com.xiao;
class Person2{
    String name;
    int age;
    public Person2(int a){
        age=a;
    }
    public Person2(String n,int a){
        String name = n;
        age=a;
    }
    public void speak(){
        System.out.println("我今年"+age+"岁了");
    }
    public void say(){
        System.out.println("我叫"+name+"我今年"+age+"岁了");
    }
}
public class Example10 {
    public static void main(String[] args) {
        Person2 p1=new Person2(18);
        Person2 p2=new Person2(32);
        p1.speak();
        p2.say();
    }
}

java中每一个类都有至少一个构造方法—会默认有一个无参构造。但是如果自己在类中定义了一个构造方法，那么系统将不再提供默认的无参构造，就会出现报错。

通过this关键字调用成员变量，解决与局部变量名称冲突问题。

package com.xiao;



class Person3{
    public Person3(){
        System.out.println("无参构造的方法被调用了");
    }
    public Person3(int age){
        this();
        System.out.println("有参构造方法被调用了");
    }
}
public class Example11 {
    public static void main(String[] args) {
        Person3 p = new Person3(18);
    }

}

输出结果
无参构造的方法被调用了
有参构造方法被调用了
注意点：
1·只能在构造方法中使用this关键字
2·使用this的语句是该方法的第一条执行语句，且只能出现一次。
3·不能在一个类中的两个构造方法使用this互相调用。

package com.xiao;
class Student{
    static String schoolName;
}
public class Example12 {
    public static void main(String[] args) {
        Student s1 = new Student();
        Student s2 =new Student();
        Student.schoolName="清华大学";
        System.out.println("我是"+s1.schoolName+"的学生");
        System.out.println("我是"+s2.schoolName+"的学生");
    }
}

注意点：static只能用于修饰成员变量，不能用于修饰局部变量。
静态方法可以在不创建对象的情况下调用某个方法

package com.xiao;
class Person{
    public static void say(){
        System.out.println("Hello!");
    }
}
public class Example13 {
    public static void main(String[] args) {
        Person.say();
        Person p1 = new Person();
        p1.say();
    }
}

输出结果
Hello!
Hello!
静态代码块
当类被加载时静态代码块会执行，由于类只执行一次，静态代码块也只执行一次。

package com.xiao;
class Person4{
    static {
        System.out.println("执行了Person4中的代码块");
    }
}
public class Example14 {
    static {
        System.out.println("执行了测试类中的静态代码块");
    }

    public static void main(String[] args) {
        Person4 p1 = new Person4();
        Person4 p2 = new Person4();
    }
}

jvm首先会加载类Example14，在加载类的同时就会执行该类的静态代码块，紧接着会调用main（）方法，main（）方法中创建了两个Person对象，但在两次实例化的过程中，静态代码块中的内容只输出了一次，这就说明静态代码块在类的第一次使用时才会被加载，并且只会加载一次。