认识类和对象

认识类

类是用来对一个实体 ( 对象 ) 来进行描述的，主要描述该实体(对象)具有哪些属性(外观尺寸等)，哪些功能(用来干啥)

类中包含的内容称为 类的成员。属性主要是用来描述类的，称之为 类的成员属性或者 类成员变量。方法主要说明类具有哪些功能，称为 类的成员方法。

在 java 中定义类时需要用到 class 关键字。

语法：

class为定义类的关键字，ClassName为类的名字，{}中为类的主体。

    类名注意采用大驼峰定义

成员前写法统一为 public.

   此处写的方法不带 static 关键字.

public class Dog {  //定义类//类的成员属性public String name;//名字public int age;//年龄public String color;//颜色//类的成员方法//吃饭public void eat(){System.out.println("摇尾巴");}//叫声public void bark(){System.out.println("汪汪汪");}
}

1. 一般一个文件当中只定义 一个类

2. main方法所在的类一般要使用public修饰(注意：Eclipse默认会在public修饰的类中找main方法)

3. public修饰的类必须要和文件名相同

类的实例化

定义了一个类，就相当于在计算机中定义了一种新的类型，与int，double类似，只不过int和double是java语言自带的内置类型，而类是 用户自定义了一个新的类型，有了这些自定义的类型之后，就可以使用这些类来定义实例(或者称为对象)。

用类类型创建对象的过程，称为类的实例化，在java中采用 new关键字，配合类名来实例化对象。

语法：

objectName 是为新创建的对象指定的变量名

new 关键字用于创建一个对象的实例.

使用 “ .  ”来访问对象中的属性和方法.

对象名.类的成员名

同一个类可以创建多个实例

类和对象的说明

1. 类只是一个 模型一样的东西，用来对一个实体进行描述，限定了类有哪些成员.

2. 类是一种自定义的类型，可以用来定义变量.

3. 一个类可以实例化出多个对象， 实例化出的对象 占用实际的物理空间，存储类成员变量

类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图。

    public static void main(String[] args){//类的实例化2Dog dog=new Dog();dog.name="大黄";dog.age=3;dog.color="yellow";dog.eat();//类的实例化3Dog dog2=new Dog();dog2.name="黑虎";dog2.age=5;dog2.color="black";dog2.bark();}

this引用

当 形参名与成员变量名相同，根据 就近原则，出现错误

this 引用指向当前对象 ( 成员方法运行时调用该成员方法的对象 ) ，在成员方法中所有成员变量的操作，都是通过该 引用去访问。

1. this的类型：对应类类型引用，即哪个对象调用就是哪个对象的引用类型

2. this只能在"成员方法"中使用

3. 在"成员方法"中，this只能引用当前对象，不能再引用其他对象

4. this是“成员方法”第一个隐藏的参数，编译器会自动传递，在成员方法执行时，编译器会负责将调用成员方法对象的引用传递给该成员方法，this负责来接收。

对象的构造及初始化

构造方法

构造方法(也称为构造器)是一个特殊的成员方法

完成一个对象的构造，分两步：

1.分配内存

2.调用合适的构造方法

所以构造方法的作用就是对对象中的成员进行初始化，并不负责给对象开辟空间。

名字必须与类名相同

没有返回值类型，设置为void也不行

一般情况下使用public修饰

在创建对象时，由编译器自动调用，并且在整个对象的生命周期内只调用 一次

构造方法之间可以构成方法重载(用户根据自己的需求提供不同参数的构造方法)

名字相同，参数列表不同，因此构成了方法重载

public class Dog {  //定义类//类的成员属性public String name;//名字public int age;//年龄public String color;//颜色//无参构造方法public Dog(){// 1// 无参构造方法--内部给各个成员赋值初始值，该部分功能与三个参数的构造方法重复// 此处可以在无参构造方法中通过this调用带有三个参数的构造方法// 但是this("小灰",6,"yellow");必须是构造方法中第一条语句this("小灰",6,"yellow");// //2// this.name="小灰";// this.age=6;// this.color="yellow";}//带三个参数的构造方法public Dog(String name,int age,String color){this.name=name;this.age=age;this.color=color;}//打印public void Print(){System.out.println("name:"+this.name+" age:"+this.age+" color:"+this.color);}public static void main(String[] args){//此次创建一个Dog类型的对象，并没有显示调用构造方法Dog dog5=new Dog();//Dog()构造方法被调用dog5.Print();Dog dog6=new Dog("小白",9,"black");//Dog(String,int,String)构造方法被调用dog6.Print();}
}

this();调用当前类的其他构造方法，只能在当前的构造方法内部第一行使用

this.field 访问当前对象的属性

this.method() 调用当前对象的方法

this();调用不能形成环

    //errpublic Dog() {this("小灰",6,"yellow");}public Dog(String name,int age,String color){this();}//无参构造器调用三个参数的构造器，而三个参数构造器有调用无参的构造器，形成构造器的递归调用//编译报错：java: 递归构造器调用

默认初始化

在Java方法内部定义一个局部变量时，必须要初始化，否则会编译失败

 public static void main(String[] args){int a;System.out.println(a);
}//error java: 可能尚未初始化变量a

但我们发现成员变量未初始化仍然可以编译成功，这是为什么？

public static void main(String[] args){Dog dog4=new Dog();System.out.println("name:"+dog4.name+" age:"+dog4.age+" color:"+dog4.color);
}

当成员变量未初始化时：

     引用类型一般默认为null

     基本类型一般为自己的0值

一个类中无构造方法，java会自动提供一个不带参数的构造方法

只要有一个构造方法，java不提供任何构造方法

我们发现当我们删去无参构造方法时，因为有带三个参数构造方法的存在，编译器不提供任何构造方法，因此在main方法中调用Dog（）时出现错误

Classname objectname = new ClassName() ;

在程序层面只是简单的一条语句，在JVM层面需要做好多事情，如下：

1. 检测对象对应的类是否加载了，如果没有加载则加载

2. 为对象分配内存空间

3. 处理并发安全问题

比如：多个线程同时申请对象，JVM要保证给对象分配的空间不冲突

4. 初始化所分配的空间

即：对象空间被申请好之后，对象中包含的成员已经设置好了初始值

数据类型	默认值
byte	0
char	'\u0000'
short	0
int	0
long	0L
boolean	false
float	0.0f
double	0.0
reference	null

5. 设置对象头信息

6. 调用构造方法，给对象中各个成员赋值

就地初始化

在声明成员变量时，就直接给出了初始值。

代码编译完成后，编译器会将所有给成员初始化的这些语句添加到各个构造函数中

封装

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互

private

封装：对类的成员进行隐藏，通过关键字private，只是对类外提供公开的接口

意义：可以隐藏类的实现细节，从而达到安全性。

范围：只能在当前类中使用

如果成员被private封装，怎样在当前类外使用？

可以使用get方法（获取），set方法（修改），通过调用get方法和set方法，从而达到在类外使用被private封装的成员。

快速生成方法的快捷步骤：

        

public class Dog {private String name;//名字private int age;//年龄public String color;//颜色//获取name成员public String getName() {return name;}//修改name成员public void setName(String name) {this.name = name;}//获取age成员public int getAge() {return age;}//修改age成员public void setAge(int age) {this.age = age;}
}class test{public static void main(String[] args) {Dog dog=new Dog();dog.setName("大黄");//调用setName方法，修改name成员System.out.println(dog.getName());//调用getName方法，获取name成员dog.setAge(8);//调用setAge方法，修改age成员System.out.println(dog.getAge());//调用setAge方法，获取age成员}
}

访问限定符

主要限定：类或者类中成员能否在类外或者其他包中被访问。

Java中主要通过类和访问权限来实现封装：

1. 类可以将数据以及封装数据的方法结合在一起

2. 访问权限用来控制方法或者字段能否直接在类外使用

范围/访问限定符	private	default	protected	public
同一包中的同一类	是	是	是	是
同一包中的不同类		是	是	是
不同包中的子类			是	是
不同包中的非子类				是

public：可以理解为一个人的外貌特征，谁都可以看得到

default: 对于自己家族中(同一个包中)不是什么秘密，对于其他人来说就是隐私了

private：只能在当前类中使用

protected主要是用在继承中

default权限指：什么都不写时的默认权限

访问权限除了可以限定类中成员的可见性，也可以控制类的可见性

封装扩展之包

包的概念

为了更好的管理类，把 多个类收集在一起成为一组，称为软件包。

包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式

在同一个工程中允许存在 相同名称的类，只要处在不同的包中即可

常见包

1. java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。

2. java.lang.reflect:java 反射编程包;

3. java.net:进行网络编程开发包。

4. java.sql:进行数据库开发的支持包。

5. java.util:是java提供的工具程序包。(集合类等) 非常重要

6. java.io:I/O编程开发包。

导入包中的类

Java 中已经提供了很多现成的类供我们使用. 例如Date类

1. 使用 完整类名java.util.Date 导入 java.util 这个包中的 Date类

 2.  使用 import语句导入包.

3. 如果需要使用 java.util 中的其他类, 可以使用 import java.util.*

但util 和 sql 中都存在一个 Date 这样的类, 同时使用时就会出现歧义, 编译出错

这时我们可以使用 完整的类名解决引用不明确这个问题

使用 import static导入包中静态的方法和字段

import static java.lang.Math.*;//导入java.lang.Math中的所有类
public class Test {public static void main(String[] args) {double x=3;double y=4;double a=Math.sqrt(Math.pow(x,2)+Math.pow(y,2));  //a=5double b=sqrt(pow(x,2)+pow(y,2));//静态导入        //b=5System.out.println(a);System.out.println(b);
}

import 和 C++ 的 #include 差别很大. C++ 必须使用 #include 来引入其他文件内容, 但是 Java 不需要. import 只是为了写代码的时候更方便. import 更类似于 C++ 的 namespace 和 using

自定义包

基本规则

1. 在文件的最上方加上一个 package 语句指定该代码在哪个包中.

2. 包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式(例如 com.bit.demo1 ).

3. 包名要和代码路径相匹配. 例如创建 com.bit.demo1 的包, 那么会存在一个对应的路径 com/bit/demo1 来存储代码.

4. 如果一个类没有 package 语句, 则该类被放到一个默认包中.

操作步骤：

1. 在 IDEA 中先新建一个包: 右键 src -> 新建 -> 包

2. 在弹出的对话框中输入包名, 例如 com.bit.demo1

3. 在包中创建类, 右键包名 -> 新建 -> 类, 然后输入类名即可

包的访问权限控制举例

package com.bit.demo1;public class Dog {private String name;//名字private int age;//年龄public String color;//颜色String sex;//default属性public Dog(String name,int age,String color,String sex){this.name=name;this.age=age;this.color=color;this.sex=sex;}//吃饭private void eat(){System.out.println("摇尾巴");}//叫声public void bark(){System.out.println("汪汪汪");}//睡觉void sep(){System.out.println("睡觉");}public static void main(String[] args) {Dog dog=new Dog("大黄",3,"yellow","男");System.out.println(dog.name);System.out.println(dog.age);System.out.println(dog.color);System.out.println(dog.sex);dog.eat();dog.bark();dog.sep();}
}

package com.bit.demo1;public class TestDog {public static void main(String[] args) {Dog dog=new Dog("大黄",3,"yellow","男");System.out.println(dog.color);// System.out.println(dog.name);//err name是私有的，不允许被其他类访问System.out.println(dog.sex);// sex是default，允许被同一包中的不同类访问dog.bark();// dog.eat();//errdog.sep();}
}

package com.bit.demo2;
import com.bit.demo1.Dog;
public class TestDog {public static void main(String[] args) {Dog dog=new Dog("大黄",3,"yellow","男");System.out.println(dog.color);// System.out.println(dog.name);//err name是私有的，不允许被其他类访问// System.out.println(dog.sex);//err sex是default，不允许被其他包中的类访问dog.bark();// dog.eat();//err// dog.sep();//err}
}

             

static 成员

在Java中， 被 static 修饰的成员，称之为 静态成员，也可以称为 类成员，其不属于某个具体的对象，是所有对象所 共享的。

public class Dog {//非静态成员变量public String name;//名字public int age;//年龄public String color;//颜色//静态成员变量（类成员）private static String species;public Dog(String name, int age, String color) {this.name = name;this.age = age;this.color = color;}public void print(){System.out.println("name:"+this.name+" age:"+this.age+" color:"+this.color+" species:"+Dog.species);}public static void main(String[] args) {Dog.species="中华田园犬";Dog dog1 = new Dog("大黄",1,"yellow");dog1.print();Dog dog2 = new Dog("小灰",2,"black");dog2.print();Dog dog3= new Dog("小白",3,"brown");dog3.print();}
}

static只能修饰成员变量： 一般类中的数据成员都设置为 private，而成员方法设置为public

【静态成员变量（类变量）特性】

1. 不属于某个具体的对象，是 类变量，所有对象共享的，不存储在某个对象的空间中

2. 既可以通过 对象访问，也可以通过 类名访问，但一般更推荐使用类名访问

3. 类变量存储在 方法区当中

4. 生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)

【静态成员方法特性】  

1. 不属于某个具体的对象，是 类方法

2. 可以通过 对象调用，也可以通过 类名 .静态方法名(...)方式调用，更推荐使用后者

3. 不能 直接在 静态方法中访问任何 非静态成员变量或者调用 非静态成员方法。

（可以通过 对象在静态方法中访问 非静态成员变量或者调用 非静态成员方法）

非静态方法有this参数，在静态方法中调用时无法传递this引用，所以static方法中不能使用this

4.静态方法无法重写，不能用来实现多态

public class Dog {//非静态成员变量public String name;//名字public int age;//年龄public String color;//颜色//静态成员变量（类成员）private static String species;//非静态成员方法public void eat(){System.out.println("摇尾巴");}//静态成员方法（类成员）public static void  sleep(){System.out.println("睡觉");//age=10;//err 无法从静态上下文中引用非静态 变量 age//eat();//err 无法从静态上下文中引用非静态方法 eat()Dog dog=new Dog();System.out.println(dog.name="小花");dog.eat();}public static void main(String[] args) {//通过对象访问Dog dog0=new Dog();System.out.println(dog0.species="中华田园犬");dog0.sleep();//通过类名访问System.out.println(Dog.species="猎犬");Dog.sleep();}
}

代码块

代码块概念以及分类

使用 {} 定义的一段代码称为代码块。根据代码块定义的位置以及关键字，又可分为以下四种：

1. 普通代码块

普通代码块通常指的是由大括号 {} 包围的一段代码，它定义了一组可以一起执行的语句。这种代码块可以出现在方法体内部，也可以作为 if、 else、 for、 while、 do-while 等控制流语句的一部分。

2. 构造块

定义在类中的代码块(不加修饰符)。也叫： 实例代码块。 构造代码块一般用于初始化实例成员变量

实例代码块只有在 创建对象时才会执行

3. 静态块

使用static定义的代码块称为静态代码块。 一般用于初始化静态成员变量。

静态代码块不管生成多少个对象，其 只会执行一次

静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的

如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行(合并)

静态代码块只要类被加载，就会被执行

public class Dog {//非静态成员变量public String name;//名字public int age;//年龄public String color;//颜色//静态成员变量（类成员）private static String species;//构造代码块(实例代码块）{this.name="小黑";this.age=2;this.color="yellow";System.out.println("这是实例代码块");}//静态代码块static {species="牧羊犬";System.out.println("这是静态代码块");}static {species="运动犬";System.out.println("这是静态代码块2");}//构造方法public Dog() {this.name = name;this.age = age;this.color = color;System.out.println("这是构造方法");}public void print(){System.out.println("name:"+this.name+" age:"+this.age+" color:"+this.color+" species:"+Dog.species);}public static void main(String[] args) {Dog dog1 = new Dog();dog1.print();Dog dog2 = new Dog();dog2.print();
}

根据编译结果我们可以得到

运行时执行顺序为：静态代码块 实例代码块  构造方法

静态代码块只执行一次

public static void main(String[] args) {System.out.println(Dog.species);
}

当我们只加载类时，静态代码块就会被执行，而实例代码块只有在创建对象时才会执行

4. 同步代码块（后续讲解多线程部分再谈）