Java学习日记基础（五）——类、对象之this、静态变量(类变量)、静态方法(类方法)、四大特征

this

赵本山问奥尼尔：“我的爸爸的爸爸是谁？”

奥尼尔：“不知道”

赵本山：“你傻啊，是我爷爷”

奥尼尔回去问科比：“我的爸爸的爸爸是谁？”

科比：“不知道”

奥尼尔：”你傻啊，是赵本山的爷爷“

就像这个笑话一样，不同的人，用this时，指向的对象也是变的。

 普通方法中，this总是指向调用该方法的对象

//this在成员方法中的用处
//this就是指代当前对象，是一个隐式参数

public class thissss
{
	public static void main(String []args)
	{
		Student s1 = new Student();
		s1.name = "小白";
		s1.age = 17;
		s1.study();
		System.out.println(s1.name);
		Student s2 = new Student();
		s2.name = "小徐";
		s2.age = 18;
		s2.study();
	}
}


class Student
{
	int age;
	String name;
	public void study()		
	//在创建成员方法(函数)的时候会自动传一个this参数,指向该对象的地址,但是是隐藏的
	{
		this.name = "小黑";
		//s1.name = "小黑";
		//这条语句是错误的,因为对象要在类创建完成之后才有
		//但是使用this.name就可以给类进行赋值
		//因为this指向创建的对象的地址,所以this.name就会找到该对象中study()方法的地址
		//对这个地址进行操纵,总而更改当前对象的值
		System.out.println(name+"在学习");
	}
}

图解：

构造方法中，this总是指向正要初始化的对象

//this在构造方法中的用处
//用来指向正在初始化的对象
public class thissss2
{
	public static void main(String []args)
	{
		Student s1 = new Student(17);
		System.out.println(s1.age);
		Student s2 = new Student(18);

	}
}


class Student
{
	int age;
	String name;
	public Student(int age)
	{
		//age = age
		//直接写age指代的是public void Student(String name,int age)传进来的name,就近原则
		//this.age指代的是当前正在初始化的对象中的String age;
		this.age = age;
	}	
}

输出结果：
age = age时，输出的是0，并非是正常的结果
this.age = age时,输出的是正常的结果17

　　原因也是因为会默认传一个this参数，用来指向当前使用这条命令的对象的地址，这样就可以正确的初始化当前对象中成员变量的值了

　　注意：this不能用于static方法（学了static方法就知道为什么了）

变量的种类

实例变量、类变量、常量都是属于成员变量的，成员变量又被称为全局变量

public class A{
    String id;                          //实例变量
    private String Tel;        　　　　  //实例变量
    private int size;             　　  //实例变量
    private static String depart;             //类变量
    final String design="样式";                //常量
}
 
/*其中实例变量、类变量、常量都是属于成员变量的，成员变量又被称为全局变量，
成员变量的范围比实例变量更宽泛 */               

方法（函数）的种类

实例方法（instance method）：或叫成员方法（member method）。供实例用的方法，必须要先有实例，才能通过此实例调用实例方法。

静态变量 / 类变量

提问：有一群小孩在玩堆雪人，不时有新的小孩加入，请问如何知道现在有多少人在玩呢？请使用面向对象的思想，编程解决。

public class Demo1
{
    public static void main(String []args)
    {
        int total = 0;
        Child ch1 = new child(3,"小徐");
        ch1.joinGame();
        total++;
        
        Child ch2 = new child(4,"小白");
        ch2.joinGame();
        total++;
        //查看总人数的时候,只需要输入total的值就可以了
        //但是要求是使用面向对象的方法,课时这个total并没有封装到对象中去
    }
}

//定义kid类
class Child
{
    int age;
    String name;
    public Child(int age,String name)
    {
        this.age = age;
        this.name = name;
    }
    public void joinGame()
    {
        System.out.println("有一个小孩加入了");
    }
}

从上面的例子中可以看到，要是有一个所有对象都能操作的变量就好了，而java中确实有这个变量，叫做静态变量（也叫类变量）

public class Demo1
{
    public static void main(String []args)
    {
        Child ch1 = new Child(3,"小徐");
        ch1.joinGame();
        Child ch2 = new Child(4,"小白");
        ch2.joinGame();
        System.out.println("公有="+ch2.total);
        //也可以直接用类访问静态变量
        System.out.println("公有="+Child.total);
        
    }
}

//定义kid类
class Child
{
    int age;
    String name;
    //total是静态变量, 因此可以被任何一个对象访问
    static int total = 0;
    public Child(int age,String name)
    {
        this.age = age;
        this.name = name;
    }
    public void joinGame()
    {
        total++;        //在这里进行计数操作
        System.out.println("有一个小孩加入了");
    }
}

什么是：静态变量（类变量）？

　　类变量是该类的所有对象的共享变量，任何一个该类的对象去访问它是，取到的都是相同的值，同样任何一个该类的对象去修改它时，修改的也是同一个变量。

静态变量的定义语法

访问修饰符   static  数据类型  变量名;

静态变量的访问方法

• 类名 . 静态变量名
• 对象名 . 静态变量名　　

加深静态方法的理解的小例子

public class Demo2
{
    static int i=1;
    static         //静态区域块只会被执行一次
    {
        i++;
    }
    public Demo2()
    {
        i++;
    }
    
    public static void main(String []args)
    {
        Demo2 t1 = new Demo2();
        System.out.println(t1.i);
        Demo2 t2 = new Demo2();
        System.out.println(t2.i);
        
    }
}

原理：

public class Demo2
{
    static int i=1;
    static         //静态区域块只会被执行一次
    {
        i++;
        System.out.println("静态区域块");
    }
    public Demo2()
    {
        i++;
        System.out.println("成员方法Demo2");
    }
    
    public static void main(String []args)
    {
        Demo2 t1 = new Demo2();
        System.out.println(t1.i);
        Demo2 t2 = new Demo2();
        System.out.println(t2.i);
        
    }
}

输出结果：
静态区域块
成员方法Demo2
3
成员方法Demo2
4

不创建对象static也会执行，原理将来会讲

public class Demo2
{
    static int i=1;
    static         //静态区域块只会被执行一次
    {
        i++;
        System.out.println("静态区域块");
    }
    public Demo2()
    {
        i++;
        System.out.println("成员方法Demo2");
    }
    
    public static void main(String []args)
    {
    }
}

输出结果：
D:myJavaDemoDay3>java Demo2
静态区域块

静态方法（类方法）

小例子：

public class Demo3
{
	public static void main(String []args)
	{
		//创建一个学生
		Stu stu1=new Stu(29,"aa",340);
		Stu stu2 = new Stu(29,"aa",290);
		System.out.println(stu2.getTotalFee());
		//此时这个语法是有歧义的，感觉输出的是stu2的学费,但是输出的是所有学生的费用		
	}
}

class Stu
{
	int age;
	String name;
	int fee;
	static int totalFee;
	
	public Stu(int age,String name,int fee)
	{
		this.age = age;
		this.name = name;
		totalFee+=fee;
	}
	public int getTotalFee()
	{
		return totalFee;
	}
}

使用静态方法

java中有一个规则，静态变量原则用静态方法去访问和操作，约定俗成的。并且

• 静态方法中不能对非静态变量操作
• 但普通的成员方法可以操作静态变量，
• 静态变量都可以被操作，非静态方法不能被静态方法操作

public class Demo3
{
    public static void main(String []args)
    {
        //创建一个学生
        Stu stu1=new Stu(29,"aa",340);
        Stu stu2 = new Stu(29,"aa",290);
        //可以直接使用Stu类名来访问这个静态方法
        System.out.println(Stu.getTotalFee());
        
    }
}

class Stu
{
    int age;
    String name;
    int fee;
    static int totalFee;
    
    public Stu(int age,String name,int fee)
    {
        this.age = age;
        this.name = name;
        totalFee+=fee;
    }
    public static int getTotalFee()  //区别就是这条语句中多了一个static
    {
        return totalFee;
    }
}

什么时候使用静态方法？

如果有一个方法（函数）需要让所有的对象去共享的时候，就可以设计成为静态方法

静态方法的语法

访问修饰符  static  数据返回类型  方法名 ()
{
            //语句;
}


//注意静态方法中不能访问非静态变量,例如: 成员属性

使用方法

类名 . 静态方法名
对象名 . 静态方法名

类变量与实例变量的区别

静态变量(类变量)
int a;
String name;

实例变量
int static a;
String static name;

• 加上static称为静态变量或类变量 ,否则称为实例变量
• 类变量是与类相关的,公共的属性
• 实例变量是属于每个对象个体的属性
• 类变量可以通过 类名.类变量名 直接访问　　

静态方法（类方法）与实例方法的区别

静态方法(类方法)
public static int getTotalFee()  
	{
		return totalFee;
	}

实例方法
public int getTotalFee()
	{
		return totalFee;
	}

• 类方法属于与类相关的，公共的方法　　
•  实例方法属于每个对象个体的方法
• 类方法可以通过  类名.类方法名  直接访问

四大特征——抽象、封装、继承、多态

一般是说java有三大特征，即封装、继承、多态。但有人也会把抽象算进去，如顺平

抽象

 　　我们前面在定义一个类的时候，实际上就是把一类事物共有的属性和行为提取出来，形成一个物理模型（模板）。这种研究问题的方法称为抽象。

封装

封装就是把抽象出的数据和对数据的操作封装在一起，数据被保护在内部，程序的其它部分只有通过被授权的操作（成员方法），才能对数据进行操作。

就像电视机一样，电路板被保护在内部，我们不能直接操作电路板，但是我们可以通过电视机上的按钮来的操作电路板，从而达到我们的目的。

访问控制修饰符

小例子：访问公有的成员变量

public class Demo4
{
    public static void main(String []args)
    {
        Clerk clerk1 = new Clerk("小花",24,4567.6f);
        System.out.println("名字是"+clerk1.name);
        
    }
}

class Clerk
{
    public String name;        //public共有的
    private int age;        //private私有的
    private float salary;
    
    public Clerk(String name,int age,float sal)
    {
        this.name = name;
        this.age = age;
        this.salary = sal;
    }
}

输出结果：
名字是小花

但访问私有的成员变量时，会报错

public class Demo4
{
    public static void main(String []args)
    {
        Clerk clerk1 = new Clerk("小花",24,4567.6f);
        System.out.println("名字是"+clerk1.name);
        
    }
}

class Clerk
{
    public String name;        //public共有的
    private int age;        //private私有的
    private float salary;
    
    public Clerk(String name,int age,float sal)
    {
        this.name = name;
        this.age = age;
        this.salary = sal;
    }
}

报错信息：
Demo4.java:11: 错误: salary 在 Clerk 中是 private 访问控制
                System.out.println("薪水是"+clerk1.salary);
                                               ^
1 个错误

通过成员方法去控制和访问私有的属性

public class Demo4
{
    public static void main(String []args)
    {
        Clerk clerk1 = new Clerk("小花",24,4567.6f);
        System.out.println("薪水是"+clerk1.getSal());
        
    }
}

class Clerk
{
    public String name;        //public共有的
    private int age;        //private私有的
    private float salary;
    
    public Clerk(String name,int age,float sal)
    {
        this.name = name;
        this.age = age;
        this.salary = sal;
    }
    //通过一个成员方法去控制和访问私有的属性
    public float getSal()
    {
        return this.salary;
    }
}

输出结果：
薪水是4567.6

因为成员方法是公开的(public)，可以被使用。

就像我们使用电视机的时候不能通过操作电路板来换台、调节音量，但是我们可以通过操作电视机给我们提供的按钮来进行换台、调节音量的操作。电视机上的按钮就相当于成员方法。

• 厂商不让我们操作电路板，但是让我们操作按钮来间接操作电路板。
• 类不让我们访问私有的属性，但是让我们使用成员方法来访问私有属性。

Java提供四种访问控制修饰符号 控制 方法和变量 的访问权限

• 公开级别：用 pulic 修饰，对外公开
• 受保护级别：用 protected 修饰，对子类和同一个包中的类公开
• 默认级别：没有修饰符号，像同一个包的类公开
• 私有级别：用 private 修饰，只有类本身可以访问，不对外空开

包

从包开始，就不用记事本写程序了，改成用eclipse了

包的必要性？

 有这样的一种情况，小白定义了一个类取名为Dog，赛拉也定义了一个类取名为Dog，然后他们俩就打起来了。我们使用myeclipse来模拟一下这种情况

　　　

小徐此时站了起来，说：“你们是傻吗？不知道包的作用！”

.代表再分一层

包的作用

1. 区分相同名字的类
2. 当类很多时，可以很好的管理
3. 控制访问范围

打包命令

命令一般放在文件开头的地方

package com.shunping;　　　　//这条命令会自动生成,会自动把字节码放到com.shunping这个包中去

命名规范

//包名都是小写字母 , 用 . 隔开 , 比如
com.sina.shunping　　

常用的包

一个包下，包含很多的类，java中常用的包有：

• java.lang.* —— 这个包是自动引入的
• java.util.* —— 工具包
• java.net.* —— 网络开发包
• java.awt.* —— 窗口工具包

引入一个包

语法 :  import   包;
import  java.awt.* ;

　　我们引入一个包的主要目的是使用该包下的类

 用包来控制访问范围

package com.xiaoqiang;

public class Test 
{
    public static void main(String[] args) 
    {
        Dog dog1 = new Dog();

                //验证同包下的权限访问情况
        System.out.println(dog1.a);

    }

}
class Dog
{
    public int a;
    protected String name;
    String color;
    private float price;
    
        //验证同类下的权限访问情况
    public void ab1()
    {
        System.out.println(this.a);
        
    }
}        

 同类下的访问权限

同包下的访问权限——没有私有属性的price类

不同包下的访问权限用——用小明去访问小强中的Dog类

在小强的包下新建一个公有的Cat类，里面的内容和Dog相同，此时小明的访问情况为

package com.xiaoqiang;

public class Cat 
{
    public int a;
    protected String name;
    String color;
    private float price;
    
    public void ab1()
    {
        System.out.println(this.a);
        
    }    
}

权限访问情况为——只能访问公有类

如果我就是想访问其它的属性呢？

——这时就要用到封装的思想，用公有的成员方法去访问私有属性

package com.xiaoqiang;

public class Cat 
{
    public int a;
    protected String name;
    String color;
    private float price;
    
    //提供一个访问name的成员方法
    public String getName()
    {
        return this.name;
        
    }
    
    
}

继承

 为什么有继承？

小例子：我们定义小学生，中学生，大学生类

public class Demo 
{
    public static void main(String[] args) 
    {
    }

}

//小学生类
class Pupil
{
    //定义成员属性
    private int age;
    private String name;
    private float fee;
    
    //交费
    public void pay(float fee)
    {
        this.fee = fee;
    }
}

//中学生类
class MiddleStu
{
    //定义成员属性
    private int age;
    private String name;
    private float fee;
    
    //交费
    public void pay(float fee)
    {
        this.fee = fee*0.8f;
    }
}

//大学生类
class ColStu
{
    //定义成员属性
    private int age;
    private String name;
    private float fee;
    
    //交费
    public void pay(float fee)
    {
        this.fee = fee*0.1f;
    }
}

继承就可以很好的解决代码重复问题，让我们的编程更加靠近人类的思维。

当多个类中存在相同的属性（变量）和方法时，可以从这些类中抽象出父类，在父类中定义这些相同的属性和方法。这样所有的子类不需要重新定义这些属性和方法，只需要通过extends语句来把父类的这些属性和方法继承过来就行。

public class Demo 
{
    public static void main(String[] args) 
    {
    }

}
//将学生的共有属性抽象出来, 做一个父类
class Student
{
    public int age;
    public String name;
    public float fee;
    
}
//小学生类
class Pupil extends Student{
    //交费
    public void pay(float fee)
    {
        this.fee = fee;
    }
}
//中学生类
class MiddleStu extends Student{    
    //交费
    public void pay(float fee)
    {
        this.fee = fee*0.8f;
    }
}
//大学生类
class ColStu extends Student{
    //交费
    public void pay(float fee)
    {
        this.fee = fee*0.1f;
    }
}

继承的语法

class  子类  extends  父类 ;
//这样子类就会自动拥有父类定义的某些属性和方法，有些东西是继承不了的

深入探讨——父类的哪些属性（变量）、方法被子类继承了

父类: 
{
	public int a;
	protected int b;
	int c;
	private int d;

	public int getA(){}
	protected int getB(){}
	int getC(){}
	private int getD(){}	
}
    ————————————继承————————————
子类: 
{
	public int a;
	protected int b;
	int c;

	public int getA(){}
	protected int getB(){}
	int getC(){}
}

　　可以看出只有private修饰符的属性和方法不能被子类继承，所以不希望子类继承的属性和方法，只需要把那个属性和方法设置为private属性即可

继承的注意事项

1. 子类最多只能继承一个父类（指直接继承），可以通过接口进行多重继承 ，之后会讲
2. java所有类都是Object类的子类
3. JDK6中有202个包，3777个类、接口、异常、枚举、注释和错误，掌握150个就是大神了
4. 在做开发的时候，强烈建议大家多查jdk帮助文档，还是不会就google

import javax.swing.*;
public class Demo2 extends JFrame {

    public static void main(String[] args) {
        Demo2 demo2 = new Demo2();
        

    }
    public Demo2()
    {
        this.setVisible(true);
        this.setSize(200 , 200);
    }

}

如果不使用继承的话，需要调用一些复杂的命令

方法重载

在多态前要先了解一下方法重载（overload）和方法覆盖（override）

思考一下：编写一个名为Abc的类，能返回两个整数中较大的一个

• 若果是接收两个float型的数，返回较大数
• 如果是接收散了int型的数，返回最大数

public class Demo3 {
    public static void main(String[] args) {
        Abc test1 = new Abc();
        System.out.println(test1.getMax(23, 78));
    }

}

class Abc
{
    public int getMax(int i,int j)
    {
        if(i>j)
        {
            return i;
        }
        else
        {
            return j;
        }
    }
}

public class Demo3 {
    public static void main(String[] args) {
        Abc test1 = new Abc();
        Abc test2 = new Abc();
        System.out.println(test1.getMax(23, 78));
        System.out.println(test1.getMaxFloat(9.8f, 12.2f));
    }

}

class Abc
{
    public int getMax(int i,int j)
    {
        if(i>j)
        {
            return i;
        }
        else
        {
            return j;
        }
    }
    public float getMaxFloat(float a,float b)
    {
        if(a>b)
        {
            return a;
        }
        else
        {
            return b;
        }
    }
}

可以看出我们是又专门加一个，比较小数的成员方法，有没有方法用一个方法来进行比较呢？

这个时候有可以利用方法重载的特性——可以定义重名的两个成员方法，让编译器自己选择用哪个？

package com.xiaohui;
/*
 * 作者:我聊啊
 * 时间:2018.9.11
 * 功能:了解方法重载
 */
public class Demo3 {
    public static void main(String[] args) {
        Abc test1 = new Abc();
        Abc test2 = new Abc();
        System.out.println(test1.getMax(23, 78));
        System.out.println(test1.getMax(9.8f, 12.2f));
    }

}

class Abc
{
    public int getMax(int i,int j)
    {
        if(i>j)
        {
            return i;
        }
        else
        {
            return j;
        }
    }
    public float getMax(float a,float b)
    {
        if(a>b)
        {
            return a;
        }
        else
        {
            return b;
        }
    }
}

方法重载的概念

　　简单地说：方法重载就是在类的同一种功能的多种实现方式，到底使用哪种方式，取决于调用者给出的参数。

注意事项

1. 方法名一定相同
2. 方法的参数类型，个数，顺序至少有一项不同——（顺序：(int a , double b)改成(double a , int b)）
3. 返回类型也可以不相同，但是如果只有返回类型不一样，是不能够构重载的
4. 方法的访问控制修饰符可以不同，如果只是修饰符不同，也是不能够构成重载的

方法的覆盖（重写）

既然子类可以继承父类的属性和方法，这样可以提高代码的复用性，这个很好，可是问题来了！！

假设我要写三个类——猫、狗、猪，显然这三个都是动物，他们之间一定存在着相同的特点。根据类的抽象特征，我们可以把他们的相同点提取出来，形成一个父类Animal，然后继承。

但是问题来了，动物都会叫，但是叫声是不一样的，怎样解决子类和父类方法的异同！

这是就体现出了方法覆盖（重写）的特性了

public class Demo4 
{
    public static void main(String[] args) {
    Cat cat1 = new Cat();
    cat1.cry();
    
    Dog dog1 = new Dog();
    dog1.cry();
    }

}

class Animal
{
    int age;
    String name;
    //动物都会叫
    public void cry()
    {
        System.out.println("我是动物,不知道怎么叫");
    }
}
class Cat extends Animal
{
    //覆盖了父类的方法
    public void cry()
    {
        System.out.println("喵喵喵");
    }
}

class Dog extends Animal
{
    //覆盖了父类的方法
    public void cry()
    {
        System.out.println("汪汪汪");
    }
}

方法重写的核心思想：子类的某些方法和父类不一样，需要覆盖掉父类的方法

方法覆盖的概念

简单的说：方法覆盖就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法覆盖了父类的那个方法。

注意事项

1. 子类的方法的返回类型，参数，方法名称要和父类方法的返回类型完全一致，否则编译会出错
2. 子类方法不能缩小父类方法的访问权限，换句话说子类的权限可以比父类高

多态

所谓多态，就是指一个引用（类型）在不同情况下的多种状态。也可以这样理解：多态是指通过指向父类的指针，来调用在不同子类中实现的方法

案例

public class Demo6 
{
    public static void main(String[] args) 
    {
        //多态
        Animal an;//创建了一个Animal类引用变量,Animal类引用就是以后可以用来指向Animal对象的对象引用
        an =new Cat();    //让这个动物的引用指向了猫这个实例(对象)
        an.cry();
        an = new Dog();
        //以Dog类为模板,在堆空间里创建一个Dog类对象,简称为Dog对象
        an.cry();
        //an这个引用会自动判断引用是那种类型的
    }
}
//动物类
class Animal
{
    String name;
    int age;
    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 void cry()
    {
        System.out.println("不知道怎么叫");
    }
    
}
class Cat extends Animal
{
    //猫自己叫
    public void cry()
    {
        System.out.println("喵喵喵");
    }
}
class Dog extends Animal
{
    //狗自己叫
    public void cry()
    {
        System.out.println("汪汪汪");
    }
}

输出结果:
喵喵喵
汪汪汪

　　如果没有这个特性，狗要叫就要创建一个狗的引用，猫要叫就要创建一个猫的引用，动物再多一点就会不方便管理。当然多态也能调用孙子类的方法。

 

package com.xiaohui;

public class Demo7 
{
    public static void main(String[] args) 
    {
        Master master = new Master();
        master.feed(new Dog(), new Bone());
        master.feed(new Cat(),new Fish());
        //我想要他喂那种动物就喂那种懂我,我想喂他吃什么就吃什么
        //
    }

}
//主人类
class Master
{
    //给动物喂食物,使用多态,方法就可以用一个
    public void feed(Animal an,Food f)
    {
        an.eat();
        f.showName();
    }
}

class Food
{
    String name;
    public void showName()
    {
        
    }
}
class Fish extends Food
{
    public void showName()
    {
        System.out.println("鱼");
    }
}
class Bone extends Food
{
    public void showName()
    {
        System.out.println("骨头");
    }
}
//动物类
class Animal
{
    String name;
    int age;
    //动物会吃
    public void  eat()
    {
        System.out.println("不知道吃什么");
    }
}

class Cat extends Animal
{
    //猫进食
    public void eat()
    {
        System.out.println("猫爱吃鱼");
    }
}

class Dog extends Animal
{
    //狗进食
    public void eat()
    {
        System.out.println("狗爱吃骨头");
    }
}

　　如果Food类和Animal类下的子类有许多的话，Master类中的方法是无需改变的，只需要输入对应的动物和事物就可以了。否则我们想要狗吃骨头和猫吃鱼就要用这么多的代码来写

                Dog dog1 = new Dog();
		dog1.eat();
		Bone bone1 = new Bone();
		bone1.showName();

		Cat cat1 = new Cat();
		cat1.eat();
		Fish fish1 = new Fish();
		fish1.showName();    

引用的注意事项：

1. Java允许父类的引用变量引用它的子类的对象（对象）
   

   Animal animal = new Cat()
   

   这种转换是自动完成的　　

2. 类型转换还有一些具体的细节要求,之后会进一步学医，比如子类能不能转换成父类，有什么要求等等...