笔记之java基础-07

1、匿名对象：

匿名对象：
       就是没有名字的对象
优点：
没有东西指向它，用完就是垃圾。
应用场景：
A:当对方法仅调用一次时，使用匿名对象比较简单
  若是多次，比较麻烦
B:匿名对象可以作为实际参数进行传递。
/*
匿名对象：
       就是没有名字的对象
优点：
没有东西指向它，用完就是垃圾。


应用场景：
A:当对方法仅调用一次时，使用匿名对象比较简单
  若是多次，比较麻烦
B:匿名对象可以作为实际参数进行传递。

*/
class Student
{
public void show ()
{
System.out.println("show");
}
}
class Test
{
public void show2(Student s){
       s.show();
}
}
 
class NiMingTest 
{
public static void main(String[] args) 
{
Student s = new Student();
s.show();
//匿名对象的使用
new Student().show();
         //匿名对象可以作为实际参数进行传递。
     Test t = new Test();
//Student s2 = new Student();
//t.show2(s2);
t.show2(new Student());

}

}

2、封装：

    是指隐藏对象的属性和实现细节，仅对外提供公共的访问方式。

    为什么要封装：s.age = -26;数据的赋值是可以的，但是这样不符合常理，这样的数据是不真实的。为了保证数据的真实性，必须对数据进行校验。

要想校验必须有逻辑数据。要想有逻辑数据，必须定义方法。但是，即使写了方法，也可以通过 对象名.成员变量直接使用。没有解决根本问题。

解决根本问题就是让外界不能直接通过对象名.成员变量 访问数据。

java提供了一个修饰符private.

private：是一个关键字，是一个访问权限修饰符，表示私有的意义，可用于修饰成员变量和成员方法。

被它修饰完毕后，在其他类中是不能直接访问的。在本类中是可以直接访问的。

要把所有的属性隐藏起来，使外界不能改变属性的值，在类中添加访问的方法，好处就是可以在方法中增加校验的功能，保证属性的正确性。

可以在类中增加访问属性的方法，使属性可以被访问。

private仅仅是封装的一种体现，类和方法也是方法的一种体现。

3、构造方法

    (1)格式及特点
格式：
访问权限修饰符 类名(参数...){}
访问权限修饰符:
public,private
特点：
A:方法名和类名相同
B:没有返回值类型
C:没有具体的返回值        

                 符合这三个规则，那就是构造方法。

    构造方法的作用：

给对象进行初始化。

给成员变量赋值。 

注意事项：

        A:如果没有给出构造方法，那么系统会默认给出一个无参构造方法，JAVA虚拟机给的。

 相当于：public Person(){}

B:假如给了构造方法，系统将不在提供无参构造。

  不管以后给出的构造方法是带参数的还是不带参数的。只要给出构造方法系统将不在提供无参构造。

  推荐做法，在任何时候，请手动给出无参构造。

C：构造方法重载,方法名相同，参数列表不同。

    给成员变量赋值：

A:通过set方法

B:通过构造方法

**推荐使用set方法。

4、this关键字:
    代表所在方法所属对象的引用。
哪个对象调用方法，在方法内部就有一个隐含的this代表这个对象
谁调用this就代表谁。
应用场景：

用于解决局部变量隐藏成员变量值得问题。

5、代码块就是有{}括起来的代码块。
分类：
定义在方法中的代码块，叫局部代码块，作用是，让变量尽快早的从内存中消失，提高效率。

                定义在方法外的代码块，叫构造代码块，作用是，让所有构造方法中共同的内容定义在构造代码块中。

                            构造代码快先于构造方法执行，且不管无参构造还是有参构造，只要执行构造方法都会先执行构造代码快。

class CodeBlock
{
{
System.out.println("haha");

}//在构造方法时就执行。
public CodeBlock()
{
System.out.println("hehe");
}//先输出haha，在输出hehe说明是在构造方法之前执行。
public CodeBlock(int a)
{
System.out.println("a = "+ a);
}
public void show()
{
{
int x = 10;
System.out.println("hello"+x);
}
//System.out.println("world"+x);//程序会报错找不到符号x，因为int x是在上面代码块中定义的，执行完后立即消失。
}
}
class CodeBlockTest 
{
public static void main(String[] args) 
{
//局部代码块
//CodeBlock cd = new CodeBlock();
//cd.show();
CodeBlock cd = new CodeBlock();
CodeBlock cd1 = new CodeBlock();//输出两次haha hehe
CodeBlock cd2 = new CodeBlock(10);//输出haha  a = 10;
}

}

6、对象的初始化过程

代码如下：

class Person
{
private String name = "haha";
private int age = 10;
{
System.out.println(name+"-----"+age);
name = "hello";
age = 20;
System.out.println(name+"-----"+age);
}
public Person(){}
public Person(String name,int age)
{
System.out.println(this.name+"----"+this.age);
this.name = name;
this.age = age;
System.out.println(this.name+"-----"+this.age);
}
public void setName(String name)
{
this.name = name;
}
public String getName()
{
return name;
}
public void setAge(int age)
{
this.age = age;
}
public int getAge()
{
return age;
}


}
class PersonTest1 
{
public static void main(String[] args) 
{
Person p = new Person("林青霞",26);
p.setName("我爱林青霞");
p.setAge(36);
System.out.println(p.getName()+"-----"+p.getAge());
 
}

}

输出结果：

haha-----10
hello-----20
hello----20
林青霞-----26
我爱林青霞-----36
请按任意键继续. . .

Person p = new Person()到底在内存中怎么执行的？

做了如下几件事情：
A:把Person.class文件加载到内存（类加载器）
    B:在栈内存开辟一个变量空间，给p使用。
C:new person（）就会在堆内存开辟空间
D:方法进方法区，有类名做标记。并且，同时成员变量进堆内存并给出了默认初始化值。
               name:null
   age:0
E:对成员变量显示初始化
               name:haha
   age:10
F：如果有代码块，可以在构造代码块中对成员变量赋值
G:执行构造方法中对成员变量的赋值。
name:hello
age:20
H:到此为止，对象初始化完毕。
I:把堆内存对象的首地址，赋值给栈内存的p变量。

7、static关键字

    1)应用背景：

代码如下：

class Student

{
private String name;
private int age;
private static String country;
public void show()
{
System.out.println(name+"----"+age+"-----"+country);
}
public Student(){}
public Student(String name,int age)
{
this.name = name;
this.age = age;
 
}
public Student(String name,int age,String country)
{
this.name = name;
this.age = age;
this.country = country;
}
}
class StaticDemo 
{
public static void main(String[] args) 
{
Student s = new Student();
s.show();

Student s1 = new Student("林青霞",26,"中国");
s1.show();

Student s2 = new Student("张曼玉",36);
s2.show();

Student s3 = new Student("张  杰",37);
s3.show();
}

}

/*

         如果都是中国这个字符串，每次创建对象对来一个。
那么如果有1000个就有1000个中国占据内存。
而我们知道，他们都是“中国”。
加入我们能让他们使用相同的中国，也就是说将来只存储一个中国。
针对这种情况，java就提供了一个关键字，static.
他可以修饰成员变量和成员方法。不能修饰构造方法。
当多个对象共享一个数据的时候，就把这个数据用静态static修饰。

*/

        2)类的组成：

成员变量：---外在描述

构造方法：---对数据进行初始化

成员方法：----一些功能

static修饰成员变量和成员方法，不能修饰构造方法

特点：

A:随着类的加载而加载，声明周期很长，成员对象是创建完之后才存在的。

B:优先于对象存在，因为对象是new之后才出现的。

C:为什么要使用静态

因为被所有对象共享，是设计上的一种体现，如果某个内容被所有对象共享，那么这个内容是静态的。

没有被静态修饰的内容，是属于对象的特有描述。如名字和年龄。

举例：饮水机和水杯的问题：饮水机是共享的，水杯是特有的。

D：可以直接被类名调用。不用创建对象就可以直接使用。类名.方法调用。 

Static 注意事项：

A:在静态方法中没有this关键字。

因为静态变量是随着类的加载而加载，而this是随着对象的存在而存在的。   

B:静态方法只能访问静态成员变量和静态成员方法。

  非静态方法可以访问非静态成员变量、方法和静态成员变量、方法。

C:可以通过类名访问。

静态的内容可通过对象调用也可以通过类名调用，推荐通过类名调用。

 8、不同java文件中类的方法的调用

         如果在一个类A中，使用另外的一个类B的内容。

                方式1、先编译B类，在编译A类，最后使用A类。

                方式2、直接编译A类，他会自动帮你编译B类。

9、如何使用JDK提供的API（应用程序编程接口-帮助文档），以math为例。
    步骤：
A：找到文档，打开文档
B:点击左上角的显示变成隐藏，然后点击索引。
C:你应该知道你要找谁，以math为例
在输入框输入math,然后回车，然后再回车
D:看这个类的结构
java.lang
类 math
java.util
类 Class Scanner
如果是java.lang包下的类，是可以直接使用的（math）。
否则就需要导包才可以使用(scanner)。
E:看看对这个类的说明。
F:看构造方法
字段---即成员变量---或者称为属性
a:有构造方法，那么就通过构造方法创建对象使用。
b:没有构造方法，那么这个类的成员都是静态的
通过类名调用。
G：按照正常的操作使用方法。
左边：
是否静态，如果是静态，那么可以通过类名调用，否则就必须创建对象调用。
是否有明确返回值，如果是void类型，就可以直接调用，否则就可以输出或者赋值。
右边：
看方法名，不要写错
看参数，看参数类型及个数。