类、对象、方法
类是对象的抽象定义，对象是类的具体实例。
类：指的是一类东西，比如汽车，人类，书等这些都指的是一类东西或物品。
对象：指类的具体的实体，比如一辆汽车，一本书等，我们要记住一切皆对象（东西）。
同时对象具有状态（属性）和行为（方法）
我以人为例：
人属性有：脸，手，脚，鼻子，耳朵，身高，性别，鼻子，耳朵等属性
人的行为（方法）：吃，喝，跑，睡觉等。
这几个大家都能理解吧，而java中是如何创建类和对象的呢
先创建一个学生类（这些都是学生的属性和方法）
public class Student {
String name; //姓名
int age; //年龄
String classNo; //班级
String hobby； //爱好
public void chi(){
System.out.println(name+"吃饭了")
}
//输出信息方法
public void show(){
System.out.println(name + "\n年龄：" + age + "\n就读于：" +classNo + "\n爱好：" + hobby);
}
}这样就创建好一个类了,那如何创建一个对象呢。
首先举一个例子：小李设计了一张汽车设计图，然后交给生产车间来生产汽车，有黑色的、红色的、白色的... 这里，汽车设计图就是我们说的类（class），生产车间就是new构造器（大部分对象都是new出来的），生产出来的汽车就是我们要说的对象。可以说java编程实质就是构建类的过程。
public class InitialStudent {
public static void main(String args[]){
Student student = new Student(); //建立对象
student.name = "小明"; //给对象赋值
student.age = 10;
student.classNo = "S1班";
student.hobby = "篮球";
student.chi();
student.show(); //调用方法
}
}到现在我都是以自己的组织的语言给大家讲解，为的是让大家能够理解，那么java编程的规范有哪些，它的具体的细节又有哪些下面我就具体讲一下
类的定义
类必须先定义才能使用。类是创建对象的模板,创建对象也叫类的实例化。（类是对象的抽象定义，对象是类的具体实例）类实质上是一个数据类型。
例子：
public class Dog
{
String name;
int age;
void bark()//汪汪叫
{
System.out.println("汪汪，不要过来");
}
void hungry()
{
System.out.println("主人，我饿了");
}
}对示例的说明:
- public 是类的修饰符，表明该类是公共类，可以被其他类访问。
一个类保存到一个文件中，并且文件名要与类名相同。（一个文件中可以运行多个类声明，只能有一个类是public,文件名必须和该类类名一致）
class 是定义类的关键字。
Dog是类的名称。
- name,age是类的成员变量，也叫属性；bark(),hungry()是类中的函数，也叫方法。
对象实例化： 类名 对象名 = new 类名(); //未实例化的对象不能访问其属性和方法
访问属性：对象名.属性名
访问方法：对象名.方法名(参数列表)
作用域修饰词
1、public：public表明该数据成员、成员函数是对所有用户开放的，所有用户都可以直接进行调用
2、private：private表示私有，私有的意思就是除了class自己之外，任何人都不可以直接使用，私有财产神圣不可侵犯嘛，即便是子女，朋友，都不可以使用。
3、protected：protected对于子女、朋友来说，就是public的，可以*使用，没有任何限制，而对于其他的外部class，protected就变成private。
| 作用域 | 当前类 | 同一package | 子孙类 | 其他package |
|---|---|---|---|---|
| public | √ | √ | √ | √ |
| protected | √ | √ | √ | × |
| friendly(默认) | √ | √ | × | × |
| private | √ | × | × | × |
一个类可以包含以下类型变量:
局部变量:在方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
成员变量:成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化(分配内存)。成员变量可以被类中的方法和特定类的语句访问。
类变量:类变量也声明在类中，方法体之外，但必须声明为static类型。static也是修饰符的一种。
同时类也可以被final修饰，下面将会讲解finnal关键字和static关键字
| 比较 | 成员变量 | 局部变量 |
|---|---|---|
| 作用域 | 整个类中起作用（包括方法中） | 只在方法中起作用 |
| 初始值 | byte,short,int,long型是0 float,double型是0.0 char型是’\0’ boolean型是false |
没有初始值，无法使用 |
注：当局部变量与成员变量重名时，在方法中优先使用局部变量，方法中使用成员变量使用this，this代表当前类的当前对象。
static(静态)
类的静态成员不依赖类的某一实例，可使用类名直接访问
１.静态变量（类变量）
当类第一次被加载（任何一个对象的声明，首先要加载类），该类的静态变量就分配独立内存，直到程序结束被回收。静态成员是公共的。（局部变量不能用static修饰）
| 比较 | 静态变量 | 成员变量 |
|---|---|---|
| 作用域 | 当前类 | 当前类 |
| 生命周期 | 类加载到程序结束 | 从对象产生到对象回收 |
| 使用方法 | 类名.静态变量名 | 对象名.成员变量名 |
静态变量即类变量 成员变量即实例变量，对象实例化后才能使用
静态方法
- 访问静态方法：类名.方法名(参数列表)
静态方法在同一个类中被调用时，类名可以省略。普通成员方法必须在对象实例化后才可以调用
| 比较 | 静态方法 | 成员方法 |
|---|---|---|
| 调用 | 类名.方法名(参数) | 对象名.方法名(参数) |
| 调用普通方法 | 不能直接调用 | 同一个类中可以调用 |
| 调用静态方法 | 类名.方法名(参数) | 类名.方法名(参数) |
| 访问静态变量 | 类名.静态变量名 | 类名.静态变量名 |
| 访问成员变量 | 不能直接访问 | 同一类中可以直接访问 |
| this关键字 | 不能使用 | 可以使用 |
static代码块
static关键字还有一个比较关键的作用就是 用来形成静态代码块以优化程序性能。static块可以置于类中的任何地方，类中可以有多个static块。在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会在类加载的时候执行一次。
一般用来加载静态资源比如加载图片，视频，音频等。
final
Java关键字final有“这是无法改变的”或者“终态的”含义，它可以修饰非抽象类、非抽象类成员方法和变量。
1.修饰类
当用final修饰一个类时，表明这个类不能被继承。也就是说，如果一个类你永远不会让他被继承，就可以用final进行修饰。final类中的成员变量可以根据需要设为final，但是要注意final类中的所有成员方法都会被隐式地指定为final方法。
注：在使用final修饰类的时候，要注意谨慎选择，除非这个类真的在以后不会用来继承或者出于安全的考虑，尽量不要将类设计为final类。
修饰方法
使用final方法的原因有两个。
第一个原因是把方法锁定，以防任何继承类修改它的含义；
第二个原因是效率。在早期的Java实现版本中，会将final方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升。在最近的Java版本中，不需要使用final方法进行这些优化了。
注：类的private方法会隐式地被指定为final方法。
修饰变量
修饰变量是final用得最多的地方，也是重点阐述的内容
对于一个final变量，
如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；
如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。
- 类的final变量和普通变量有什么区别
- 当用final作用于类的成员变量时，成员变量（注意是类的成员变量，局部变量只需要保证在使用之前被初始化赋值即可）必须在定义时或者构造器中进行初始化赋值，而且final变量一旦被初始化赋值之后，就不能再被赋值了。
public class Test {
public static void main(String[] args) {
String a = "hello2";
final String b = "hello";
String d = "hello";
String c = b + 2;
String e = d + 2;
System.out.println((a == c));//true
System.out.println((a == e));//false
}
}分析
为什么第一个比较结果为true，而第二个比较结果为fasle。这里面就是final变量和普通变量的区别了，当final变量是基本数据类型以及String类型时，如果在编译期间能知道它的确切值，则编译器会把它当做编译期常量使用。也就是说在用到该final变量的地方，相当于直接访问的这个常量，不需要在运行时确定。这种和C语言中的宏替换有点像。因此在上面的一段代码中，由于变量b被final修饰，因此会被当做编译器常量，所以在使用到b的地方会直接将变量b 替换为它的 值。而对于变量d的访问却需要在运行时通过链接来进行。想必其中的区别大家应该明白了，不过要注意，只有在编译期间能确切知道final变量值的情况下，编译器才会进行这样的优化，比如下面的这段代码就不会进行优化：
public class Test {
public static void main(String[] args) {
String a = "hello2";
final String b = getHello();
String c = b + 2;
System.out.println((a == c));//这段代码的输出结果为false。
}
public static String getHello() {
return "hello";
}
}- 被final修饰的引用变量指向的对象内容可变吗
- 引用变量被final修饰之后，虽然不能再指向其他对象，但是它指向的对象的内容是可变的。
public class Test {
public static void main(String[] args) {
final MyClass myClass = new MyClass();
System.out.println(++myClass.i);//结果为1
}
}
class MyClass {
public int i = 0;
}- final参数的问题
- 无论参数是基本数据类型的变量还是引用类型的变量，使用final声明都不会防止你无意的修改而影响到调用方法外的变量
public class Test {
public static void main(String[] args) {
MyClass myClass = new MyClass();
StringBuffer buffer = new StringBuffer("hello");
myClass.changeValue(buffer);
System.out.println(buffer.toString());
}
}
class MyClass {
void changeValue(final StringBuffer buffer) {
buffer.append("world");
}
}
运行这段代码就会发现输出结果为 helloworld。很显然，用final进行修饰并没有阻止在changeValue中改变buffer指向的对象的内容。有人说假如把final去掉了，万一在changeValue中让buffer指向了其他对象怎么办。有这种想法的朋友可以自己动手写代码试一下这样的结果是什么，如果把final去掉了，然后在changeValue中让buffer指向了其他对象，也不会影响到main方法中的buffer，原因在于java采用的是值传递，对于引用变量，传递的是引用的值，也就是说让实参和形参同时指向了同一个对象，因此让形参重新指向另一个对象对实参并没有任何影响。
static final
static作用于成员变量用来表示只保存一份副本，而final的作用是用来保证变量不可变。
static final修饰的属性表示一旦给值，就不可修改，并且可以通过类名访问。
-
static final也可以修饰方法，表示该方法不能重写，可以在不new对象的情况下调用。
方法
- 为什么要有方法
- 提高代码的复用性
- 什么是方法
- 完成特定功能的代码块。
方法的格式
修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {
方法体语句;
return 返回值;
} -
方法的格式说明
- 修饰符：一般就用 public，static，final。
- 返回值类型：就是功能结果的数据类型。
- 方法名：符合命名规则即可。方便我们的调用。
- 参数：
- 实际参数：就是实际参与运算的。
- 形式参数；就是方法定义上的，用于接收实际参数的。
- 参数类型：就是参数的数据类型
- 参数名：就是变量名
- 方法体语句：就是完成功能的代码。
- return：结束方法的。
- 返回值：就是功能的结果，由return带给调用者。
构造方法（特殊的方法）
在类实例化的过程中自动执行的方法叫做构造方法，它不需要你手动调用。构造方法可以在类实例化的过程中做一些初始化的工作。
构造方法的名称必须与类的名称相同，并且没有返回值。
每个类都有构造方法。如果没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认的构造方法。
public class Dog
{
String name;
int age;
//构造方法，没有返回值
Dog(String name1,int age1)
{
name = name1;
age = age1;
System.out.println("感谢主人领养了我");
}
//普通方法,必须有返回值
void bark()
{
System.out.println("汪汪，不要过来");
}
void hungry()
{
System.out.println("主人，我饿了");
}
public static void main(String[] args)
{
//创建对象时传递的参数要与构造方法参数列表对应
Dog myDog = new Dog("花花",3);
}
}运行结果：
感谢主人领养了我
package day23;
/*构造方法
- 作用是用于初始化参数
- 所有的数字变量全部设置为0
- 所有的boolean类型全部设置为false
- 所有的对象变量全部设置为null
*/
/*
- 设计自己的构造方法
- 方法名称必须和类的名称相同
- 没有返回值
*/
/*
- 如果自己写了有参的构造方法，那么编译器不会再提供
- 默认的构造方法了
- 如果我们还想用无参的构造方法，
- 那么需要手动实现
*/
public class People
{
String name;
String sex;
int age;
//无参的构造方法(可以不写编译器自动加上，前提是没有任何其他构造方法)
People()//构造方法（可删掉,编译器默认加上)
{
// name = null;
// sex = null;
// age = 0;
}
//有参的构造方法
People(String name,String sex,int age)
{
this.name = name;
this.sex = sex;
this.age = age;
}
//部分初始化
People(String name)
{
this.name = name;
}
People(String name,int age)
{
this.name = name;
this.age = age;
}
public static void main(String[] args)
{
People p = new People();
System.out.println(p.name);
System.out.println(p.sex);
System.out.println(p.age);
People p1 = new People("张三","男",30);
System.out.println(p1.name+","+p1.sex+","+p1.age);
People p2 = new People("老王");
System.out.println(p2.name);
People p3 = new People("小老虎",3);
System.out.println(p3.name+","+p2.age);
}
}
说明:
构造方法不能被显式调用。
构造方法不能有返回值，因为没有变量来接收返回值
创建对象
对象是类的一个实例，创建对象的过程也叫类的实例化。对象是以类为模板来创建的。
在Java中，使用new关键字来创建对象，一般有以下三个步骤:
声明:声明一个对象，包括对象名称和对象类型
实例化:使用关键字new来创建一个对象。
初始化:使用new创建对象时，会调用构造方法初始化对象。
例如:
Dog myDog;//声明一个对象
myDog = new Dog("花花",3);//实例化也可以在声明的同时进行初始化:
Dog myDog = new Dog("花花",3);访问成员变量和方法
通过已创建的对象来访问成员变量和成员方法，例如:
//实例化
Dog myDog = new Dog("花花",3);
//通过点号访问成员变量
myDog.name;
//通过点号访问成员方法
myDog.bark();下面的例子演示了如何访问成员变量和方法:
public class Dog
{
String name;
int age;
Dog(String name1,int age1)
{
name = name1;
age = age1;
System.out.println("感谢主人领养了我");
}
void bark()
{
System.out.println("汪汪，不要过来");
}
void hungry()
{
System.out.println("主人，我饿了");
}
public static void main(String[] args)
{
Dog myDog = new Dog("花花",3);
//访问成员变量
String name = myDog.name;
int age = myDog.age;
System.out.println("我是一只小狗，我名字叫" + name + ",我" + age + "岁了");
//访问方法
myDog.bark();
myDog.hungry();
}
} 运行结果：
感谢主人领养了我
我是一只小狗，我名字叫花花，我3岁了
汪汪，不要过来
主人，我饿了