一.OOP
Java是一个面向对象程序设计(Object Oriented Programming,OOP)的语言
二.变量
1.成员:
-
成员变量:独立于方法之外的变量,作用域是从对象开始创建到销毁
-
成员函数:非构造函数外的类内部的函数
//参数确定
和C语言类似
//参数不确定
public int test6(int ... counts){
int sum = 0;
for (int i = 0; i < counts.length; i++) {
sum += counts[i];
}
return sum;
}
2.变量类型:
-
类变量:独立于方法之外的变量,用 static 修饰。
-
实例变量:独立于方法之外的变量,不过没有 static 修饰。
-
局部变量:类的方法中的变量。
3.构造方法:
-
创建类的一个对象的时候,就会被调用的方法(就是初始化方法,相当于oc的init)。
-
每个类会默认提供一个构造方法,没有返回值,名字是类名
public 类名(){}
。 -
构造方法的重载,重新写一个有参数的构造方法,在对象创建的时候,希望给属性赋值;或者希望在对象创建的时候做一点事情。
//类的默认构造方法
public Poker() {
System.out.println("构造方法");
}
//构造方法的重载 自定义一个有参数的构造方法
//通常给一个属性赋值,形参名尽量与属性名一致
//方法里面的变量以及参数的作用域就在这个方法里面,出了方法就没有了
public Poker(String number,String color) {
this.number = number;
this.color = color;
System.out.println("自定义的构造方法");
}
4.匿名对象:
- 尽量少使用匿名对象,当做参数时,适合使用
//new String[]{"请输入玩家人数:"}就是匿名对象
Utils.log(false,false,new String[]{"请输入玩家人数:"});
三.类和对象
1. 类
- 抽象的,不存在的,用来描述同一类事物
- 具有共同的方法和属性,不能完成具体的事情
- 同一个方法可以有多个对象,每个对象的内存空间都是独立的(对象之间没有任何关系)
- 定义一个类(类名必须大写),通常情况下一个文件对应一个类
修饰符 class 类名{
这个类的一些属性:成员变量
这个类的功能:方法
}
明确
存什么值:成员变量
完成什么功能:方法
2. 对象
- 对象都是new出来的,有内存空间
- 具体的,实际存在的,某一类的实例化,可以完成具体的事情
3. 实例方法的调用
- 首先思考调用谁的(哪个对象)方法
- 在类里面可以直接调用自己的方法
- 在外部必须通过对象来调用
4. 给对象属性赋值的方式
- 对于public,protected,default修饰的属性,使用对象直接用
.
调用。 - 对于private修饰的属性 不能直接调用,只能用 setter/getter方法间接调用。
- 给外部提供一个setter方法,通过这个方法给某个变量赋值;可以对外部给的值产生控制。
- 给外部提供一个get方法,通过这个方法访问某个变量;可以把给外部的值加密等其它操作。
5. 什么时候需要使用this
- 需要明确指定调用的是这个对象自己的一些属性和方法
public Poker(String number,String color) {
this.number = number;
this.color = color;
System.out.println("自定义的构造方法");
}
- 某一个方法里面调用this,this指的是调用这个方法的对象
public void setColor(String color) {
this.color = color;
}
Poker poker = new Poker();
poker.setColor("♥");
这里的this就是poker对象
6. 重写类的toString方法
- 所有的类都是直接或者间接继承于Object,Object有一个方法:
toString
,用来打印对象。
public String toString() {
return this.getClass().getName() + "@" + Integer.toHexString(this.hashCode());
}
- 我们测试的时候可以在我们的类中重写
toString
用来打印我们想要的对象的内容。
@Override
public String toString() {
return "CivilServant{" +
"salary=" + salary +
", count=" + count +
", name='" + name + '\'' +
", age=" + age +
'}';
}
7.声明一个对象和实例化一个对象
-
声明一个对象,并不会分配一个完整的对象所需要的内存空间,只是将对象名所代表的变量看成是一个引用变量,并为它分配所需内存空间,它所占用的空间远远小于一个类的对象所需要的空间。
-
用new创建一个新对象,即为实例化。实例化的过程就是为对象分配内存空间的过程,此时,对象才成为类的实例。new所执行的具体操作是调用相应类中的构造方法(包括祖先类的构造方法),来完成内存分配以及变量的初始化工作,然后将分配的内存地址返回给所定义的变量。
四.面向对象的三大特性
封装Encapsulation
1.概念:将类的某些信息隐藏在类的内部,不允许外部程序直接访问,而是通过该类提供的方法来对隐藏的信息进行操作和访问。
2.好处:1.只能通过规定的方法访问数据;2.隐藏类的实例细节,方便修改和实现。
3.实现步骤:修改属性的可见性为private,创建getter/setter方法,用于访问数据,也可以在其中加入属性控制语句。
package swu.xl.day3.base;
public class Poker {
private String number;
private String color;
public String getNumber(){
return number;
}
public void setNumber(String number){
this.number = number;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
}
继承
1.概念:继承就是子类继承父类的特征和行为,使得子类对象具有父类的属性和方法。
2.继承的特性:
- 子类拥有父类非private的属性,方法。
- 子类可以拥有自己的属性和方法,可以对父类进行扩展。
- 子类可以用自己的方式实现父类的方法。
- Java的继承是单继承,可以多重继承,不可以单继承。
3.继承的关键字:
-
继承可以使用
extends
和implements
这两个关键字来实现继承,而且所有的类都是继承于java.lang.Object
,当一个类没有继承的两个关键字,则默认继承object(这个类在 java.lang 包中,所以不需要 import)祖先类 -
extends的使用
在 Java 中,类的继承是单一继承,也就是说,一个子类只能拥有一个父类,所以 extends 只能继承一个类
public class Animal {
private String name;
private int id;
public Animal(String myName, String myid) {
//初始化属性值
}
public void eat() { //吃东西方法的具体实现 }
public void sleep() { //睡觉方法的具体实现 }
}
public class Penguin extends Animal{
}
-
implements的使用
使用 implements 关键字可以变相的使java具有多继承的特性,使用范围为类继承接口的情况,可以同时继承多个接口
public interface A {
public void eat();
public void sleep();
}
public interface B {
public void show();
}
public class C implements A,B {
}
4.super和this关键字
-
super关键字:我们可以通过super关键字来实现对父类成员的访问,用来引用当前对象的父类。
-
this关键字:指向自己的引用。
调用super对应方法的情况:
如果一个方法需要完成一个功能,又不能单独完成,必须要父类完成相应的工作
1.父类做完之后,子类再操作
2.子类做点事后,再调用父类完成
class Animal {
void eat() {
System.out.println("animal : eat");
}
}
class Dog extends Animal {
void eat() {
System.out.println("dog : eat");
}
void eatTest() {
this.eat(); // this 调用自己的方法
super.eat(); // super 调用父类方法
}
}
public class Test {
public static void main(String[] args) {
Animal a = new Animal();
a.eat();
Dog d = new Dog();
d.eatTest();
}
}
5.构造器:
-
子类是不继承父类的构造器(构造方法或者构造函数)的,它只是调用(隐式或显式)。
-
如果父类的构造器带有参数,则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。
-
如果父类构造器没有参数,则在子类的构造器中不需要使用 super 关键字调用父类构造器,系统会自动调用父类的无参构造器。
-
如果父类的构造器既有带有参数,又有不带参数的,可以不显示的调用父类构造器
class SuperClass {
private int n;
public SuperClass(){
System.out.println("SuperClass()");
}
public SuperClass(int n) {
System.out.println("SuperClass(int n)");
this.n = n;
}
}
class SubClass extends SuperClass{
private int n;
public SubClass(){ // 自动调用父类的无参数构造器
System.out.println("SubClass");
}
public SubClass(int n){
super(300); // 调用父类中带有参数的构造器
System.out.println("SubClass(int n):"+n);
this.n = n;
}
}
//判断某个对象是不是某个类
对象 instanceof 类
多态polymorphic
1.两种表现形式:
- 同一个方法在不同的子类中有不同的实现(子类继承父类后可以重写继承到的方法)
- 如果有继承关系,子类的对象可以使用父类变量接受(类型的自动向上转换)
2.注意:
当使用多态方式调用方法时,首先检查父类中是否有该方法,如果没有,则编译错误;如果有,再去调用子类的同名方法。
3.多态的实现方式:
- 重写
- 接口
- 抽象类和抽象方法
网友评论