Java面向对象思想、类、封装、代码块

1、Java中的面向对象

• 面对对象程序设计（简称OOP）是当今主流的程序设计范型。
• 面对对象的程序是由对象组成的面向对象的程序是由对象组成的， 每个对象包含对用户公开的特定功能部分和隐藏的实现部分。程序中的很多对象来自标准库，还有一些是自定义的。在 OOP 中， 不必关心对象的具体实现，只要能够满足用户的需求即可。
• 对于一些规模较小的问题， 将其分解为过程的开发方式比较理想。而面向对象更加适用于解决规模较大的问题。

2、Java中的类与对象

• 类是构造对象的模板或蓝图。我们可以将类想象成制作小甜饼的切割机，将对象想象为小甜饼。由类构造对象的过程称为创建类的实例。
• 正如前面所看到的， 用 Java 编写的所有代码都位于某个类的内部: 标准的 Java 库提供了几千个类，可以用于用户界面设计、日期、 日历和网络程序设计。尽管如此，还是需要在Java 程序中创建一些自己的类， 以便描述应用程序所对应的问题域中的对象。
• 封装是与对象有关的一个重要概念。从形式上看，封装就是将数据和行为组合在一个包中， 并对对象的使用者隐藏了数据的实现方式。实现封装的关键在于绝对不能让类中的方法直接地访问其他类的实例域。程序仅通过对象的方法与对象数据进行交互。封装给对象赋予了“ 黑盒” 特征， 这是提高重用性和可靠性的关键。 这意味着一个类可以全面地改变存储数据的方式，只要仍旧使用同样的方法操作数据， 其他对象就不会知道或介意所发生的变化。OOP 的另一个原则会让用户自定义 Java 类变得轻而易举，在 Java 中， 所有的类都源自于一个“ 神通广大的超类” Object。
• 面向对象的特征：封装、继承、多态
• 类：是一组相关的属性和行为的集合
  对象：是该类事物的具体体现
  类包括：属性 ----- 成员变量、行为 ----- 成员方法
• 在一个java文件中写两个类：一个基本的类，一个测试类。接下来就是创建对象使用。格式：类名 对象名 = new 类名()，用对象名.变量名、对象名.方法名(…)就可以使用创建出来的对象了

//测试类
public class MyTest {
    public static void main(String[] args) {
        Animal a1=new Animal();//创建一个Animal对象
        Scanner sc=new Scanner(System.in);//创建一个用来接收用户输入的对象
        System.out.println("请输入该动物的名称：");
        String name=sc.next();
        System.out.println("请输入该动物的年龄：");
        int age=sc.nextInt();
        System.out.println("请输入该动物的种类：");
        String spices=sc.next();
        a1.Show(spices,name,age);
        Animal a2=new Animal();//创建一个Animal对象
        a2.Show("哺乳类","猫",8);
    }
}
//自定义类
public class Animal {
    public String name;
    public int age;
    public String spices;
    public void Show(String a,String b,int c){
        System.out.println("我属于"+a+",我的名字是"+b+",我的年龄是"+c);
    }
}

3、局部变量和成员变量的区别

局部变量是指定义在方法里面的变量，成员变量是指定义在类里面，方法外面的变量。
1、在类中的位置不同
成员变量：在类中方法外
局部变量：在方法定义中或者方法声明上
2、在内存中的位置不同
成员变量：在堆内存
局部变量：在栈内存
3、生命周期不同
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
4、初始化值不同
成员变量：有默认初始化值，可以不用自己初始化
局部变量：没有默认初始化值，必须定义，自己赋值，然后才能使用。

//测试类
public class MyTest {
    public static void main(String[] args) {
        Person p = new Person();
        p.age=18;
        p.Show("李四");
    }
}
class Person {
    //这三个变量都是成员变量，它们随对象的产生而产生，
    //成员变量可以不用赋初值，系统在创建对象时会默认给它们赋值，
    public String name="张三";
    public int age;
    public void Show(String a){
        int c=20;//这里的变量必须赋值才能使用，因为它是局部变量
        System.out.println("默认的年龄是："+age);
        System.out.println("我叫"+a+",我的年龄是"+c);
    }
}

4、传递参数

• 如果方法中的形参是类类型数据，应该怎么办？形参是引用类型时它的改变会直接影响实际参数，这时候你只需要将该类的一个对象传递过去就好。
• 什么是匿名对象：匿名对象就是使用关键字new创建出来的对象没有对象名，它适用于只调用该对象一次的时候，并且它可以当做实参传递。

5、private关键字

• 我们采用对象名.成员变量这种方式可以给成员变量设置值，但有时候类里面的成员变量需要有一些限制（如果用户输入年龄为230），如何屏蔽这种设置，我么可以使用关键字private，private是一个权限修饰符，可以修饰成员变量和成员方法，被修饰的成员只能在本类当中被访问。
• 权限修饰符：public>protected>缺省的(把这个类挪到另外一个包下，就访问不到了)>private
• 我们给外界提供公共的设置和获取的方法，可以去给成员变量设置值以及获取成员变量的值，成员变量一般为私有，构造器setXxx()和getXxx()一般为public。
  •一个 私有的数据域；
  •一 个公有的域访问器方法（setXxx()）；
  • 一个公有的域更改器方法（getXxx()）
• this关键字：当局部变量和成员变量名字相同的时候，如果我们不使用this关键字，局部变量会在自己的作用域内屏蔽了成员变量，this关键字代表当前类的对象引用。它就代表当前类的一个对象，谁调用这个方法,那么该方法的内部的this就代表谁。

6、构造方法

• 在构造对象时，构造方法会运行，以便将实例域初始化为所希望的状态。构造方法与其他的方法有一个重要的不同。构造器总是伴随着 new 操作符的执行被调用，每个类都有一个默认的无参的构造方法，但是如果你定义了其他有参的构造方法，这个无参的构造方法就不见了，如果你再次使用这个类创建对象就会发生错误，如果你需要这个无参的构造方法，你需要自己手动添加
  •构造方法与类同名
  •每个类可以有一个以上的构造方法
  •构造方法可以有 0 个、1 个或多个参数
  •构造方法没有返回值
  •构造方法总是伴随着 new 操作一起调用
  •如果我们没有给出构造方法，系统将自动提供一个无参构造方法。
  •如果我们给出了有参数构造方法，系统将不再提供默认的无参构造方法。
  •如果我们还想使用无参构造方法，就必须自己手动添加
• 给成员变量赋值的两种方式：
  setXxx()方法
  构造方法：在实例化对象的时候就可以将实例域初始化为所希望的状态

7、static关键字

在前面给出的示例程序中，main 方法都被标记为 static （静态的）修饰符。下面讨论一下这个修饰符的含义。

静态变量

如果将域定义为 static, 每个类中只有一个这样的域。而每一个对象对于所有的实例域却都有自己的一份拷贝。例如， 假定需要给每一个雇员賦予唯一的标识码。这里给 Employee类添加一个变量 id 和一个静态变量 nextld:
class Employee
{
private static int nextld = 1;
private int id; }
现在， 每一个雇员对象都有一个自己的 id 域， 但这个类的所有实例将共享一个 iiextld域。换句话说， 如果有 1000 个 Employee 类的对象， 则有 1000 个实例域 id。但是， 只有一个静态域 nextld。即使没有一个雇员对象， 静态域 nextld 也存在。它属于类，而不属于任何独立的对象。

• 静态变量和成员变量的区别：
  1、所属不同
  静态变量属于类，所以也称为类变量
  成员变量属于对象，所以也称为实例变量(对象变量)
  2、内存中位置不同
  静态变量存储于方法区的静态区
  成员变量存储于堆内存
  3、内存出现时间不同
  静态变量随着类的加载而加载，随着类的消失而消失
  成员变量随着对象的创建而存在，随着对象的消失而消失
  4、调用不同
  静态变量可以通过类名调用，也可以通过对象调用，推荐使用类名调用
  成员变量只能通过对象名调用

静态常量

静态变量使用得比较少，但静态常量却使用得比较多。例如， 在 Math 类中定义了一个
静态常量：
public class Hath
{
public static final double PI = 3.14159265358979323846; }
在程序中，可以采用 Math.PI 的形式获得这个常量。如果关键字 static 被省略， PI 就变成了 Math 类的一个实例域。需要通过 Math 类的对象
访问 PI，并且每一个 Math 对象都有它自己的一份 PI 拷贝。

静态方法

静态方法是一种不能向对象实施操作的方法。例如，Math类里面的pow()方法是一种不能向对象实施操作的方法。表达式：Math.pow(x, a)是计算x的a次幂。在运算时，不使用任何Math对象。

使用static关键字注意：

• 在静态方法中是没有this关键字的，静态是随着类的加载而加载，this是随着对象的创建而存在。前者早于后者出现，因此静态方法里面不能有关键字this的出现，静态比对象先存在。
• 静态方法只能访问静态的成员变量和静态的成员方法，非静态可以访问静态的也可以访问非静态的
• 成员变量本身属于对象，使用状态修饰符关键字static之后就使得成员变量/成员方法属于类，所有该类的对象都可以共享，只要有一个对象操作改变它，他就会发生改变
• 方法区在加载字节码文件的时候将区域分为共享区（被static修饰，如main()）和非共享区，共享变量任何对象都可以设置，它们一被设置就会覆盖缺省的值

手机类：
public class Phone {
        private String name;
        private String color;
        private double price;
        public static int num;
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public String getColor() {
            return color;
        }
        public void setColor(String color) {
            this.color = color;
        }
        public double getPrice() {
            return price;
        }
        public void setPrice(double price) {
            this.price = price;
        }
        public Phone(){}//如果类里面有构造方法的重载，你想创建这个类的对象需要手动添加那个缺省的构造方法
        public Phone(String name, String color, double price) {
            this.name = name;
            this.color = color;
            this.price = price;
        }
        public void sayHello(){
        	int num=0;
            System.out.println("我是Phone类");
            System.out.println(name);
            System.out.println(price);
            System.out.println(color);
            System.out.println(num);
        }
        public static void sayNum(){
        	System.out.println("看一下它们输出的值一样吗？");
        	System.out.println(Phone.num);
        	System.out.println(this.num);
        	System.out.println(num);
        }
}
测试类：
public class MyTest {
    public static void main(String[] args){
        Phone p1=new Phone();
        System.out.println("观察它们输出的值");
       	p1.sayNum();
        System.out.println("----------------------------");
       	Phone.sayNum();
        p1.setName("华为");
        p1.setPrice(784.2);
        p1.setColor("黑色");
        p1.sayHello();
        Phone p2=new Phone("vivo","白色",900);
        p2.sayHello();
    }
}

8、代码块

• 代码块就是被一对大括号括起来的范围，根据大括号的位置不同，将代码块分为：局部代码块、构造代码块、静态代码块、同步代码块（多线程）
• 局部代码块：定义在方法中的代码块，如果你希望及早的释放资源，你可以在方法内部定义变量
• 构造代码块：构造代码块定义在类里面，与构造方法平级，new创建对象的时候先调用构造代码块，再调用构造方法，前者优先于后者执行
• 静态代码块：用static修饰的代码
  static{
  ……
  }
  随着类的加载而加载，只执行一次，很常用，一般我们在静态代码块里面做一些业务逻辑，进行一些准备工作，只有JVM可以调用

class Student {
    static {
        System.out.println("Student 静态代码块");
    }
    public Student() {
        System.out.println("Student 构造方法");
    }
    {
        System.out.println("Student 构造代码块");
    }
}
public class MyTest {
    static {
        System.out.println("MyTest的静态代码块");
    }
    {
        System.out.println("MyTest的构造代码块");
    }
    public static void main(String[] args) {
        System.out.println("我是main方法");
        Student s1 = new Student();
        Student s2 = new Student();
    }
}/*输出结果为：
MyTest的静态代码块
我是main方法
Student 静态代码块
Student 构造代码块
Student 构造方法
Student 构造代码块
Student 构造方法
*/