java类、对象、方法
资料来源于视频课程和其他收集,个人整理,如有侵权请联系。
1.类
类是对象的抽象表示,比如中华田园犬是属于犬类。
属性是对象的特征,比如狗的毛色就是狗的属性。
方法是对象的功能,比如狗会叫,叫就是方法。
下面的程序定义一个人类:
public class People {
//属性(成员变量) 有什么
double height; //身高
int age; //年龄
int sex; //性别,0为男性,非0为女性
//方法 干什么
void cry(){
System.out.println("我在哭!");
}
void laugh(){
System.out.println("我在笑!");
}
void printBaseMes(){
System.out.println("我的身高是"+height+"cm");
System.out.println("我的年龄是"+age+"岁");
if(this.sex==0)
System.out.println("我是男性!");
else
System.out.println("我是女性!");
}
}
一个类可以包含以下类型变量:
• 局部变量:在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中,方法结束后,变量就会自动销毁。
• 成员变量:成员变量是定义在类中,方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
• 类变量:也叫静态变量,类变量也声明在类中,方法体之外,但必须声明为 static 类型。
2.对象
创建对象的语法如下:
类名 对象名 = new 类名();
实例化xiaoming这个人:
People xiaoming = new People();
定义类的时候不会为类开辟内存空间,但是一旦创建了对象,系统就会在内存中为对象开辟一块空间,用来存放对象的属性值和方法。
下面调用people类创建并使用对象:
public class NewObject {
public static void main(String[] args) {
People xaioming = new People(); //创建一个People对象xiaoming
xiaoming.height =170; //给成员变量赋值。
xiaoming.age = 20;
xiaoming.sex = 1;
xiaoming.printBaseMes();
}
}
注意:成员变量和局部变量同名时,局部变量具有更高的优先级。
3.构造方法
每个类都有构造方法,在创建该类的对象的时候他们将被调用,如果没有定义构造方法,Java 编译器会提供一个默认构造方法。 创建一个对象的时候,至少调用一个构造方法。比如在新建一个对象new Object(),括号中没有任何参数,代表调用一个无参构造方法(默认构造方法就是一个无参构造方法)。构造方法的名称必须与类名相同,一个类可以定义多个构造方法。
构造方法的具体内容:
1、构造方法的名称与类名相同,且没有返回值。它的语法格式如下:
//与类同名,可以指定参数,没有返回值
public 构造方法名(){
//初始化代码
}
下面是一个构造方法的例子:
public class People{
//无参构造方法
public People(){
}
//有一个参数的构造方法
public People(int age){
}
}
又例如具体的构造方法:
public class People {
//属性(成员变量)有什么
double height; //身高
int age; //年龄
int sex; //性别,0为男性,非0为女性
//构造函数,初始化了所有属性
public People(double h, int a, int s){
height = h;
age = a;
sex = s;
}
}
//创建对象,调用我们自己定义的有参构造方法
People XiaoMing = new People(168, 21, 1);
上面的例子中通过new关键字将类实例化成对象,而new后面跟的就是构造方法。于是可以知道new + 构造方法可以创建一个新的对象。
2、如果在定义类的时候没有写构造方法,系统会默认生成一个无参构造方法,这个构造方法什么也不会做。
3、当有指定的构造方法时,系统都不会再添加无参构造方法了。
4、构造方法的重载:方法名相同,但参数不同的多个方法,调用时会自动根据不同的参数选择相应的方法。
4、对象实例其实是一个类的引用
在新建对象实例时,需要为对象实例设置一个对象名,如下
Object object=new Object();
这里其实只是创建了一个 object 对象的引用,就像c语言的指针,变量 object 保存的其实 Object 对象的引用,指向了 Object 对象。
例:
Object object1=new Object();
Object object2=object1;
System.out.println(object1==object2);
运行得到的结果为 true,说明 object1 和 object2 的地址相同(==会比较两个对象的地址是否相同),它们实际上是引用同一对象,如果改变 object1 对象内部的属性,那么 object2 的属性同样会改变。
5、static
Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有,而不是某个对象所有,即被类的所有对象所共享。静态成员可以使用类名直接访问,也可以使用对象名进行访问。
如:
public class StaticTest{
public static String string="shiyanlou";
public static void main(String[] args){
//静态成员不需要实例化 直接就可以访问
System.out.println(StaticTest.string);
//如果不加static关键字 需要这样访问
StaticTest staticTest=new StaticTest();
System.out.println(staticTest.string);
//如果加上static关键字,上面的两种方法都可以使用
}
}
静态方法:
被 static 修饰的方法是静态方法,静态方法不依赖于对象,不需要将类实例化便可以调用,由于不实例化也可以调用,所以不能有 this,也不能访问非静态成员变量和非静态方法。但是非静态成员变量和非静态方法可以访问静态方法。
6.final
final关键字可以修饰类、方法、属性和变量
- final 修饰类,则该类不允许被继承,为最终类
- final 修饰方法,则该方法不允许被覆盖(重写)
- final 修饰属性:则该类的属性不会进行隐式的初始化(类的初始化属性必须有值)或在构造方法中赋值(但只能选其一)
- final 修饰变量,则该变量的值只能赋一次值,即常量
如:
//静态常量
public final static String SHI_YAN_LOU=“shiyanlou”;
7、权限修饰符
代码中经常用到private和public修饰符,权限修饰符可以用来修饰属性和方法的访问范围。
如图所示,代表了不同的访问修饰符的访问范围,比如private修饰的属性或者方法,只能在当前类中访问或者使用。默认是什么修饰符都不加,默认在当前类中和同一包下都可以访问和使用。protected修饰的属性或者方法,对同一包内的类和所有子类可见。public修饰的属性或者方法,对所有类可见。
8、封装
即隐藏对象的属性和实现细节,仅对外公开接口,控制在程序中属性的读和修改的访问级别
如何实现封装:
- 修改属性的可见性,在属性的前面添加修饰符(private)
- 对每个值属性提供对外的公共方法访问,如创建 getter/setter(取值和赋值) 方法,用于对私有属性的访问
- 在 getter/setter 方法里加入属性的控制语句,例如我们可以加一个判断语句,对于非法输入给予否定。
public class People {
//属性(成员变量)有什么,前面添加了访问修饰符private
//变成了私有属性,必须通过方法调用
private double height; //身高
//属性已经封装好了,如果用户需要调用属性
//必须用getter和setter方法进行调用
//getter和setter方法需要程序员自己定义
public double getHeight(){
//getter 方法命名是get关键字加属性名(属性名首字母大写)
//getter 方法一般是为了得到属性值
return height;
}
//同理设置我们的setter方法
//setter 方法命名是set关键字加属性名(首字母大写)
//setter 方法一般是给属性值赋值,所以有一个参数
public void setHeight(double newHeight){
height = newHeight;
}
}
调用程序实例:
public class XiaoMing
{
public static void main(String[] args)
{
People xiaoming = new People();
xiaoming.setHeight(170.0);
System.out.println(xiaoming.getHeight());
}
}
9.this的使用
this关键字代表当前对象。使用this.属性操作当前对象的属性,this.方法调用当前对象的方法。
用private修饰的属性,必须定义 getter 和 setter 方法才可以访问到
如下:
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
创建好了 getter 和 setter 方法后,我们发现方法中参数名和属性名一样。
当成员变量和局部变量之间发生冲突时,在属性名前面添加了this关键字。 此时就代表将一个参数的值赋给当前对象的属性,同理this关键字可以调用当前对象的方法。
10.继承
(1)父类
public class Father {
private int money = 100; //私有
long mobile = 13999999999L;
public void hello() {
System.out.println("hello");
}
}
(2)子类
public class Son extends Father {
public void hi() {
//子类可以扩展自己的成员方法
System.out.println("hi~~~~~");
}
public static void main(String[] a) {
Son s = new Son();
System.out.println(s.mobile); //Son没有定义mobile, 而是通过父类继承的
//System.out.println(s.money); //error 父类的money是私有的,子类无法直接访问
s.hello(); //Son没有定义hellow方法, 而是通过父类继承的
s.hi(); //Son可以自定义自己的成员方法
}
}
如上程序,Son类是继承于Father类的,除了Father类的私有变量,Son类都可以使用,同时可以拓展自己的方法和属性。执行时两个类文件分开写,先运行父类再运行子类即可。
继承的特点:
• 子类拥有父类除 private 以外的所有属性和方法(可以通过
• 子类可以拥有自己的属性和方法
• 子类可以重写实现父类的方法
• Java 中的继承是单继承,一个类只有一个父类
注: Java 实现多继承的一个办法是 implements(实现)接口
11.方法的重载和重写
(1)重载
重载是指在一个类中定义多个同名的方法,但要求每个方法具有不同的参数的类型或参数的个数。方法重载一般用于创建一组任务相似但是参数不同的方法。
public class OverloadeTest
{
public static int add (int a, int b) {
return a + b;
}
public static double add (double a, double b) {
return a + b;
}
//方法名一样,参数不一样,也可以执行通过,叫做方法的重载。
public static void main (String [] args)
{
System.out.println(add (2,3));
System.out.println(add (1.5,2.5));
}
}
上面的程序首先定义了一个类OverloadeTest,再定义了两个方法名字都是add,这种情况叫方法的重载,还有一个main函数用来调用其他方法,方法可以互相调用,执行程序内容。
(2)重写
重写是指子类继承父类时可以对父类的方法进行修改,重写的方法一定要与原父类的方法语法保持一致,比如返回值类型,参数类型及个数,和方法名都必须一致。
例如:
public class Animal {
//类方法
public void bark() {
System.out.println("动物叫!");
}
}
public class Dog extends Animal {
//重写父类的bark方法
public void bark() {
System.out.println("汪!汪!汪!");
}
}
写个测试类来看看输出结果:
public class Test{
public static void main(String args[]){
Animal a = new Animal(); // Animal 对象
Dog d = new Dog(); // Dog 对象
Animal b = new Dog(); // Dog 对象,向上转型为Animal类型,具体会在后面的内容进行详解
a.bark();// 执行 Animal 类的方法
d.bark();//执行 Dog 类的方法
b.bark();//执行 Dog 类的方法
}
}
编译运行:
$ javac Test.java Dog.java Animal.java
$ java Test
动物叫!
汪!汪!汪!
汪!汪!汪!
12.对象直接定义在类内部
public class OOExample{
private int a; //本类的私有变量
public void setA(int a) //自定义方法
{
this.a = a;
}
public int add(int b) //自定义方法
{
return this.a + b;
}
public static void main(String[] a)
{
int b = 5;
OOExample obj = new OOExample(); //定义OOExample类的对象
obj.setA(10); //对象调用setA()方法
System.out.println(obj.add(b)); //对象调用add()方法
}
}
如上面的程序,obj就是对象,这个对象定义在类的内部可以调用类之中的所有方法。
13.super
super关键字在子类内部使用,代表父类对象。
- 访问父类的属性 super.属性名
- 访问父类的方法 super.bark()
- 子类构造方法需要调用父类的构造方法时,在子类的构造方法体里最前面的位置:super()
14.向上转型
假设Animal类是父类,Dog类是子类。
Animal a = new Animal(); //a是父类的引用指向的是本类的对象
Animal b = new Dog(); //b是父类的引用指向的是子类的对象
由于 Dog 继承于 Animal,所以 Dog 可以自动向上转型为 Animal,所以 b 是可以指向 Dog 实例对象的。如果定义了一个指向子类对象的父类引用类型,那么它除了能够引用父类中定义的所有属性和方法外,还可以使用子类强大的功能(指的是子类重写的父类方法)。但是对于只存在于子类的方法和属性就不能获取。
class Animal {
//父类方法
public void bark() {
System.out.println("动物叫!");
}
}
class Dog extends Animal {
//子类重写父类的bark方法
public void bark() {
System.out.println("汪、汪、汪!");
}
//子类自己的方法
public void dogType() {
System.out.println("这是什么品种的狗?");
}
}
public class Test {
public static void main(String[] args) {
Animal a = new Animal();
Animal b = new Dog();
Dog d = new Dog();
a.bark();
b.bark();
//b.dogType();
//b.dogType()编译不通过
d.bark();
d.dogType();
}
}
编译运行:
$ javac Test.java
$ java Test
动物叫!
汪、汪、汪!
汪、汪、汪!
这是什么品种的狗?
在这里,由于 b 是父类的引用,指向子类的对象,因此不能获取子类的方法(dogType()方法),同时当调用 bark()方法时,由于子类重写了父类的 bark()方法,所以调用子类中的 bark()方法。
因此,向上转型,在运行时,会遗忘子类对象中与父类对象中不同的方法,也会覆盖与父类中相同的方法——重写。(方法名,参数都相同)
15.抽象类
在定义类时,前面加上abstract关键字修饰的类叫抽象类。 抽象类中至少要有一个抽象方法,这种方法是不完整的,仅有声明而没有方法体。抽象方法声明语法如下:
abstract void f(); //f()方法时抽象方法
那我们什么时候会用到抽象类呢?
- 在某些情况下,某个父类只是知道其子类应该包含怎样的方法,但无法准确知道这些子类如何实现这些方法。也就是说抽象类是约束子类必须要实现哪些方法,而并不关注方法如何去实现。
- 从多个具有相同特征的类中抽象出一个抽象类,以这个抽象类作为子类的模板,从而避免了子类设计的随意性。
所以由上可知,抽象类是限制规定子类必须实现某些方法,但不关注实现细节。
那抽象类如何用代码实现呢,它的规则如下: - 用 abstract 修饰符定义抽象类
- 用 abstract 修饰符定义抽象方法,只用声明,不需要实现
- 包含抽象方法的类就是抽象类
- 抽象类中可以包含普通的方法,也可以没有抽象方法
- 抽象类的对象不能直接创建,通常是定义引用变量指向子类对象(即向上转型)。
父类:
public abstract class TelePhone{
public abstract void call(); //抽象方法
public abstract void message(); //抽象方法
}
子类:
public class CellPhone extends TelePhone {
@Override
public void call() {
System.out.println("我可以打电话!");
}
@Override
public void message() {
System.out.println("我可以发短信!");
}
public static void main(String[] args) {
TelePhone cp = new CellPhone(); //向上转型。
cp.call();
cp.message();
}
}
抽象类也是类,如果一个子类继承了抽象类,它就不能再继承于其他类,而且要实现父类抽象类的所有抽象方法。
16.接口
如果一个程序所有的方法都未实现,那么我们就可以把它定义为接口。我们为什么需要接口呢,因为接口可以实现多继承,这弥补了普通类单继承的不足,接口可以继承于其他接口,这样未实现方法就会叠加,子类继承了接口就要实现接口的所有方法。
// Animal.java
interface Animal {
//int x;
//编译错误,x需要初始化,因为是 static final 类型
int y = 5;
public void eat();
public void travel();
}
注意点:在Java8中
接口不能用于实例化对象
接口中方法只能是抽象方法、default 方法、静态方法
接口成员是 static final 类型
接口支持多继承
抽象类也可以实现接口,而且可以把接口的方法写成抽象方法而不实现它。
在Java9中,接口可以拥有私有方法和私有静态方法,但是只能被该接口中的 default 方法和静态方法使用。
多继承实现:
接口继承接口
修饰符 interface A extends 接口1,接口2{
}
类继承接口
修饰符 class A extends 类1 implements 接口1,接口2{
}
实现接口Animal
// Cat.java
public class Cat implements Animal{
public void eat(){
System.out.println("Cat eats");
}
public void travel(){
System.out.println("Cat travels");
}
public static void main(String[] args) {
Cat cat = new Cat();
cat.eat();
cat.travel();
}
}
17.内部类
内部类
将一个类的定义放在另一个类的定义内部,这就是内部类。而包含内部类的类被称为外部类。
内部类的主要作用如下:
- 内部类提供了更好的封装,可以把内部类隐藏在外部类之内,不允许同一个包中的其他类访问该类
- 内部类的方法可以直接访问外部类的所有数据,包括私有的数据
- 内部类所实现的功能使用外部类同样可以实现,只是有时使用内部类更方便
- 内部类允许继承多个非接口类型(具体将在以后的内容进行讲解)
注:内部类是一个编译时的概念,一旦编译成功,就会成为完全不同的两类。对于一个名为 outer 的外部类和其内部定义的名为 inner 的内部类。编译完成后出现 outer.class 和 outer$inner.class 两类。所以内部类的成员变量/方法名可以和外部类的相同。
成员内部类
// People.java
//外部类People
public class People {
private String name = "LiLei"; //外部类的私有属性
//内部类Student
public class Student {
String ID = "20151234"; //内部类的成员属性
//内部类的方法
public void stuInfo(){
System.out.println("访问外部类中的name:" + name);
System.out.println("访问内部类中的ID:" + ID);
}
}
//测试成员内部类
public static void main(String[] args) {
People a = new People(); //创建外部类对象,对象名为a
Student b = a.new Student(); //使用外部类对象创建内部类对象,对象名为b
// 或者为 People.Student b = a.new Student();
b.stuInfo(); //调用内部对象的suInfo方法
}
}
编译运行:
$ javac People.java $ java People
访问外部类中的name:LiLei
访问内部类中的ID:20151234
成员内部类的使用方法:
- Student 类相当于 People 类的一个成员变量,所以 Student 类可以使用任意访问修饰符
- Student 类在 People 类里,所以访问范围在类里的所有方法均可以访问 People 的属性(即内部类里可以直接访问外部类的方法和属性,反之不行)
- 定义成员内部类后,必须使用外部类对象来创建内部类对象,即 内部类 对象名 = 外部类对象.new 内部类();
- 如果外部类和内部类具有相同的成员变量或方法,内部类默认访问自己的成员变量或方法,如果要访问外部类的成员变量,可以使用 this 关键字 如上述代码中:a.this
注:成员内部类不能含有 static 的变量和方法,因为成员内部类需要先创建了外部类,才能创建它自己的。
静态内部类:
静态内部类通常被称为嵌套类。
// People.java
//外部类People
public class People {
private String name = "LiLei"; //外部类的私有属性
/*外部类的静态变量。
Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有,而不是某个对象所有,即被类的所有对象所共享。静态成员可以使用类名直接访问,也可以使用对象名进行访问。
*/
static String ID = "510xxx199X0724XXXX";
//静态内部类Student
public static class Student {
String ID = "20151234"; //内部类的成员属性
//内部类的方法
public void stuInfo(){
System.out.println("访问外部类中的name:" + (new People().name));
System.out.println("访问外部类中的ID:" + People.ID);
System.out.println("访问内部类中的ID:" + ID);
}
}
//测试成员内部类
public static void main(String[] args) {
Student b = new Student(); //直接创建内部类对象,对象名为b
b.stuInfo(); //调用内部对象的suInfo方法
}
}
编译运行:
$ javac People.java
$ java People
访问外部类中的name:LiLei
访问外部类中的ID:510xxx199X0724XXXX
访问内部类中的ID:20151234
静态内部类是 static 修饰的内部类,这种内部类的特点是:
- 静态内部类不能直接访问外部类的非静态成员,但可以通过 new 外部类().成员的方式访问
- 如果外部类的静态成员与内部类的成员名称相同,可通过类名.静态成员访问外部类的静态成员;如果外部类的静态成员与内部类的成员名称不相同,则可通过成员名直接调用外部类的静态成员
- 创建静态内部类的对象时,不需要外部类的对象,可以直接创建 内部类 对象名= new 内部类();
局部内部类:
局部内部类,是指内部类定义在方法和作用域内。
例如:
// People.java
//外部类People
public class People {
//定义在外部类中的方法内:
public void peopleInfo() {
final String sex = "man"; //外部类方法中的常量
class Student {
String ID = "20151234"; //内部类中的常量
public void print() {
System.out.println("访问外部类的方法中的常量sex:" + sex);
System.out.println("访问内部类中的变量ID:" + ID);
}
}
Student a = new Student(); //创建方法内部类的对象
a.print();//调用内部类的方法
}
//定义在外部类中的作用域内
public void peopleInfo2(boolean b) {
if(b){
final String sex = "man"; //外部类方法中的常量
class Student {
String ID = "20151234"; //内部类中的常量
public void print() {
System.out.println("访问外部类的方法中的常量sex:" + sex);
System.out.println("访问内部类中的变量ID:" + ID);
}
}
Student a = new Student(); //创建方法内部类的对象
a.print();//调用内部类的方法
}
}
//测试方法内部类
public static void main(String[] args) {
People b = new People(); //创建外部类的对象
System.out.println("定义在方法内:===========");
b.peopleInfo(); //调用外部类的方法
System.out.println("定义在作用域内:===========");
b.peopleInfo2(true);
}
}
编译运行:
$ javac People.java
$ java People
定义在方法内:===========
访问外部类的方法中的常量sex:man
访问内部类中的变量ID:20151234
定义在作用域内:===========
访问外部类的方法中的常量sex:man
访问内部类中的变量ID:20151234
局部内部类也像别的类一样进行编译,但只是作用域不同而已,只在该方法或条件的作用域内才能使用,退出这些作用域后无法引用的。
18.package
为了更好地组织类,Java 提供了包机制,用于区别类名的命名空间。
包的作用
• 把功能相似或相关的类或接口组织在同一个包中,方便类的查找和使用。
• 包采用了树形目录的存储方式。同一个包中的类名字是不同的,不同的包中的类的名字是可以相同的,当同时调用两个不同包中相同类名的类时,应该加上包名加以区别。
• 包也限定了访问权限,拥有包访问权限的类才能访问某个包中的类。
定义包语法:
package 包名
//注意:必须放在源程序的第一行,包名可用"."号隔开
例如:
//在定义文件夹的时候利用"/"来区分层次
//包中用"."来分层
package com.shiyanlou.java
不仅是我们这样利用包名来区分类,系统也是这样做的。
如何在不同包中使用另一个包中的类?
使用import关键字。比如要导入包com.shiyanlou下People这个类,import com.shiyanlou.People。同时如果import com.shiyanlou.*这是将包下的所有文件都导入进来,*是通配符。
包的命名规范是全小写字母拼写。