Java 类与对象-CSDN博客

什么是 java 类

类，归类。类是一个模板，它描述一类对象的行为和状态。
比如：“人”类，“人”是一个“类”，“男人” 和“女人”就“人”这个类的对象；
“动物”类，“动物”是一个类，“狗”和“猫”就是“动物”这个类的对象。
人睡觉，动物卖萌就是对象的行为和状态。# 怎么去表示（声明）一个类
必须使用关键字 class 声明 java 类。
可使用一个或多个成员变量来定义类的属性。
可使用一个或多个方法来描述类的行为特征。

类中最常见的三种成员：

构造器、成员变量、方法

构造器：
定义构造器的语法格式：
- 修饰符：可默认省略，也可定义 public 、private、protected的其中之一；
- 构造器名：必须与类名一致
  
  成员变量
定义成员变量的语法格式：
- 修饰符：可默认省略，也可定义 public 、private、protected、static、final；其中public 、private、protected这三个只能出现一个，可以与static、final 组合起来修饰成员变量。
- 默认值；定义成员变量也可以指定一个默认值。
  
  方法：
定义方法的语法格式
- 修饰符：可默认省略，也可定义 public 、private、protected、static、final、abstract；其中public 、private、protected这三个只能出现一个，abstract、final 只能出现一个，可以和static组合使用。
- 返回值：可以返回任意数据类型，有具体返回值必须 return ;没有返回值则使用 void 声明没有返回值
- 形参：定义方法的参数类型
  
  修饰符
public ：访问权限最低；
protected:同包内可以访问；
private:私有属性不可直接访问；
abstract ：抽象，有抽象方法必定是抽象类，但抽象类可以包含普通方法；抽象类和抽象方法都不可以被实例化；
final ：被final修饰的类或者变量不能被继承或者修改；
static：static修饰的变量和方法成为类（静态）变量和类（静态）方法。被static修饰的成员属于类本身而不是类的实例，即在类加载的时候static修饰的成员就加载了，不需要等实例化对象后在生效。

类中可以包含的变量
成员变量：
成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。
成员变量可以被类中方法、构造方法和特定类的语句块访问。
类变量（静态变量）：
类变量也声明在类中，方法体之外，但必须声明为static类型。
局部变量：
在方法、构造方法或者语句块中定义的变量被称为局部变量。
变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。

类中各成员之间的关系
类中各成员之间的定义顺序没有任何影响，成员之间可以相互调用。
被static 修饰的成员不能访问非static 修饰的成员（静态得不可访问非静态的）。

对象的创建与引用之间的关系
每当实例化一个对象（ Employee emp = new Employee() ）代码就产生了： emp 与 Employee 对象（new Employee）这两个东西。
new 的对象存在“堆内存”中，其中包含了该对象的成员变量和方法。
把对象赋值给变量即 emp 时，是指在"栈内存" 中创建了一个引用变量emp 指向了 “堆内存”中的对象 Employee，而不是直接把Employee直接复制一份给emp，切记是引用变量指向了对象。
当没有任何引用指向堆内存中对象时，此对象就是所谓的垃圾了，需要被Java回收的。

对象的this引用
作用一：在方法中引用调用该方法的对象，即在this可在使类的一个方法中，访问类的另一个方法或实例变量。
作用二：构造器中引用该构造器正在初始化的对象

代码练习
修饰符的使用

package com.ivo.bean;

/**
 * @author Mytripod
 * @create 2018-12-05 21:56
 */
public class Employee {

    static String staticProperty="苏州";

    static  final String staticFinalProperty="Mytripod.com";

    public  static  String publicStaticProperty="未成年";

    private static final String  privateStaticFinalProperty="10000000";

    public int publicProperty =17;

    protected  String protectedProperty="崇仙";

    private String privateProperty ="男";

    public void publicFoo(){
        System.out.println("public Foo");
    }

    protected void protectedFoo(){
        System.out.println("protected Foo");
    }

    public static void publicStaticFoo2(){
        System.out.println("public Static Foo2");
    }

    protected  static  final int publicStaticFinalFoo3(){
        int i =1;
        System.out.println("public Static Final Foo3");
        return i;
    }

    private   int privateStaticFinalFoo4(){
        int i =4;
        System.out.println("private Static Final Foo4");
        return i;
    }

    public Employee(){
        System.out.println("public 默认构造");
    }

    public Employee(int publicProperty){
        System.out.println("public 构造器"+protectedProperty);
    }

    private Employee(String protectedProperty){
        System.out.println("private 构造器"+protectedProperty);
    }


    // public abstract int (){} 定义抽象方法,则 class 必须使用 abstract 修饰


    @Override
    public String toString() {
        return "Employee{" +
                "publicProperty=" + publicProperty +
                ", protectedProperty='" + protectedProperty + '\'' +
                ", privateProperty='" + privateProperty + '\'' +
                '}';
    }


    public static void main(String[] args) {

        //类名直接访问 静态属性
        System.out.println(Employee.publicStaticProperty);

        Employee emp = new Employee();

        //同类中下,可访问所有的成员 public,protected,private,static final
        emp.publicFoo();
        emp.protectedFoo();
        emp.privateStaticFinalFoo4();
        emp.publicProperty=18;
        emp.protectedProperty="崇仙2";
        emp.privateProperty="男2";

        staticProperty="我是静态数据";
        publicStaticProperty="我是public静态属性";
        //privateStaticFinalProperty="我是静态的最终属性";  //发现final修饰的属性 不允许修改;
        //privateStaticFinalProperty="private 静态的最终属性";
        System.out.println("静态最终属性"+staticFinalProperty);
        System.out.println("静态属性"+staticProperty);
        System.out.println("public 静态属性"+publicStaticProperty);
        System.out.println(emp);

    }
}

package com.ivo.bean;

/**
 * @author Mytripod
 * @create 2018-12-07 22:12
 */
public class Main {
    public static void main(String[] args) {
        Employee emp = new Employee();

        //同一包内下,可访问所有的成员 public,protected
        emp.publicFoo();
        emp.protectedFoo();
        // emp.privateStaticFinalFoo4();
        emp.publicProperty = 18;
        emp.protectedProperty = "崇仙2";
        //  emp.privateProperty="男2";

        // staticProperty="我是静态数据";
        // publicStaticProperty="我是public静态属性";
        //privateStaticFinalProperty="我是静态的最终属性";  //发现final修饰的属性 不允许修改;
        //privateStaticFinalProperty="private 静态的最终属性";
        //System.out.println("静态最终属性"+staticFinalProperty);
        //System.out.println("静态属性"+staticProperty);
        //System.out.println("public 静态属性"+publicStaticProperty);
        System.out.println(emp);

    }
}

import com.ivo.bean.Employee;

public class Main {

    // 与employee 非同一包下
    public static void main(String[] args) {

        Employee emp = new Employee();

        //非同一包下,只能访问类实例(对象)的public 属性 和public 方法
        emp.publicProperty=1;

        emp.publicFoo();

        System.out.println(emp);

    }
}

对象的 this关键

package com.ivo.bean;

/**
 * @author Mytripod
 * @create 2018-12-07 23:23
 */
public class Person {
    private String name="张三";

    public void run(){
        System.out.println("run....");
    }

    public void eat(){
        //在方法中引用调用该方法的对象
        this.run();
        System.out.println("eat....");
    }

    public  Person(){
        //构造器中引用该构造器正在初始化的对象

        this.name="李四";
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }

    public static void main(String[] args) {

        //this.eat();
        //这样写是错误的,因为此处的方法为 main()方法,mian()方法不属于类实例,而是类本身,所以不可使用this 指代对象.

        //若非要在静态方法中访问普通方法,则需创建类实例,通过对象来访问
       // new Person().eat();

        Person  person= new Person();
        person.eat();
        System.out.println(person);

    }
}

转载于:https://www.cnblogs.com/mytripod/p/10085646.html