typora-root-url: img

面向对象基础

1、类和对象

1.1：面向对象和面向过程的介绍

C：面向过程的编程语言

C++和java是面向对象的编程语言

1.2：类和对象的介绍

类是java编程中的基本单元；把具有相同行为和属性的事物归为一类；

对象是类的具体；

我们现实生活中，老师叫小明去扫地；而不是叫人类去扫地；

1.3：类的定义

通过class关键字定义一个类

语法：

作用域修饰符修饰类关键字类名{

//类体

}

1.4：对象的创建以及使用

对象创建的语法：

数据类型   对象名 = new  构造方法;

作用：通过对象调用该对象的属性和方法

1.5：对象内存图

单个对象内存图

演示案例：

Student.java

/*** 定义了一个学生类，该学生类有两个成员变量和一个成员方法* 分别是 name属性和age属性* 以及study方法*/
public class Student {String name;int age;public void study(){System.out.println("我爱学习,奥利给");}
}

TestStudent.java

/*** 测试学生类的测试类* 在里面对学生类进行操作*/
public class TestStudent {public static void main(String[] args) {Student s = new Student();System.out.println(s);System.out.println(s.name+"--------"+s.age);s.name = "小强";s.age=18;System.out.println(s.name+"--------"+s.age);s.study();}
}

双个对象内存图

Student.java

/*** 定义了一个学生类，该学生类有两个成员变量和一个成员方法* 分别是 name属性和age属性* 以及study方法*/
public class Student {String name;int age;public void study(){System.out.println("我爱学习,奥利给");}
}

TestStudent.java

/*** 测试学生类的测试类* 在里面对学生类进行操作*/
public class TestStudent {public static void main(String[] args) {Student s1 = new Student();System.out.println(s1);System.out.println(s1.name+"--------"+s1.age);s1.name = "小强";s1.age=18;System.out.println(s1.name+"--------"+s1.age);s1.study();Student s2 = new Student();System.out.println(s2);s2.name = "小马";s2.age=20;System.out.println(s2.name+"--------"+s2.age);s2.study();}
}

两个引用指向同一对象内存图

Student.java

/*** 定义了一个学生类，该学生类有两个成员变量和一个成员方法* 分别是 name属性和age属性* 以及study方法*/
public class Student {String name;int age;public void study(){System.out.println("我爱学习,奥利给");}
}

TestStudent.java

/*** 测试学生类的测试类* 在里面对学生类进行操作*/
public class TestStudent {public static void main(String[] args) {Student s1 = new Student();s1.name = "小强";Student s2 = s1;s2.name = "小马";System.out.println(s1.name+"--------"+s2.name);s1 = null;//System.out.println(s1.name);System.out.println(s2.name);s2=null;}
}

垃圾回收

==当堆内存中，对象或数组产生的地址，通过任何方式都不能被找到后，就会被判定为内存中的“垃圾”==

==垃圾会被Java垃圾回收器，空闲的时候自动进行清理==

2、成员变量和局部变量

成员变量：也就是全局变量也可以叫属性；

什么叫成员变量呢？定义在类体中，方法外的变量叫做成员变量也叫全局变量。

局部变量：定义在方法体内的变量；

3、作用域修饰符

package com.frank.rd;
public class A {public void aaa(){System.out.println("我是rd包下的类A");}
}

package com.frank.rd;
public class B {protected void bbb(){System.out.println("我是rd包下的类B");}
}

package com.frank.ko;
public class C {public void ccc(){System.out.println("我是ko包下的ccc方法");}
}

public class Test {public static void main(String[] args) {A a = new A();a.aaa();B b = new B();b.bbb();   // 此处报错，因为bbb方法是由protected修饰，类A和类B不在同一包下C c = new C();c.ccc();}
}

==值得注意的是==：protected不用于修饰外部类，因为外部类的上一单元是包，所以外部类只有两个作用域，分别是同包和任何位置；如果一个java文件的类被private修饰，其他的程序或是类是无法使用它的，那么他作为一个单独的文件就没啥用了。如果它作为单个文件运行，类加载也无法找到它，因为它对外不可见。同时，也失去了类的存在意义。

4、this关键字

this：代表所在类的对象引用；方法被哪个对象调用，this就代表哪个对象

案例：

Student.java

/*** 定义了一个学生类，该学生类有两个成员变量和对应给他们赋值，取值的方法* 分别是 name属性和age属性* 以及getName,getAge,setName,setAge方法*/
public class Student {String name;int age;public String getName() {return name;}public int getAge() {return age;}public void setName(String name) {this.name = name;}public void setAge(int age) {this.age = age;}
}

TestStudent.java

/*** 测试学生类的测试类* 在里面对学生类进行操作*/
public class TestStudent {public static void main(String[] args) {Student s1 = new Student();s1.setName("小马");Student s2 = new Student();s2.setName("小豪");}
}

5、构造方法

与类名同名的方法叫做构造方法

6、继承、封装、多态、抽象类

封装：隐藏实现细节，仅对外暴露公共的访问方式

将代码抽取到方法中，这是对代码的一种封装

将属性抽取到类当中，这是对数据的一种封装

封装常见的体现：

1、私有成员变量，提供setXxx和getXxx方法

2、将代码抽取到方法中，这是对代码的一种封装

3、将属性抽取到类当中，这是对数据的一种封装

封装的好处：

1、提高了代码的安全性

2、提高了代码的复用性

【掌握】：会使用private关键字进行封装，并能够访问封装的成员

6.1、封装的步骤

使用 private 关键字来修饰成员变量。

使用public修饰getter和setter方法。

class Student {//1. private修饰成员变量private String name;private int age;//2. public修饰getter和setter方法【Alt+Insert】//name的getter和setter方法public void setName(String name) {this.name = name;}public String getName() {return name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}
}

6.2:继承

继承就是一个类A继承了另一个类B的所有成员，并且能够访问使用那些==非私有成员==。假如多个类中存在相同属性和行为时，我们可以将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那一个类即可。因此继承的一个很重要的意义就是能够减少代码的冗余

继承的语法:

public class A{}
public class B extends A{ } // 基于A已有成分的基础上扩展出B这个子类

==注意==:

Java是单继承的，一个类只能继承一个直接父类。

操作案例：

需求：请使用继承定义以下类

学生类属性:姓名,年龄行为:吃饭,睡觉
老师类属性:姓名,年龄，薪水行为:吃饭,睡觉，教书

班主任属性:姓名,年龄，薪水行为:吃饭,睡觉，管理

//父类
class Human {//属性String name;int age;//行为public void eat() {System.out.println(name+"吃麻辣香锅~~~");}public void sleep() {System.out.println(name+"睡觉觉~~~");}
}

class Teacher extends Human {int salary;public void teaching() {System.out.println(name+"教java....");}
}

class Student extends Human {public void study() {System.out.println(name+"在认真的刻苦的学习Java~~");}}

public class Demo01 {public static void main(String[] args) {Student stu = new Student();//来自父类的属性和行为stu.name = "小马";stu.age = 20;stu.sleep();stu.eat();//调用子类自己的方法stu.study();System.out.println("===================");Teacher t = new Teacher();//来自父类的t.name = "老杨";t.age = 18;t.eat();t.sleep();//来自本类t.salary = 1;t.teaching();}
}

案例二：子类和父类中有同名的变量，该如何访问

public class Demo01 {public static void main(String[] args) {B b = new B();//使用子类对象调用成员System.out.println("b.num1 = " + b.num1);//100System.out.println("b.num2 = " + b.num2);//200//访问一个子类和父类都同时存在的一个成员变量//子类对象访问成员变量特点：就近先访问自身的成员变量，如果自身没有访问父类，如果父类没有报错。System.out.println("b.num3 = " + b.num3);//400b.show();//父类中私有的成分，需要借助getter、setter访问b.setNum4(10000);System.out.println("b.getNum4() = " + b.getNum4());}
}class A{int num1 = 100;int num3 = 300;//父类的成员变量private int num4;public int getNum4() {return num4;}public void setNum4(int num4) {this.num4 = num4;}
}class B extends A{int num2 = 200;int num3 = 400; //本类成员变量public void show() {int num3 = 500;//局部变量System.out.println(num3);//500  //局部变量System.out.println(this.num3);//400  本类的成员变量System.out.println(super.num3);//300   super:专门用于访问父类空间的关键字}}

方法重写

方法的重载：同一个类中存在同名不同参的方法

方法重写 ：当父类继承下来的方法不满足子类需要的时候，可以写一个和父类声明一样的方法，方法体中逻辑重新实现，这个子类重新定义的方法就是重写后的方法。重写后的方法会覆盖父类的功能，因此成为方法重写，方法的覆盖。

重写格式：当我们要重写父类的一个方法时，一般的做法就是定义一个声明一样的方法，方法体逻辑重写。简而意之，声明不变，重新实现

声明：修饰符 返回值类型 方法名 （参数列表） {方法体；}

注意事项：子类方法覆盖父类方法，必须要保证权限大于等于父类权限

问：继承关系中构造方法的执行先后问题？

父类静态代码 >子类静态代码 >父类构造方法 >子类构造方法

6.3、抽象类

一个类被abstract关键字修饰，那么这个类就是一个抽象类。一个抽象类可以含有或者不含有抽象方法。

抽象的含义是什么呢？抽象是一个隐藏实现细节并只向用户显示功能的过程。

我们可以将一个方法进行抽象，也可以将一个类进行抽象。

使用abstract 关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体。

定义格式：

修饰符 abstract 返回值类型 方法名 (参数列表);

代码举例：

public abstract void run();

如果一个类包含抽象方法，那么该类必须是抽象类。注意：抽象类不一定有抽象方法，但是有抽象方法的类必须定义成抽象类。

定义格式：

public abstract class 类名字 { }

代码举例：

定义Animal抽象类，含有抽象方法run方法。

//写抽象类Animal并含有抽象方法run
abstract class Animal {int age;public abstract void run();public void eat() {}
}

继承抽象类的子类必须重写父类所有的抽象方法。否则，该子类也必须声明为抽象类。

==抽象类注意点==

抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。

理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。
抽象类中，可以有构造器，是供子类创建对象时，初始化父类成员使用的。

理解：子类的构造方法中，有默认的super()，需要访问父类构造方法。
抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。
抽象类的子类，必须重写抽象父类中所有的抽象方法，否则子类也必须定义成抽象类，编译无法通过而报错。

理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。
抽象类存在的意义是为了被子类继承，抽象类体现的是模板思想。

理解：抽象类中已经实现的是模板中确定的成员，抽象类不确定如何实现的定义成抽象方法，交给具体的子类去实现。

抽象类存在的意义是为了被子类继承，否则抽象类将毫无意义，抽象类体现的是模板思想，模板是通用的东西抽象类中已经是具体的实现（抽象类中可以有成员变量和实现方法），而模板中不能决定的东西定义成抽象方法，让使用模板（继承抽象类的类）的类去重写抽象方法实现需求，这是典型的模板思想。

模板模式

我们现在使用抽象类设计一个模板模式的应用，例如在小学的时候，我们经常写作文，通常都是有模板可以套用的。

假如我现在需要定义新司机和老司机类，新司机和老司机都有开车功能，开车的步骤都一样，只是驾驶时的姿势有点不同，新司机:开门,点火,双手紧握方向盘,刹车,熄火，老司机:开门,点火,右手握方向盘左手抽烟,刹车,熄火。我们可以将固定流程写到父类中，不同的地方就定义成抽象方法，让不同的子类去重写，代码如下:

// 司机开车的模板类
public abstract class Driver {public  void go() { //模板方法：具体定义了固定的流程System.out.println("开门");System.out.println("点火");// 开车姿势不确定?定义为抽象方法ziShi();System.out.println("刹车");System.out.println("熄火");}public abstract void ziShi();
}

现在定义两个使用模板的司机：

public class NewDriver extends Driver {@Overridepublic void ziShi() {System.out.println("新司机双手紧握方向盘");}
}public class OldDriver extends Driver {@Overridepublic void ziShi() {System.out.println("老司机右手握方向盘左手抽烟...");}
}

编写测试类

public class Demo02 {public static void main(String[] args) {NewDriver nd = new NewDriver();nd.go();OldDriver od = new OldDriver();od.go();}
}

运行效果

可以看出，模板模式的优势是，模板已经定义了通用架构，使用者只需要关心自己需要实现的功能即可！非常的强大！

6.4、多态

在java中多态可以体现在方法上比如方法的重载，同名方法可以有不同的执行结果。多态也可以体现在面向对象中，一个对象可以使用多种类型进行表示。

多态案例演示

//定义Animal类及其子类Dog，Cat测试案例。
class Animal {public void eat() {System.out.println("动物吃东西");}
}

/*** 1.需要有继承或者实现* 2.需要有方法的重写【意义体现】* 3.父类型引用指向子类对象** 常见多态代码体现在三个地方：* 1. 直接定义变量：父类型变量接收子类对象* 2. 方法参数：父类型的形参接收子类型的实参对象* 3. 返回值：父类型的返回值类型接收子类型的返回值对象*/
public class Demo01 {public static void main(String[] args) {Cat c = new Cat();//没有体现多态//多态体现Animal a1 = new Cat();//父类型变量（引用）接收子类对象Animal a2 = new Dog();//相同方法的执行，有不同的结果a1.eat();a2.eat();//==============Dog d = new Dog();show(d); // Animal a = d;  也是体现了多态}public static void show(Animal a) {a.eat();}public static Animal getAniamal() {return new Cat();}}
class Animal{public void eat() {System.out.println("动物吃东东~~");}
}class Cat extends Animal {@Overridepublic void eat() {System.out.println("猫儿吃鱼~~");}
}class Dog extends Animal {@Overridepublic void eat() {System.out.println("狗啃骨头~~~");}
}

7、static 、final、枚举、接口

7.1、static

static关键字在java中主要用来做内存管理的。被static修饰的数据在内存中只会存在一份数据。所以这个数据适合用来共享数据。

7.2、final

学习了继承后，我们知道，子类可以在父类的基础上改写父类内容，比如，方法重写。那么我们能不能随意的继承API中提供的类，改写其内容呢？显然这是不合适的。为了避免这种随意改写的情况，Java提供了final 关键字，用于修饰不可改变内容。

那么，final作为一个关键字修饰符，可以修饰哪些成分呢？

final可以修饰类，这个类将不能被继承。
final可以修饰成员方法，这个方法将不能被重写。
final可以修饰变量，这个变量只能赋值一次。

查询API发现像 public final class String 、public final class Math 、public final class Scanner 等，很多我们学习过的类，都是被final修饰的，目的就是供我们使用，而不让我们所以改变其内容。

被final修饰的常量名称，一般都有书写规范，所有字母都大写

7.3、枚举

早期JDK1.5之前，我们会自己手动枚举数据（枚举既列举的意思），例如表示季节的数据我们会定义常量来操作，如下：

public class EnumDemo {

public static final int SPRING = 1;//春
public static final int SUMMER = 2;//夏
public static final int FALL = 3;//秋
public static final int WINTER = 4;//冬public static void main(String[] args) {showSeason(SPRING);}public static void showSeason(int season)) {switch (season) {case SPRING:System.out.println("春季");break;case SUMMER:System.out.println("夏季");break;case FALL:System.out.println("秋季");break;case WINTER:System.out.println("冬季");break;default:System.out.println("未知数据");}
}
}

虽然这种使用常量的方式列举数据很好，但是也是有弊端就是不直观，是一种硬编码。例如showSeason方法参数是整数，如果直接出入数字1，不能直观的知道这是春季，而且你不能限定使用者只传入1,2,3,4这四种数据，如果传入的是其他数字就没有季节的含义了。

如果要表示季节的数据我们可以定义一个类型，对象固定四个用来分别表示春夏秋冬。如果要表示星期，我们可以定义一个类星期类只提供7个对象用来表示一个星期的每一天，这种实例有限而且固定的类，在Java里被称为枚举类。

枚举类是一种特殊的类，它一样可以有自己的成员变量、方法，可以实现一个或者多个接口，也可以定义自己的构造器。在JDK1.5开始增加了关键字 enum（它与关键字 class ，interface 处于同等位置）用来定义枚举类型。

关键字：enum （class interface ）

定义枚举的格式

[public] enum 枚举名 {第一行都是枚举实例,这些枚举实例直接写大写名字即可。
}例如：
public enum Sex{BOY,GIRL;
}

案例：

1、定义枚举类型Sex：预定义实例BOY表示男，GIRL表示女

public enum Sex{BOY,GIRL;
}

2、定义Person类型含有姓名和性别属性，姓名使用字符串类型，性别使用Sex枚举类型类型

class Person{String name;Sex sex;//sex只能是 Sex.BOY或者Sex.GIRL中的一个值public Person(String name, Sex sex) {this.name = name;this.sex = sex;}
}

3、测试类

public class Demo01 {public static void main(String[] args) {Person p1 = new Person("张三",Sex.BOY);Person p2 = new Person("李四",Sex.GIRL);Person p3 = new Person("塞班",Sex.YAO);}
}

使用场景：

当要描述若干数据，这些数据是固定的有限的数据，我们可以使用枚举类型进行表示。

7.4、接口

接口是Java中的一种类型【引用数据类型】主要有两个成分：方法，常量。

定义接口的格式：

[public] interface 接口名{//方法  注意：接口中的抽象方法默认会自动加上public abstract修饰程序员无需自己手写！！//常量   接口中常量必须要给初始值，常量命名规范建议字母全部大写，多个单词用下划线连接。
}

接口是Java中的一种类型，没有构造方法，而且是抽象类型，不能直接创建对象使用。和抽象类很相似，需要定义子类去实现接口。

类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类。实现的动作类似继承，格式相仿，只是关键字不同，实现使用 implements关键字。

类实现接口的格式

[修饰符] class 类名 implements 接口名1，接口名2,...{//接口可以同时实现多个接口//实现所有的抽象方法
}

要求：

子类必须重写实现全部接口中所有的抽象方法。
若父接口中某个抽象方法未重写实现，这个子类也必须定义成抽象类。

==类实现接口的意义==：接口体现的是一种规范，接口对实现类是一种强制性的约束，要么全部完成接口申明的功能，要么自己也定义成抽象类。

8、字符串类

8.1、使用java API文档

8.2、String类

String 类在 java.lang 包下，所以使用的时候不需要导包

String 类代表字符串，Java 程序中的所有字符串文字（例如“abc”）都被实现为此类的实例

也就是说，Java 程序中所有的双引号字符串，都是 String 类的对象

字符串不可变，它们的值在创建后不能被更改

/*** 使用字符串类模拟登陆操作*/
public class Login {public static void main(String[] args) {// 第一步：定义两个字符串变量，分别代码用户名和密码String username = "张三";String password = "admin123";// 第二步 得到用户从控制台输入的用户名和密码// 第三步 用从控制台获取到的用户名和密码跟本地存储的用户名密码做比较Scanner s = new Scanner(System.in);// 表示创建了一个控制台输入的对象for(int i=0;i<4;i++){while (s.hasNext()){String name = s.next();String pw = s.next();if(name.equals(username) && pw.equals(password)){System.out.println("登录成功");break;}else{System.out.println("登录失败，请重新输入");}}}}
}

package com.frank.exec;import java.util.Scanner;public class TestCharAt {public static void main(String[] args) {//第一步 先创建控制台输入的对象Scanner s = new Scanner(System.in);String result = s.next();// 得到用户输入的内容int d = 0;// 用于统计大写字符出现的次数int x = 0;// 用于统计小写字符出现的次数int n=0;// 用于统计数字出现的次数// 通过charAt方法得到字符串的每个字符for(int i=0;i<result.length();i++){// 通过对象调用方法char c = result.charAt(i);if(c>='A'&& c<='Z'){// 说明此字符是大写d++;}else if(c>='a'&&c<='z'){// 说明此字符是小写x++;}else{//属于数字n++;}}System.out.println("大写字符出现的次数为"+d);System.out.println("小写字符出现的次数为"+x);System.out.println("数字出现的次数为"+n);}
}

package com.frank.exec;import java.util.Scanner;/*** 字符串截取*/
public class TestSubstr {public static void main(String[] args) {Scanner s = new Scanner(System.in);String number = s.next();// 得到用户输入的手机号 185 3344 9870// substring方法用于截取字符串String befor = number.substring(0,3);String after = number.substring(7);String result = befor+"****"+after;System.out.println(result);}
}

package com.frank.exec;import java.util.Scanner;/*** 字符串截取*/
public class TestSubstr {public static void main(String[] args) {Scanner s = new Scanner(System.in);String number = s.next();// 得到用户输入的手机号 185 3344 9870String newStr = number.replace("TMD", "****");System.out.println(newStr);}
}

package com.frank.exec;

import java.util.Scanner;

public class TestSplit {

public static void main(String[] args) {//第一步 先创建控制台输入的对象Scanner s = new Scanner(System.in);String res = s.next();// 得到用户输入的内容String[] strings = res.split(",");Student student = new Student();student.setName(strings[0]);student.setAge(Integer.parseInt(strings[1]));System.out.println(student.getName()+"==="+student.getAge());}
}

8.3、StringBuilder

StringBuilder 是一个可变的字符串类，我们可以把它看成是一个容器。

l作用：提高字符串的操作效率

Day06-面向对象基础相关推荐

Javascript基础与面向对象基础~第四讲 Javascript中的类对象
今天来说JS中如何实现类(class),事实上本应该昨天晚上写的,可我失言了,在些说一声"抱歉"!JS中的类是JS面向对象的基础,也是我最拿手的东西,你写的代码能否提高一个层次,一 ...
JavaScript – 6.JS面向对象基础(*) + 7.Array对象 + 8.JS中的Dictionary + 9.数组、for及其他...
6.JS面向对象基础(*) 7.Array对象 7.1 练习:求一个数组中的最大值.定义成函数. 7.2 练习:将一个字符串数组输出为|分割的形式,比如"刘在石|金钟国|李光洙|HAHA|宋 ...
java中sum=a+aa+aaa_Java面向对象基础IO系统
Java面向对象基础–IO系统一.IO 输入:input 输出:output Java的IO主要包含三个部分流式部分:IO的主题部分非流式部分:主要包含一些辅助流式部分的类文件读取部分的与安全 ...
石川es6课程---9、面向对象-基础
石川es6课程---9.面向对象-基础一.总结一句话总结: js老版本的面向对象和继承都不是很方便,新版的面向对象向其它语言靠拢,有了class,extends,constructor等关键字,用 ...
C++面向对象基础（二）
面向对象基础能够准确理解下面这些问题是从C程序员向C++程序员进阶的基础.当然了,这只是一部分. 面向对象三大特性? 封装性:数据和代码捆绑在一起,避免外界干扰和不确定性访问. 继承性:让某种类型对 ...
Python面向对象基础示例_创建对象
Python面向对象基础示例_创建对象 python是面向对象的语言,你可以很轻松的创建一个类和对象.本书代码源自<<Python 3 Object-Oriented Programmin ...
PHP面向对象基础总结
近来参加了几场PHP工程师的面试,但是笔试题答得都不理想,回来总结了一下失败的原因,是没看PHP手册.几家公司的PHP基础面试题都可以在PHP手册上找到.哎,现在才知道最好的面试宝典是PHP手册. 下 ...
Python基础入门_5面向对象基础
Python 基础入门前四篇: Python 基础入门–简介和环境配置 Python基础入门_2基础语法和变量类型 Python基础入门_3条件语句和迭代循环 Python基础入门_4函数第五篇主要 ...
Python第十七课(面向对象基础)
Python第17课(面向对象基础) >>>思维导图>>>中二青年面向对象编程思想OOP 什么是面向对象面向对象是一种编程思想,是前辈们总结出的经验,指导 ...
JavaSE——面向对象基础（思想、类与对象、构造方法、重载、匿名对象）
第1节面向对象基础一.面向对象思想 1.1 概述面向对象(Object Oriented)是软件开发方法.面向对象的概念和应用已超越了程序设计和软件开发,是一种对现实世界理解和抽象的方法,是计算 ...

Day06-面向对象基础

面向对象基础

1、类和对象

1.1：面向对象和面向过程的介绍

1.2：类和对象的介绍

1.3：类的定义

1.4：对象的创建以及使用

1.5：对象内存图

2、成员变量和局部变量

3、作用域修饰符

4、this关键字

5、构造方法

6、继承、封装、多态、抽象类

6.1、封装的步骤

6.2:继承

6.3、抽象类

6.4、多态

7、static 、final、枚举、接口

7.1、static

7.2、final

7.3、枚举

7.4、接口

8、字符串类

Day06-面向对象基础相关推荐

最新文章

热门文章