一.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.多态的实现方式：
- 重写
- 接口
- 抽象类和抽象方法
