目录
前言:
所谓面向对象它是针对于面向过程来说的,面向过程是在意执行的流程。而面向对象在意的功能。将一系列的过程封装到一个容器中,我们通过操作这个容器即以对象的方式来进行操作就是面向对象。在面向对象中,会涉及到类和对象的概念。类是一类事物的总称,它是看不见摸不着的。如:空气、人。它们都看不见,也摸不着,但是又真实存在。 对象是看得见摸得着的,它是类的一个具体的实例。一个类可以创建多个实例对象。
一、类
1.1 如何创建类
创建类分为以下三步:
-
第一步:给类取个名称
-
第二步:给类指定属性(类的特征)
-
第三步:给类指定行为(动作,也叫方法)
示例:我们定义一个人的类,它有身高、体重、性别、年龄等;同时它也具有吃、跑、走等行为。
/**
* 示例:我们定义一个人的类,它有身高、体重、性别、年龄等;同时它也具有吃、跑、走等行为。
*
* 类的名称叫:Person,它的定义是首字母大小,其他字母小写。如果有多个单词,每个单词的首字母大写如:UserName。类是需要被 class 关键字修改的
*
* 属性的定义格式:
* 属性的类型 属性名称;
*
* 方法的定义格式:
* 访问的访问修饰符 方法的返回值类型 方法名称(参数列表) {
* 方法体;
* [return 返回值]
* }
*
* 访问的访问修饰符:在 Java 中访问修饰符有以下几种:
* 1. public,它表示是公共的,所有的类都可以访问,包括互联网。
* 2. protected,它表示是受保护的,只当前类或其子类才可以访问
* 3. default,它表示是默认的,只当前类及当前类所在包中的类可以访问,default 不写
* 4. private,它表示是私有的,只有当前类可以使用
*
* void 关键字:它表示方法没有返回值。如果一个方法的返回值是 void ,那么这个方法就没有返回值,但是我们可以在方法的最后书写 return 语句,但是 return 关键字不能有内容。
* 如果方法的返回值类型不是 void , 而是其它类型,则方法中必须要有 return 语句,而 return 返回的值的类型必须是方法要求返回的类型。
*
* 方法名称的定义方式:单词小写,如果由多个单词组成,则第一个单词的首字母小写,其余单词的首字母大写,如:userName(),在方法名称后面必须要有一对小圆括号。
* 方法体就在一对大括号之间。
*
* 方法还可以传参数,它的格式为:
* 参数类型 参数名称
*
*
*/
public class Person {
float height; // 身高
float weight; // 体重
String gender; // 性别
int age; // 年龄
public void speak() {
System.out.println("身高: " + height + ", 体重:" + weight + ", 性别: " + gender + ", 年龄:" + age);
//return null; // 报错
return;
}
public int getAge() {
return age;
}
// 带有参数的方法,如果参数有多个,则使用逗号进行分隔
public void say(String str) {
System.out.println(str);
}
}
1.2 如何使用类
类定义好后,目的是为了使用这个类。而要使用这个类,就必须通过 new 关键字来进行实例化。这个过程叫创建对象。
使用类的格式为:
类名称 引用名称 = new 类名称();
示例:我们创建Person对象
/**
* 代码解析:
* 1. Person person = new Person(); 表示创建一个名称叫 person 的对象,它的类型是 Person。要使用对象之前必须创建对象
* 2. 通过点(.)操作来给创建好的对象赋值以及调用对象的方法。
*/
public class PersonDemo {
public static void main(String[] args) {
// 1. 创建对象
Person person = new Person();
// 2. 给对象中的属性赋值
person.height = 185.1f;
person.weight = 125.5f;
person.gender = "男";
person.age = 18;
person.speak();
//System.out.println(person);
}
}
补充:在类中定义的属性与变量的区别:
-
定义的位置不同:属性是定义在类中,而变量是定义在方法中的。
-
在内存中的位置不同:属性是在堆中的,而变量是在栈中。
-
声明的周期不同:属性是在对象创建是放到堆中的且会随着对象的消失而消失,而变量是在栈中且方法执行后就消失。
-
初始化不同:属性是在对象创建时初始化,而变量是在定义时就初始化。
二、方法
2.1 构造方法
在一个类中,如果方法的名称和类名称相同,并且这个方法没有返回值类型,则该方法就叫构造方法(也叫构造函数,还叫构造器) 。
class Human {
String name;
private int age;
public Human(){
}
public Human(String n, int a) {
name = n;
age = a;
}
// 它是一个普通方法,不是构造器
public void human() {
}
}
2.1.1 构造器的作用
就是给对象中的属性进行初始化
为了在创建对象的同时就给这个对象进行赋值,如果没有构造器,我们需要先把这个对象创建好后,再给对象中的属性进行赋值。虽然在没有定义构造器时,系统也会给我们一个默认的无参数的构造器,但这个构造器只能根据类中属性的类型来进行默认值的赋予,而达不到我们指定值赋予。
2.1.2 如何编写构造器
只需要在类中声明方法的名称与类名称相同,并且这个方法没有返回值类型即可,构造器可重载。
class Human {
String name;
private int age;
public Human(){
}
public Human(String n, int a) {
name = n;
age = a;
}
}
注意:在创建对象时已经使用到了构造器,创建对象是使用构造器完成的。
2.2 默认方法
在JDK1.8中的定义了默认方法,这个方法必须使用 default 关键字修饰,同时这个方法必须要实现。
// 默认方法
interface IntA {
default void sayHello() {
System.out.println("Hello");
}
default String eat(String s) {
return s;
}
}
public class InterfaceDemo2 implements IntA {
@Override
public void sayHello() {
System.out.println("hi");
}
public static void main(String[] args) {
InterfaceDemo2 id = new InterfaceDemo2();
System.out.println(id.eat("吃火锅"));
id.sayHello();
}
}
子类可以直接实例接口中定义默认方法而无须重写,当然我们也可以根据自己的需要来重写接口中的默认方法。
2.3 静态方法
在 JDK1.8 中还定义静态方法,它是使用 static 关键字来修饰的,它也必须是实现的方法。
// 静态方法
interface IfaceA {
static void print(String str) {
System.out.println(str);
}
static int getNum(int n) {
return n;
}
}
public class InterfaceDemo3 implements IfaceA {
public static void main(String[] args) {
InterfaceDemo3 id = new InterfaceDemo3();
//id.getNum(); // 报
System.out.println(IfaceA.getNum(10));
IfaceA.print("大家上午好!");
}
}
在接口中定义的静态方法,子类是不能使用的,它只能是接口自己使用。
补充:抽象方法我们放到后面单独拿出来和接口一起进行学习。
三、关键字
3.1 static关键字
如果希望类中的方法能够通过 类名.方法名()
的方式来进行访问,那么就需要使用 static 关键字来修饰这个方法。这个关键字必须放在方法返回值类型之前,访问修饰符之后(高版本中这名不成立)。
static String name;
private static int age;
public static int getAge() {
return age;
}
3.1.1 static关键字的使用要求
1,static关键字可以修改方法,也可以修改属性,但是不能修改变量
class Human {
static String name;
public static int getAge() {
//static int x = 5; // 报错,不能修改变量
return age;
}
}
2,static关键字修改的方法可以通过 类名.方法名()
来访问,修饰的属性可以通过 类名.属性名
来访问
class Human {
static String name;
public static int getAge() {
//static int x = 5;
return age;
}
}
public class HumanTest {
public static void main(String[] args) {
System.out.println(Human.getAge() + ", " + Human.name);
}
}
3,被static修改的方法叫类方法,被statis修饰的属性叫类属性,因此可以通过 类名.
的方式来使用
4,在static修饰的方法中不能使用非静态变量
class Human {
static String name;
private static int age;
String gender;
public static int getAge() {
gender = "男"; // 报错,静态方法中不能使用非静态的属性
return age;
}
}
不能使用的原因:因为被 static 修饰的方法和属性它们的生命周期与类的生命周期相同。而非静态的方法和属性的生命周期是在创建这个对象时才有的。换句话说:被 static 修饰的成员的生命周期要比非静态的成员的生命周期长。
3.2 super关键字
这个关键字是用于子类调用父类中的属性或方法的。
如果它是调用父类中的构造器方法,那么它必须是子类构造方法的第一句。
class Animal {
private String name;
private int age;
public Animal() {
}
public Animal(String n, int a) {
name = n;
age = a;
}
public void show() {
System.out.println(name + " " + age);
}
}
class Dog extends Animal {
private String color;
public Dog() {}
public Dog(String n, int a, String c) {
super(n, a); // 调用父类的构造方法
color = c;
}
public void show() {
System.out.println(color);
super.show();
}
}
public class AnimalDemo {
public static void main(String[] args) {
Dog d = new Dog("沙皮狗", 2, "黄色");
d.show();
}
}
3.3 this关键字
1)这个关键字可以调用本类中的构造方法,如果是调用本类中的构造方法,那么它也必须是第一行。
class Cat {
public String name;
public int age;
public String color;
public Cat() {
System.out.println("无参构造器被调用了。。。。。");
}
public Cat(String n) {
this();
System.out.println("这是有一个name的构造器被调用了......");
}
public Cat(String n, int a) {
this(n);
System.out.println("调用了name和age的构造器.....");
}
public Cat(String n, int a, String c) {
this(n, a);
System.out.println("这是调用了name、age以及color的构造器......");
}
public static void main(String[] args) {
Cat cat = new Cat("小花", 2, "白色");
}
}
注意:在调用本类构造器时,必须要有一个出口。
2)可以调用对象中的属性和方法
public void show() {
}
public void say() {
this.show();
}
//this指向被创建的对象引用
3.4 final关键字
final 关键字可以修饰类、属性和方法。
如果final修饰的是类,那么这个类就不能有子类,也就是说它不能被继承。
如果final修饰的是属性,那么这个属性就是常量,通常会和 static 关键字一起使用。
如果final修饰的是方法,那么这个方法就不能被重写。
final class Father {
static final String name;
/*Father(String name) {
this.name = name;
}*/
static {
name = "";
}
public final void sayHi() {
System.out.println(name);
}
}
class Son extends Father {
int age;
public Son() {
}
public Son(String name, int age) {
this.name = name;
this.age = age;
}
public void sayHi() {
super.sayHi();
System.out.println(age);
}
}
public class FinalDemo {
public static void main(String[] args) {
Son son = new Son("小华", 18);
son.sayHi();
}
}