Java基础之类和对象

一、什么是类和对象

对象：真正存在的一个实体，拥有自己的属性。就像我和彭于晏都是实体的，都是对象。

类：是一个抽象的概念，是一类具有相同特征的对象的统称。类中定义了该类对象所共同具备的属性和方法，无法具体到某个具体实例。

举例

就像我和彭于晏都是人类，而归为人类的原因是我们有共同的属性和行为，比如人的五官，四肢，头脑，需要吃饭，学习，工作等，帅也是共同点，但是属性值不一样，彭于晏帅亿点（手动狗头）。

二、创建类和类的实例化

基本语法

class <class_name>{ 
  field;//成员属性
  method;//成员方法
}
// 实例化对象
<class_name> <对象名> = new <class_name>();

例子，调用成员方法和属性。

 public static void main(String[] args) {
        Dog dog = new Dog();
        String name = "小黑";
        int age = 1;
        dog.eat();
        System.out.println("名字：" + name);
        System.out.println("年龄：" + age);
    }

    static class Dog {
        public String name;
        public int age;

        public void eat() {
            System.out.println("吃狗粮");
        }

    }

运行结果

 三，类的命名方法

类的命名使用有意义的大驼峰单词命名法
从第一个单词开始首字母就大写，多个单词都是首字母大写

例如

class Person
class ChinaPerson

四、Java的面向对象

java中流传着一句话，一切皆对象，这也是Java和C语言的区别所在。

C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。

JAVA是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。而面向过程注重的是过程，在整个过程中所涉及的行为，就是功能。

面向对象设计把握一个重要的经验:谁拥有数据，谁对外提供操作这些数据（私有）的方法!

例子，

我亲女朋友，C语言中不关心对象的属性，行为，对它而已都是方法的调用，关心的是行为本身，谁亲谁不重要，亲这个行为很重要。

                   Java中认为，行为都是对象发出的，对象->行为->对象，行为和属性都是归于对象，行为发生的本身就是一个对象作用于另一个对象。

对象的属性和方法

类名称引用名称= new类名称();

Person per=new Person();

当产生一个类的对象之后，我们就可以使用"."操作符来使用该对象的属性和方法

例子

public class Test {
    public static void main(String[] args) {
      Person per1 = new Person();
      per1.name = "小明";//per1为对象的引用，给对象起了名
        per1.age = 18;
      per1.sex = "男";

    }
}
class Person{
    //成员变量，实例变量-每个Person的对象都有，在堆中的每个对象中存储
    String name;
    int age;
    String sex;
}

关于引用数据类型的特殊值null
null在Java中表示"空引用”，表示只有名字没有保存任何堆内存中的地址，如果直接使用值为null的引用去操作"."任何属性或方法(成员变量和成员方法)都会报错。

例子

public class Test {
    public static void main(String[] args) {
        Person per1 = new Person();
        Person per2 = new Person();
        per1.name = "小明";//per1为对象的引用，给对象起了名
        per1.age = 18;
        per1.sex = "男";
        per1.print();
        per2.print();//没有给对象赋初值直接打印默认null
        System.out.println(per2.name.length());/打印name的长度
    }
}
class Person{
    //成员变量，实例变量-每个Person的对象都有，在堆中的每个对象中存储
    String name;
    int age;
    String sex;

    public void print() {
        System.out.println("姓名为:" + name + ",年龄为:" + age + ",性别为:"  + sex);
    }
}

static关键字

理解：和对象无关，表示公有的，共同的属性和方法

分为四个方面

1.1修饰属性，类属性，类变量

1.2修饰方法，类方法，工具方法

1.3 static修饰的代码块，静态代码块

1.4 static修饰的内部类，静态内部类

 1.1static修饰的属性，类属性，类变量

static修饰的属性在JVM方法区中存储，称为类属性，类变量，所有对象共享。

当一个实例变量被static关键字修饰，他就表示类的属性，该类的所有对象共享这个属性，所有对象的属性值大家都一样。

static修饰的属性，直接通过类名称就可以方法，无需通过对象访问。

在Java中，不能在一个方法的内部定义一个static变量，因为方法中定义的变量全是局部变量，局部变量都在栈中存储，不可能定义了个既在栈中又在方法区中的属性。

  ps：方法区中存储类中的所有方法和常量，静态变量。

例子

public class Test {
    public static void main(String[] args) {
        Person per1 = new Person();
        Person per2 = new Person();
        per1.age = 16;
        per1.sex = "男";
        per2.age = 17;//因为17是静态变量，per2最终修改值为17，一个类共享，所以per1也是17
        per2.sex = "女";
        per1.print();
        per2.print();
    }
}
class Person{
  final String name = "小明";//常量，所以类中对象都是一样的，且不可更改
    static int age = 18;
    String sex ;
   static String country = "中国";//静态变量，不做修改的话，直接调用，所有类中对象默认相同属性
    Person() {
    }

    public void print() {
        System.out.println("姓名为:" + name + ",年龄为:" + age + ",性别为:"  + sex +",国籍为："+ country);
    }
}

final和static的区别

class Person{
  final String name = "小明";//final修饰的是成员常量，都在堆中存储
    static int age = 18;//静态变量，在方法区中存储，所有Person的对象共享这个country属性。
    String sex = "男";

类中定义常量
我们通常情况下都会把static和final共同使用称为类的常量

命名规则：所有单词全部大写，多个单词使用下划线分隔

static final String STUDENT_SCHOOL ="清华大学"

总结:
a.static变量称为类属性，在方法区中存储，该类的所有对象共享此变量
b.若在类中定义了常量(定义时赋值)，一般我们使用static和final共同修饰，全局常量
c.要使用类属性，我们通常直接通过类名称.属性名称不推荐使用对象来调用类属性，不规范。d.static属性称为类属性，通过类名称直接访问此时没有对象也能调用(包含该类的null引用)

1.2 static修饰方法-类方法，工具方法，静态方法

static修饰的方法也是通过类名称直接访问，无需对象就能访问。

就像程序从主方法开始执行，主方法要能调用起来，就必须是静态方法，直接调用，无需产生对象，如果主方法是个成员方法，就需要通过对象调用，那程序还没执行是无法产生对象的。

静态方法和成员方法的区别

静态方法能否访问成员变量和成员方法成员方法能否访问静态变量和静态方法?

a.在静态方法中只能调用静态方法或者静态属性，static家族之间可以相互调用。不能直接调用成员方法和成员属性，必须通过对象来调用。（静态方法没有对象）
b.在成员方法中既可以调用成员方法，也可调用静态方法(此时都已经产生了该类对象，一定是可以访问静态域).

面向对象—共有三大特性:封装，继承和多态（这里只讨论封装）
封装:保护性和易用性。

在Java中，所谓的权限修饰符，指的是你修饰的属性，方法，类，到底可见的范围有多大，共有四大访问修饰符，可见的范围有小到大依次为：
private< default(不要写这个关键字，什么权限也没有就是default)-包访问权限<protected<public

例子

public class Test {
    public static void main(String[] args) {
        Bank bank = new bank();
        bank.cardNum = 3456;//cardNum外部不可见
    }
    
}
class Bank{
    private int cardNum;//只可取
    private String password;//可取可改
    private double value;//可取
}

就想在类的外部去使用这些私有属性，需要使用类提供的getter(取值)和setter(修改值)

阿里编码规范:
Java类中所有的成员变量一律使用private封装，并且根据属性的实际情况对外提供getter和setter方法。