类与对象
类定义一种全新的数据类型，包含一组变量和函数；
对象是类这种类型对应的实例。
比如类相当于人类这个概念，而对象指的是人类中的每个人都是这个类中的一个对象；
源文件声明规律
1.一个源文件只能有一个public类，即public class；
2.public类型的名称必须和文件名的名称一致；
3.一个源文件可以有多个非public类，如private class；
4.每个源文件中，先写package语句，再写import语句，最后定义类；
package tmp.pet.dog;
import java.util.Scanner;
public class test1{
}
5.package是在设定软件包之后，对于本文件大致软件包路径的声明；
//本文件的位置在tmp软件包里的pet软件包里的dog软件包里;
package tmp.pet.dog;
类的定义
其实类的定义也可以用来定义变量，用于划定变量的适用范围；
1.public
所有对象均可以访问；
2.private
只有本类可以访问；
以下代码用于区别public和private的区别
package tmp.pet.dog;
class h_w
{
public int h;
private int w;
}
public class Main
{
public static void main(String[] args)
{
h_w dog1 = new h_w();
dog1.h = 110;
dog1.w = 50;
System.out.println(h / w);
}
}
很显然，报错了，因为private只能在h_w这个类中使用；
3.protected
同一包或者子类中可以访问；
4.不添加修饰符（default）
在同一个包中可以访问；
5.静态（static）
由static定义的变量或函数被称之为成员变量或成员函数；
以下程序用来证明静态与普通的区别
class h_w
{
public static int h;
public int w;
}
public class Main
{
public static void main(String[] args)
{
h_w dog1 = new h_w() , dog2 = new h_w() , dog3 = new h_w();
dog1.h = 110;
dog1.w = 50;
System.out.printf("%d %d %d\n" , dog1.h , dog2.h , dog3.h);
System.out.printf("%d %d %d\n" , dog1.w , dog2.w , dog3.w);
}
}
打印出来的结果如下
110 110 110
50 0 0
他们之间的区别如下：
所有static成员变量/函数在类中只有一份，被所有类的对象共享；
所有普通成员变量/函数在类的每个对象中都有独立的一份；
静态函数中只能调用静态函数/变量；普通函数中既可以调用普通函数/变量，也可以调用静态函数/变量。
举个简单的例子理解；
被static修饰的，都是被写在黑板上的，所有人都可以看见；
而普通的，则是写在草稿纸上的，只有自己才能看见；
草稿纸上可以写自己的和黑板上的答案；
但是想在黑板上写答案，就不能直接把草稿纸贴上去；
例如，以下是类，输出输入的数字；
package tmp.pet.dog;
class Point {
private int x;
private int y;
//构造函数
public Point(int x, int y) {
this.x = x;//this.x是成员变量x,x是传进来的形参；
this.y = y;
}
public void setX(int x) {
this.x = x;
}
public void setY(int y) {
this.y = y;
}
public int getX() {
return x;
}
public int getY() {
return y;
}
public String toString() {
return String.format("(%d, %d)", x, y);
}
}
而引用该类的主函数如下
package tmp.pet;
import tmp.pet.dog.Point;
public class Main
{
public static void main(String[] args)
{
Point[] p = new Point(3 , 4);
System.out.println(p[0].toString());
}
}
打印结果为
(3,4)
继承
举个例子理解一下概念；
就拿gta路上的npc来说，我总不可能每个人设置一套专门的动作模组，我肯定是套用一套动作模组，然后换衣服颜色就行了；
继承也是父类与子类的产生过程；
用以下代码来讲解,我们继承的是上面的tmp.pet.dog.Point来设计颜色部分;
package tmp.pet.dog;
class ColorPoint extends Point //extends + 继承的类名
{
private String color;
//构造函数
public ColorPoint(int x, int y, String color) {
super(x, y);//继承Point输入的x和y
this.color = color;
}
public void setColor(String color) {
this.color = color;
}
public String toString() {//如果父类和子类有同一名字同一类型的函数，优先使用子类；
//因为父类的x和y是private，所以这里需要用super声明一下API——super.getX()；
return String.format("(%d, %d, %s)", super.getX(), super.getY(), this.color);
}
}
类的多态
还是引用了的Point和ColorPoint的主函数
package tmp.pet;
import tmp.pet.dog.Point;
import tmp.pet.dog.ColorPoint;
public class Main {
public static void main(String[] args) {
Point point = new Point(3, 4);
Point colorPoint = new ColorPoint(1, 2, "red");
// 多态，同一个类的实例，调用相同的函数，运行结果不同
System.out.println(point.toString());
System.out.println(colorPoint.toString());
}
}