黑马程序员——Java基础---面向对象
2015-08-11 23:24
525 查看
-----------android培训、java培训、java学习型技术博客、期待与您交流！------------
一、面向过程思想概述
这几天的学习，我们完成一个需求的步骤：首先是搞清楚我们要做什么，然后在分析怎么做，最后我们再代码体现。一步一步去实现，而具体的每一步都需要我们去实现和操作。这些步骤相互调用和协作，完成我们的需求。
在上面的每一个具体步骤中我们都是参与者，并且需要面对具体的每一个步骤和过程，这就是面向过程最直接的体现。
二、面向对象思想引入
回想前面学过的数组，当有多个数组都需要遍历时，我们可以将遍历的代码封装到方法中，需要遍历时，就调用相应的方法即可，提高代码的复用性。在对数组遍历的基础上继续增加需求，比如获取最值，数值逆序等，同样需要将这些功能封装到相应的方法中。这样继续封装会发现方法越来越多，于是就想能不能将这些方法继续进行封装呢？通过前面的学习我们知道类是可以存放方法的，所以，我们就考虑使用类封装来这多个方法，将来再做数组的操作时，不用去找具体的方法，先找到这个类，然后使用这个类中的方法。这就是面向对象思想的编程方式。
三、面向对象
面向对象思想概述：面向对象是基于面向过程的编程思想
(一)面向对象思想特点
1. 是一种更符合我们思想习惯的思想(惰性思想)
2. 可以将复杂的事情简单化
3. 角色发生了转换，我们从执行者变成了指挥者
4. 完成需求时：
(1)先要去找具有所需功能的对象来用
(2)如果该对象不存在，那么创建一个具有所需功能的对象
(3)这样简化了开发并提高了复用性
Java的开发过程，其实就是不断的创建对象，使用对象，指挥对象做事情，设计过程，其实就是在管理和维护对象之间的关系。
(二)面向对象特征：封装(encapsulation)，继承(inheritance)，多态(polymorphism)
四、类与对象
(一)类与对象的关系
我们学习编程语言，就是为了模拟现实世界的事物，实现信息化。
我们如何表示一个现实世界事物呢：
属性：就是该事物的描述信息，比如说是人的身高，体重
行为：就是该事物能够做什么，比如说人可以吃饭，睡觉，吃饭
我们学习的Java语言最基本单位是类，所以，我们就应该把事物用一个类来体现。
Java中用class(类)描述事物也是如此
成员变量：就是事物的属性
成员方法：就是事物的行为
类：是一组相关的属性和行为的集合，是对现实世界事物的描述，是虚拟存在的
对象：是该类事物的具体体现，现实世界事物的本身，是实实在在存在的
举例：
类：学生
对象：班长就是一个对象
如何定义：
按照事物到类的过程一步步分析
如何使用：
创建对象：类名 对象名 = new 类名();
对象名.成员变量
对象名.成员方法
演示用例：
class StudentTest{
public static void main(String[] args){
//创建Student对象
Student st=new Student();
//给成员变量赋值
st.name="zz";
st.age=24;
st.sex='女';
//使用成员变量
System.out.println("学生的姓名为："+st.name);
System.out.println("学生的年龄为："+st.age);
System.out.println("学生的性别为："+st.sex);
//使用成员方法
st.study();
st.eat();
st.sleep();
}
}
class Student{
//成员变量
//姓名
String name;
//年龄
int age;
//性别
char sex;
//成员方法
//学习
public void study(){
System.out.println("好好学习，天天向上");
}
//吃
public void eat(){
System.out.println("好好吃东西");
}
//睡
public void sleep(){
System.out.println("每天按时休息");
}
}
运行结果：
(二)成员变量和局部变量
之前我们用到的基本都是局部变量，现在我们将会使用成员变量。其实成员变量与局部变量都是变量，规范写法上也没什么区别，都是标识符，但是它们在作用范围和内存中分配不同。
成员变量：
①成员变量定义在类中，在整个类中都可以被访问。
②成员变量随着对象的建立而建立，存在于对象所在的堆内存中。
③成员变量有默认初始化值。
局部变量：
①局部变量只定义在局部范围内，如：函数内，语句内等。
②局部变量存在于栈内存中。
③作用的范围结束，变量空间会自动释放。
④局部变量没有默认初始化值。
1. 成员变量和局部变量区别
①在类中位置不同
成员变量 : 类中，方法外
局部变量 : 方法定义中或者方法声明上
②在内存中位置不同
成员变量 : 堆内存中
局部变量 : 栈内存中
③生命周期不同
成员变量 : 随着对象的创建而存在, 随着垃圾街回收的回收而消失
局部变量 : 随着方法的调用而存在, 随着方法的结束就消失了
④初始化值不同
成员变量 : 有初始化值，直接使用,但是默认值
局部变量 : 没有初始化值的，需要初始化才能使用.
(三)匿名对象
匿名对象：就是没有名字的对象，是对象的一种简化表示形式
匿名对象两种使用情况：
1. 当对对象方法仅进行一次调用的时候。
2. 匿名对象可以作为实际参数进行传递。
例： new Cook();
注意: 只能使用一次，就变成垃圾，还没有被立刻回收。如果对一个对象进行多个成员调用，必须给这个对象起个名字。
演示用例：
class GoddessTest{
public static void main(String[] args){
//创建了一个女神对象
new Goddess();
new Goddess().walk();
new Goddess().say("我是匿名的");
}
}
class Goddess{
//成员变量
private String name; //姓名
private int age; // 年龄
private double weight; //体重
//get/set
public String getName(){
return name;
}
public void setName(String name){
this.name = name;
}
public int getAge(){
return age;
}
public void setAge(int age){
this.age = age;
}
public double getWeight(){
return weight;
}
public void setWeight(double weight){
this.weight = weight;
}
//成员方法
public void walk(){
System.out.println("走红毯.....");
}
public void say(String words){
System.out.println( name +"说:" + words );
}
}
运行结果：
五、对象的封装
(一)封装概述：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
(二)封装的好处：
1. 隐藏实现细节，提供公共的访问方式
2. 提高了代码的复用性
3. 提高安全性。
(三)封装原则：
将不需要对外提供的内容都隐藏起来。
把属性隐藏，提供公共方法对其访问。
(四)封装的表现形式之一——private(私有)
1. private关键字：
①是一个权限修饰符.
②可以修饰成员(成员变量和成员方法)
③被private修饰的成员只在本类中才能访问。
2. private最常见的应用：
①把成员变量用private修饰，将成员变量私有化。
②对外提供对应的getXxx()/setXxx()方法对其进行访问，提高对数据访问的安全性。
(五)this关键字
1. this：代表所在类的对象引用
简单的说：方法被哪个对象调用，this就代表那个对象
2. 什么时候使用this呢?
局部变量隐藏成员变量，也就是局部变量和成员变量同名的时候。this.变量名
用于构造方法间调用，如：this(name);这个时候，this语句只能定义在构造方法的第一行，因为初始化要先执行。
演示用例：
class PerponTest{
public static void main(String[] args){
Person p=new Person();
p.setName("张三");
p.setSex("男");
p.setAge(23);
System.out.println("人的姓名为："+p.getName());
System.out.println(p.getName()+"的性别为："+p.getSex());
System.out.println(p.getName()+"的年龄为："+p.getAge());
p.play();
p.eat();
p.sleep();
}
}
class Person{
//成员变量
//姓名
private String name;
//年龄
private int age;
//性别
private String sex;
//定义get/set
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
public void setSex(String sex){
this.sex=sex;
}
public String getSex(){
return sex;
}
public void setAge(int age){
this.age=age;
}
public int getAge(){
return age;
}
//成员方法
//玩耍
public void play(){
System.out.println("玩的开心");
}
//吃
public void eat(){
System.out.println("好好吃东西");
}
//睡
public void sleep(){
System.out.println("每天按时休息");
}
}
运行结果：
六、构造方法
(一)构造方法作用：给对象的数据进行初始化
(二)构造方法格式
方法名与类名相同
没有返回值类型，连void都没有
没有具体的返回值
(三)构造方法注意事项
如果你不提供构造方法，系统会给出默认的空参构造方法
如果你提供了构造方法，系统将不再提供
构造方法也是可以重载的
(四)构造方法与一般方法的区别
构造方法和一般的方法不仅在写法上有所不同，在运行时也有所不同，构造方法在对象一建立时就运行。而一般方法是在对象调用时才执行，一个对象建立，构造方法只执行一次，而一般方法可以被该对象调用多次。
(五)给成员变量赋值
无参构造方法：对象名.方法名();
有参构造方法：在创建对象时直接赋值
演示用例：
class CellphoneTest{
public static void main(String[] args){
//无参构造方法
Cellphone cp=new Cellphone();
//对象名.方法名，给成员变量赋值
cp.setBrand("小米4");
cp.setPrice(1799);
cp.setSize("5寸");
cp.show();
System.out.println("手机的品牌为："+cp.getBrand());
System.out.println("手机的颜色为："+cp.getSize());
System.out.println("手机的价格为："+cp.getPrice());
cp.call("小明");
cp.sendNote("小英","我今天到北京");
System.out.println("---------------------------------------");
//有参构造，直接给成员变量赋值
Cellphone cp2=new Cellphone("华为荣耀6plus",2999,"5.5寸");
cp2.show();
cp2.call("子皓");
cp2.sendNote("晶晶","今天学的怎么样");
}
}
class Cellphone{
//成员变量
//品牌
private String brand;
//价格
private int price;
//大小
private String size;
//构造方法
Cellphone(){}
Cellphone(String brand,int price,String size){
this.brand=brand;
this.price=price;
this.size=size;
}
//get/set
public String getBrand(){
return brand;
}
public void setBrand(String brand){
this.brand=brand;
}
public String getSize(){
return size;
}
public void setSize(String size){
this.size=size;
}
public int getPrice(){
return price;
}
public void setPrice(int price){
this.price=price;
}
//成员方法
//打电话
public void call(String name){
System.out.println("请给"+name+"回电");
}
//发短信
public void sendNote(String name,String text){
System.out.println("给"+name+"发："+text);
}
//玩app
public void playApp(){
System.out.println("用手机可以玩app");
}
public void show(){
System.out.println("手机品牌为："+brand+"，大小为："+size+"，价格为："+price);
}
}
运行结果：
七、类的初始化过程
Student s = new Student();在内存中做了哪些事情?
1. 加载Student.class文件进内存
2. 在栈内存为s开辟空间
3. 在堆内存为学生对象开辟空间
4. 对学生对象的成员变量进行默认初始化
5. 对学生对象的成员变量进行显示初始化
6. 通过构造方法对学生对象的成员变量赋值
7. 学生对象初始化完毕，把对象地址赋值给s变量
八、static关键字
static是一个修饰符，可以修饰成员(成员变量和成员方法)。
(一)static关键字特点：
1. 随着类的加载而加载，也就是说，静态会随着类的消失而消失，说明它的生命周期最长
2. 优先于对象存在
3. 被类的所有对象共享：这也是我们判断是否使用静态关键字的条件
4. 可以通过类名调用：类名.静态成员
(二)static关键字注意事项
1. 在静态方法中是没有this关键字的，因为静态优先于对象存在
2. 静态方法只能访问静态的成员变量和静态的成员方法，非静态方法既可以访问静态也可以访问非静态。
3. 主函数是静态的。
由于静态成员可以直接被类名调用，因此静态成员变量又称为类变量。而非静态成员变量又被称为实例变量。
(三)静态的内存图
静态的内容存在于方法区的静态区
(四)什么时候使用静态？
从两方面下手：因为静态修饰的内容有成员变量和成员方法
1. 什么时候使用定义静态变量呢？
当对象中出现共享数据时，该数据被静态所修饰
对象中的特有数据要定义成非静态存在于堆内存中
2. 什么时候定义静态方法呢？
当功能内部没有访问到非静态数据(对象的特有数据)，那么该功能可以定义成静态的。
(五)静态变量和成员变量的区别
1. 所属不同
静态变量属于类，所以也称为为类变量
成员变量属于对象，所以也称为实例变量(对象变量)
2. 内存中位置不同
静态变量存储于方法区的静态区，随着类的加载而存在于方法区中
成员变量存储于堆内存，随着对象的建立而存在于堆内存中
3. 内存出现时间不同
静态变量随着类的加载而加载，随着类的消失而消失
成员变量随着对象的创建而存在，随着对象的消失而消失
4. 调用不同
静态变量可以通过类名调用，也可以通过对象调用
成员变量只能通过对象名调用
案例演示：
class StudentTest{
public static void main(String[] args){
//有参构造
Student.country = "美国";
Student s = new Student("子明",28,"czbk001");
s.show();
Student s2 = new Student("子皓", 20 ,"czbk002");
s2.show();
s2.sleep();
Student s3 = new Student("子枫", 18 ,"czbk003");
s2.country = "中国";
s3.show();
//调用静态sleep()
Student.sleep();
}
}
//类名
class Student{
//成员变量
static String name; //名字
int age; //年龄
String studyNum; //学号
static String country; // 国籍
//构造方法
//无参构造
Student(){}
//有参构造
Student(String name, int age,String studyNum ){
this.name = name;
this.age = age;
this.studyNum =studyNum;
}
Student(String name, int age, String studyNum ,String country){
this.name = name;
this.age = age;
this.studyNum =studyNum;
this.country = country;
}
//get /set
public String getName(){
return name;
}
public void setName(String name){
this.name = name;
}
public int getAge(){
return age;
}
public void setAge(int age){
this.age = age;
}
public String getStudyNum(){
return studyNum;
}
public void setStudyNum(String studyNum){
this.studyNum = studyNum;
}
//成员方法 (其他功能)
public static void study(){
System.out.println("有精力好好学习Java");
}
public void eat(String food){
System.out.println("饿了吃"+ food);
}
public static void sleep(){
System.out.println( name + "按时休息");
study();
}
public void show(){
System.out.println( "姓名:"+ name + "--年龄是"+age + "--学号为"+ studyNum +"--国籍是" + country);
}
}
运行结果：
九、main方法是静态的
main函数是一个特殊的函数。作为程序的入口，可以被JVM调用
public static void main(String[] args) {}
public被jvm调用，访问权限足够大。
static被jvm调用，不用创建对象，直接类名访问，代表着函数随着类的加载就已经存在了
void被jvm调用，不需要给jvm返回值
main：一个通用的名称，虽然不是关键字，但是被jvm识别
String[] args：以前用于接收键盘录入的，接收字符串的输入
arge：argument参数。唯一可以更改的地方。
十、制作帮助文档(API)
javadoc -d 目录 -author -version ArrayTool.java
每一个应用程序中都有共性的功能，可以将这些功能进行抽取。独立封装，以便复用。以下是一个数组工具类制作文档说明书的例子。
import java.util.Scanner;
class ArrayToolTest{
public static void main(String[] args){
int[] arr={11,22,33,44,55,7,8,6,5,99};
System.out.println("该数组为：");
ArrayTool.printArray(arr);
System.out.println("------------------------------------");
Scanner sc=new Scanner(System.in);
System.out.println("请输入你要查询的数字：");
int num=sc.nextInt();
int index=ArrayTool.select(arr,num);
System.out.println("你所查询的数字，第一次找到时所对应的索引为："+index);
System.out.println("------------------------------------");
System.out.println("数组中最大值为："+ArrayTool.getMax(arr));
System.out.println("数组中最小值为："+ArrayTool.getMin(arr));
System.out.println("------------------------------------");
ArrayTool.huHuan(arr);
System.out.println("反转后的数组为：");
ArrayTool.printArray(arr);
}
}
/**
@author 珍珍
@version v0.9
这是一个数组操作的类,你可以使用它来遍历数组,获取数组中的最值,查找数字第一次被找到所对应的索引值.......
*/
public class ArrayTool{
//成员变量
//构造方法
//get/set
//成员方法
//遍历数组
/**
这是一个遍历数组的方法
@param arr
*/
public static void printArray(int[] arr){
System.out.print("{");
for (int i=0;i<arr.length ;i++ ){
if (i<arr.length-1){
System.out.print(arr[i]+",");
}
else System.out.print(arr[i]+"}");
}
System.out.println();
}
//获取数组中的最大值
/**
这是一个获取数组中元素最大值的方法
@param arr
@return int
*/
public static int getMax(int[] arr){
int max=arr[0];
for (int i=1;i<arr.length ;i++ ){
if (max<arr[i]){
max=arr[i];
}
}
return max;
}
//获取数组中的最小值
/**
这是一个获取数组中元素最小值的方法
@param arr
@return int
*/
public static int getMin(int[] arr){
int min=arr[0];
for (int i=1;i<arr.length ;i++ ){
if (min>arr[i]){
min=arr[i];
}
}
return min;
}
//数组中的基本查询
/**
这是一个查询数字在数组中第一次被找到时输出对应索引值的方法
@param arr
@return int
*/
public static int select(int[] arr,int num){
int index=-1;
for (int i=0;i<arr.length ;i++ ){
if (num==arr[i]){
index=i;
break;
}
}
return index;
}
//反转
/**
这是一个将数组中元素反转的方法
@param arr
*/
public static void huHuan(int[] arr){
int start=0;
int end=arr.length-1;
while(start<end){
int t=arr[start];
arr[start]=arr[end];
arr[end]=t;
start++;
end--;
}
//printArray();
}
}
在dos命令行中输入命令：javadoc –d MyHlepDocuments –author –version ArrayTool.java，java中的javadoc工具就会帮我们制作说明文档了。
运行结果如下：
这样，我们自己制作的属于自己的API就制作成功了，在MaHelpDocuments文件夹中直接打开ArrayTool.html，如下图所示：
十一、通过API学习Math类
Math类概述：Math包含用于执行基本数学运算的方法
Math类特点：没有构造方法，因为成员都是静态的
(一)Math类的一个方法random()获取随机数，random()方法返回带正号的double值，该值大于等于0.0且小于1.0。
案例演示：猜数字小游戏
import java.util.Scanner;
class GuessNum{
public static void main(String[] args){
int bingo=(int)(Math.random()*100)+1;
Scanner sc=new Scanner(System.in);
System.out.println("请输入你猜的数字(1-100)");
int count=0;
while (true){
int num=sc.nextInt();
count++;
if (count<5){
if (num<bingo){
System.out.println("不好意思，你猜小了。。。");
}
else if (num>bingo){
System.out.println("不好意思，你猜大了。。。");
}
else {
System.out.println("恭喜你，猜对了，请去领奖品，O(∩_∩)O哈哈~");
return;
}
}
else{
System.out.println("你真可爱，^(*￣(oo)￣)^^(*￣(oo)￣)^");
return;
}
System.out.println("你已经猜了"+count+"次了！！！"+"你还有"+(5-count)+"次机会");
}
}
}
运行结果：
十二、代码块
在Java中，使用{}括起来的代码被称为代码块，根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块(以后学习多线程后再总结)。
(一)局部代码块
在方法中出现；限定变量生命周期，及早释放，提高内存利用率
(二)构造代码块
在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行
(三)静态代码块 在类中方法外出现，加了static修饰
在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且值执行一次。
案例演示：
class Student {
static {
System.out.println("Student 静态代码块");
}
{
System.out.println("Student 构造代码块");
}
public Student() {
System.out.println("Student 构造方法");
}
}
class StudentDemo {
static {
System.out.println("今天是个好日子");
}
public static void main(String[] args) {
System.out.println("我是main方法");
Student s1 = new Student();
Student s2 = new Student();
}
}
运行结果：
-----------android培训、java培训、java学习型技术博客、期待与您交流！------------
一、面向过程思想概述
这几天的学习，我们完成一个需求的步骤：首先是搞清楚我们要做什么，然后在分析怎么做，最后我们再代码体现。一步一步去实现，而具体的每一步都需要我们去实现和操作。这些步骤相互调用和协作，完成我们的需求。
在上面的每一个具体步骤中我们都是参与者，并且需要面对具体的每一个步骤和过程，这就是面向过程最直接的体现。
二、面向对象思想引入
回想前面学过的数组，当有多个数组都需要遍历时，我们可以将遍历的代码封装到方法中，需要遍历时，就调用相应的方法即可，提高代码的复用性。在对数组遍历的基础上继续增加需求，比如获取最值，数值逆序等，同样需要将这些功能封装到相应的方法中。这样继续封装会发现方法越来越多，于是就想能不能将这些方法继续进行封装呢？通过前面的学习我们知道类是可以存放方法的，所以，我们就考虑使用类封装来这多个方法，将来再做数组的操作时，不用去找具体的方法，先找到这个类，然后使用这个类中的方法。这就是面向对象思想的编程方式。
三、面向对象
面向对象思想概述：面向对象是基于面向过程的编程思想
(一)面向对象思想特点
1. 是一种更符合我们思想习惯的思想(惰性思想)
2. 可以将复杂的事情简单化
3. 角色发生了转换，我们从执行者变成了指挥者
4. 完成需求时：
(1)先要去找具有所需功能的对象来用
(2)如果该对象不存在，那么创建一个具有所需功能的对象
(3)这样简化了开发并提高了复用性
Java的开发过程，其实就是不断的创建对象，使用对象，指挥对象做事情，设计过程，其实就是在管理和维护对象之间的关系。
(二)面向对象特征：封装(encapsulation)，继承(inheritance)，多态(polymorphism)
四、类与对象
(一)类与对象的关系
我们学习编程语言，就是为了模拟现实世界的事物，实现信息化。
我们如何表示一个现实世界事物呢：
属性：就是该事物的描述信息，比如说是人的身高，体重
行为：就是该事物能够做什么，比如说人可以吃饭，睡觉，吃饭
我们学习的Java语言最基本单位是类，所以，我们就应该把事物用一个类来体现。
Java中用class(类)描述事物也是如此
成员变量：就是事物的属性
成员方法：就是事物的行为
类：是一组相关的属性和行为的集合，是对现实世界事物的描述，是虚拟存在的
对象：是该类事物的具体体现，现实世界事物的本身，是实实在在存在的
举例：
类：学生
对象：班长就是一个对象
如何定义：
按照事物到类的过程一步步分析
如何使用：
创建对象：类名 对象名 = new 类名();
对象名.成员变量
对象名.成员方法
演示用例：
class StudentTest{
public static void main(String[] args){
//创建Student对象
Student st=new Student();
//给成员变量赋值
st.name="zz";
st.age=24;
st.sex='女';
//使用成员变量
System.out.println("学生的姓名为："+st.name);
System.out.println("学生的年龄为："+st.age);
System.out.println("学生的性别为："+st.sex);
//使用成员方法
st.study();
st.eat();
st.sleep();
}
}
class Student{
//成员变量
//姓名
String name;
//年龄
int age;
//性别
char sex;
//成员方法
//学习
public void study(){
System.out.println("好好学习，天天向上");
}
//吃
public void eat(){
System.out.println("好好吃东西");
}
//睡
public void sleep(){
System.out.println("每天按时休息");
}
}
运行结果：
(二)成员变量和局部变量
之前我们用到的基本都是局部变量，现在我们将会使用成员变量。其实成员变量与局部变量都是变量，规范写法上也没什么区别，都是标识符，但是它们在作用范围和内存中分配不同。
成员变量：
①成员变量定义在类中，在整个类中都可以被访问。
②成员变量随着对象的建立而建立，存在于对象所在的堆内存中。
③成员变量有默认初始化值。
局部变量：
①局部变量只定义在局部范围内，如：函数内，语句内等。
②局部变量存在于栈内存中。
③作用的范围结束，变量空间会自动释放。
④局部变量没有默认初始化值。
1. 成员变量和局部变量区别
①在类中位置不同
成员变量 : 类中，方法外
局部变量 : 方法定义中或者方法声明上
②在内存中位置不同
成员变量 : 堆内存中
局部变量 : 栈内存中
③生命周期不同
成员变量 : 随着对象的创建而存在, 随着垃圾街回收的回收而消失
局部变量 : 随着方法的调用而存在, 随着方法的结束就消失了
④初始化值不同
成员变量 : 有初始化值，直接使用,但是默认值
局部变量 : 没有初始化值的，需要初始化才能使用.
(三)匿名对象
匿名对象：就是没有名字的对象，是对象的一种简化表示形式
匿名对象两种使用情况：
1. 当对对象方法仅进行一次调用的时候。
2. 匿名对象可以作为实际参数进行传递。
例： new Cook();
注意: 只能使用一次，就变成垃圾，还没有被立刻回收。如果对一个对象进行多个成员调用，必须给这个对象起个名字。
演示用例：
class GoddessTest{
public static void main(String[] args){
//创建了一个女神对象
new Goddess();
new Goddess().walk();
new Goddess().say("我是匿名的");
}
}
class Goddess{
//成员变量
private String name; //姓名
private int age; // 年龄
private double weight; //体重
//get/set
public String getName(){
return name;
}
public void setName(String name){
this.name = name;
}
public int getAge(){
return age;
}
public void setAge(int age){
this.age = age;
}
public double getWeight(){
return weight;
}
public void setWeight(double weight){
this.weight = weight;
}
//成员方法
public void walk(){
System.out.println("走红毯.....");
}
public void say(String words){
System.out.println( name +"说:" + words );
}
}
运行结果：
五、对象的封装
(一)封装概述：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
(二)封装的好处：
1. 隐藏实现细节，提供公共的访问方式
2. 提高了代码的复用性
3. 提高安全性。
(三)封装原则：
将不需要对外提供的内容都隐藏起来。
把属性隐藏，提供公共方法对其访问。
(四)封装的表现形式之一——private(私有)
1. private关键字：
①是一个权限修饰符.
②可以修饰成员(成员变量和成员方法)
③被private修饰的成员只在本类中才能访问。
2. private最常见的应用：
①把成员变量用private修饰，将成员变量私有化。
②对外提供对应的getXxx()/setXxx()方法对其进行访问，提高对数据访问的安全性。
(五)this关键字
1. this：代表所在类的对象引用
简单的说：方法被哪个对象调用，this就代表那个对象
2. 什么时候使用this呢?
局部变量隐藏成员变量，也就是局部变量和成员变量同名的时候。this.变量名
用于构造方法间调用，如：this(name);这个时候，this语句只能定义在构造方法的第一行，因为初始化要先执行。
演示用例：
class PerponTest{
public static void main(String[] args){
Person p=new Person();
p.setName("张三");
p.setSex("男");
p.setAge(23);
System.out.println("人的姓名为："+p.getName());
System.out.println(p.getName()+"的性别为："+p.getSex());
System.out.println(p.getName()+"的年龄为："+p.getAge());
p.play();
p.eat();
p.sleep();
}
}
class Person{
//成员变量
//姓名
private String name;
//年龄
private int age;
//性别
private String sex;
//定义get/set
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
public void setSex(String sex){
this.sex=sex;
}
public String getSex(){
return sex;
}
public void setAge(int age){
this.age=age;
}
public int getAge(){
return age;
}
//成员方法
//玩耍
public void play(){
System.out.println("玩的开心");
}
//吃
public void eat(){
System.out.println("好好吃东西");
}
//睡
public void sleep(){
System.out.println("每天按时休息");
}
}
运行结果：
六、构造方法
(一)构造方法作用：给对象的数据进行初始化
(二)构造方法格式
方法名与类名相同
没有返回值类型，连void都没有
没有具体的返回值
(三)构造方法注意事项
如果你不提供构造方法，系统会给出默认的空参构造方法
如果你提供了构造方法，系统将不再提供
构造方法也是可以重载的
(四)构造方法与一般方法的区别
构造方法和一般的方法不仅在写法上有所不同，在运行时也有所不同，构造方法在对象一建立时就运行。而一般方法是在对象调用时才执行，一个对象建立，构造方法只执行一次，而一般方法可以被该对象调用多次。
(五)给成员变量赋值
无参构造方法：对象名.方法名();
有参构造方法：在创建对象时直接赋值
演示用例：
class CellphoneTest{
public static void main(String[] args){
//无参构造方法
Cellphone cp=new Cellphone();
//对象名.方法名，给成员变量赋值
cp.setBrand("小米4");
cp.setPrice(1799);
cp.setSize("5寸");
cp.show();
System.out.println("手机的品牌为："+cp.getBrand());
System.out.println("手机的颜色为："+cp.getSize());
System.out.println("手机的价格为："+cp.getPrice());
cp.call("小明");
cp.sendNote("小英","我今天到北京");
System.out.println("---------------------------------------");
//有参构造，直接给成员变量赋值
Cellphone cp2=new Cellphone("华为荣耀6plus",2999,"5.5寸");
cp2.show();
cp2.call("子皓");
cp2.sendNote("晶晶","今天学的怎么样");
}
}
class Cellphone{
//成员变量
//品牌
private String brand;
//价格
private int price;
//大小
private String size;
//构造方法
Cellphone(){}
Cellphone(String brand,int price,String size){
this.brand=brand;
this.price=price;
this.size=size;
}
//get/set
public String getBrand(){
return brand;
}
public void setBrand(String brand){
this.brand=brand;
}
public String getSize(){
return size;
}
public void setSize(String size){
this.size=size;
}
public int getPrice(){
return price;
}
public void setPrice(int price){
this.price=price;
}
//成员方法
//打电话
public void call(String name){
System.out.println("请给"+name+"回电");
}
//发短信
public void sendNote(String name,String text){
System.out.println("给"+name+"发："+text);
}
//玩app
public void playApp(){
System.out.println("用手机可以玩app");
}
public void show(){
System.out.println("手机品牌为："+brand+"，大小为："+size+"，价格为："+price);
}
}
运行结果：
七、类的初始化过程
Student s = new Student();在内存中做了哪些事情?
1. 加载Student.class文件进内存
2. 在栈内存为s开辟空间
3. 在堆内存为学生对象开辟空间
4. 对学生对象的成员变量进行默认初始化
5. 对学生对象的成员变量进行显示初始化
6. 通过构造方法对学生对象的成员变量赋值
7. 学生对象初始化完毕，把对象地址赋值给s变量
八、static关键字
static是一个修饰符，可以修饰成员(成员变量和成员方法)。
(一)static关键字特点：
1. 随着类的加载而加载，也就是说，静态会随着类的消失而消失，说明它的生命周期最长
2. 优先于对象存在
3. 被类的所有对象共享：这也是我们判断是否使用静态关键字的条件
4. 可以通过类名调用：类名.静态成员
(二)static关键字注意事项
1. 在静态方法中是没有this关键字的，因为静态优先于对象存在
2. 静态方法只能访问静态的成员变量和静态的成员方法，非静态方法既可以访问静态也可以访问非静态。
3. 主函数是静态的。
由于静态成员可以直接被类名调用，因此静态成员变量又称为类变量。而非静态成员变量又被称为实例变量。
(三)静态的内存图
静态的内容存在于方法区的静态区
(四)什么时候使用静态？
从两方面下手：因为静态修饰的内容有成员变量和成员方法
1. 什么时候使用定义静态变量呢？
当对象中出现共享数据时，该数据被静态所修饰
对象中的特有数据要定义成非静态存在于堆内存中
2. 什么时候定义静态方法呢？
当功能内部没有访问到非静态数据(对象的特有数据)，那么该功能可以定义成静态的。
(五)静态变量和成员变量的区别
1. 所属不同
静态变量属于类，所以也称为为类变量
成员变量属于对象，所以也称为实例变量(对象变量)
2. 内存中位置不同
静态变量存储于方法区的静态区，随着类的加载而存在于方法区中
成员变量存储于堆内存，随着对象的建立而存在于堆内存中
3. 内存出现时间不同
静态变量随着类的加载而加载，随着类的消失而消失
成员变量随着对象的创建而存在，随着对象的消失而消失
4. 调用不同
静态变量可以通过类名调用，也可以通过对象调用
成员变量只能通过对象名调用
案例演示：
class StudentTest{
public static void main(String[] args){
//有参构造
Student.country = "美国";
Student s = new Student("子明",28,"czbk001");
s.show();
Student s2 = new Student("子皓", 20 ,"czbk002");
s2.show();
s2.sleep();
Student s3 = new Student("子枫", 18 ,"czbk003");
s2.country = "中国";
s3.show();
//调用静态sleep()
Student.sleep();
}
}
//类名
class Student{
//成员变量
static String name; //名字
int age; //年龄
String studyNum; //学号
static String country; // 国籍
//构造方法
//无参构造
Student(){}
//有参构造
Student(String name, int age,String studyNum ){
this.name = name;
this.age = age;
this.studyNum =studyNum;
}
Student(String name, int age, String studyNum ,String country){
this.name = name;
this.age = age;
this.studyNum =studyNum;
this.country = country;
}
//get /set
public String getName(){
return name;
}
public void setName(String name){
this.name = name;
}
public int getAge(){
return age;
}
public void setAge(int age){
this.age = age;
}
public String getStudyNum(){
return studyNum;
}
public void setStudyNum(String studyNum){
this.studyNum = studyNum;
}
//成员方法 (其他功能)
public static void study(){
System.out.println("有精力好好学习Java");
}
public void eat(String food){
System.out.println("饿了吃"+ food);
}
public static void sleep(){
System.out.println( name + "按时休息");
study();
}
public void show(){
System.out.println( "姓名:"+ name + "--年龄是"+age + "--学号为"+ studyNum +"--国籍是" + country);
}
}
运行结果：
九、main方法是静态的
main函数是一个特殊的函数。作为程序的入口，可以被JVM调用
public static void main(String[] args) {}
public被jvm调用，访问权限足够大。
static被jvm调用，不用创建对象，直接类名访问，代表着函数随着类的加载就已经存在了
void被jvm调用，不需要给jvm返回值
main：一个通用的名称，虽然不是关键字，但是被jvm识别
String[] args：以前用于接收键盘录入的，接收字符串的输入
arge：argument参数。唯一可以更改的地方。
十、制作帮助文档(API)
javadoc -d 目录 -author -version ArrayTool.java
每一个应用程序中都有共性的功能，可以将这些功能进行抽取。独立封装，以便复用。以下是一个数组工具类制作文档说明书的例子。
import java.util.Scanner;
class ArrayToolTest{
public static void main(String[] args){
int[] arr={11,22,33,44,55,7,8,6,5,99};
System.out.println("该数组为：");
ArrayTool.printArray(arr);
System.out.println("------------------------------------");
Scanner sc=new Scanner(System.in);
System.out.println("请输入你要查询的数字：");
int num=sc.nextInt();
int index=ArrayTool.select(arr,num);
System.out.println("你所查询的数字，第一次找到时所对应的索引为："+index);
System.out.println("------------------------------------");
System.out.println("数组中最大值为："+ArrayTool.getMax(arr));
System.out.println("数组中最小值为："+ArrayTool.getMin(arr));
System.out.println("------------------------------------");
ArrayTool.huHuan(arr);
System.out.println("反转后的数组为：");
ArrayTool.printArray(arr);
}
}
/**
@author 珍珍
@version v0.9
这是一个数组操作的类,你可以使用它来遍历数组,获取数组中的最值,查找数字第一次被找到所对应的索引值.......
*/
public class ArrayTool{
//成员变量
//构造方法
//get/set
//成员方法
//遍历数组
/**
这是一个遍历数组的方法
@param arr
*/
public static void printArray(int[] arr){
System.out.print("{");
for (int i=0;i<arr.length ;i++ ){
if (i<arr.length-1){
System.out.print(arr[i]+",");
}
else System.out.print(arr[i]+"}");
}
System.out.println();
}
//获取数组中的最大值
/**
这是一个获取数组中元素最大值的方法
@param arr
@return int
*/
public static int getMax(int[] arr){
int max=arr[0];
for (int i=1;i<arr.length ;i++ ){
if (max<arr[i]){
max=arr[i];
}
}
return max;
}
//获取数组中的最小值
/**
这是一个获取数组中元素最小值的方法
@param arr
@return int
*/
public static int getMin(int[] arr){
int min=arr[0];
for (int i=1;i<arr.length ;i++ ){
if (min>arr[i]){
min=arr[i];
}
}
return min;
}
//数组中的基本查询
/**
这是一个查询数字在数组中第一次被找到时输出对应索引值的方法
@param arr
@return int
*/
public static int select(int[] arr,int num){
int index=-1;
for (int i=0;i<arr.length ;i++ ){
if (num==arr[i]){
index=i;
break;
}
}
return index;
}
//反转
/**
这是一个将数组中元素反转的方法
@param arr
*/
public static void huHuan(int[] arr){
int start=0;
int end=arr.length-1;
while(start<end){
int t=arr[start];
arr[start]=arr[end];
arr[end]=t;
start++;
end--;
}
//printArray();
}
}
在dos命令行中输入命令：javadoc –d MyHlepDocuments –author –version ArrayTool.java，java中的javadoc工具就会帮我们制作说明文档了。
运行结果如下：
这样，我们自己制作的属于自己的API就制作成功了，在MaHelpDocuments文件夹中直接打开ArrayTool.html，如下图所示：
十一、通过API学习Math类
Math类概述：Math包含用于执行基本数学运算的方法
Math类特点：没有构造方法，因为成员都是静态的
(一)Math类的一个方法random()获取随机数，random()方法返回带正号的double值，该值大于等于0.0且小于1.0。
案例演示：猜数字小游戏
import java.util.Scanner;
class GuessNum{
public static void main(String[] args){
int bingo=(int)(Math.random()*100)+1;
Scanner sc=new Scanner(System.in);
System.out.println("请输入你猜的数字(1-100)");
int count=0;
while (true){
int num=sc.nextInt();
count++;
if (count<5){
if (num<bingo){
System.out.println("不好意思，你猜小了。。。");
}
else if (num>bingo){
System.out.println("不好意思，你猜大了。。。");
}
else {
System.out.println("恭喜你，猜对了，请去领奖品，O(∩_∩)O哈哈~");
return;
}
}
else{
System.out.println("你真可爱，^(*￣(oo)￣)^^(*￣(oo)￣)^");
return;
}
System.out.println("你已经猜了"+count+"次了！！！"+"你还有"+(5-count)+"次机会");
}
}
}
运行结果：
十二、代码块
在Java中，使用{}括起来的代码被称为代码块，根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块(以后学习多线程后再总结)。
(一)局部代码块
在方法中出现；限定变量生命周期，及早释放，提高内存利用率
(二)构造代码块
在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行
(三)静态代码块 在类中方法外出现，加了static修饰
在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且值执行一次。
案例演示：
class Student {
static {
System.out.println("Student 静态代码块");
}
{
System.out.println("Student 构造代码块");
}
public Student() {
System.out.println("Student 构造方法");
}
}
class StudentDemo {
static {
System.out.println("今天是个好日子");
}
public static void main(String[] args) {
System.out.println("我是main方法");
Student s1 = new Student();
Student s2 = new Student();
}
}
运行结果：
-----------android培训、java培训、java学习型技术博客、期待与您交流！------------
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 黑马程序员——Java基础---继承，抽象，多态，接口，包，内部类
- 黑马程序员
- 黑马程序员——Java基础---集合
- 黑马程序员——高新技术---反射
- 黑马程序员
- 黑马程序员——Java基础---方法与数组操作
- 黑马程序员——Java基础---多线程
- Android面试题集锦
- 黑马程序员——多态
- 黑马程序员——组合与super关键字
- [程序员面试金典]1001.字符串变换
- 程序员装逼指南 （转）
- 黑马程序员——继承
- [程序员面试金典]1002.下一个较大元素
- 黑马程序员——self使用
- 黑马程序员——Java基础---常用类，基本类型包装类，正则表达式
- 【黑马程序员】protocol的概念及基本使用
- 黑马程序员——Java基础---IO、File类、Properties类、打印流、序列流（合并流）
- 黑马程序员——类方法与self关键字
- 码农成长篇——新员工怎样快速脱颖而出