万事万物皆对象，对象是具有某些属性和功能的统一体。面向对象开发即不断地创建对象，使用对象，指挥对象，销毁对象。
1. 类与对象
类：是一组相关的属性和行为的集合
对象：是该类事物的具体体现
举例：学生为一个类，某一具体的学生如班长就是一个对象
1.1 类的组成
**成员变量 + 构造函数 + 成员方法 **
class Person{
public String name;
public Integer age;
public Person(String name,Integer age){
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
}
1.2 对象内存图
创建一个对象，要在栈区，堆区，方法区使用内存，具体见以下的Demo;
public class PersonDemo {
public static void main(String[] args) {
Person p1 = new Person("小红",11);
Person p2 = new Person("小明",13);
}
}
在内存分配中如下图：
2. 几种变量
-
2.1 局部变量与成员变量
-
2.2 成员变量与静态变量
3. 面向对象的特征
3.1 封装
是指隐藏对象的属性和实现细节，仅对外提供公共访问方式.封装提高了代码的复用性和安全性。
3.2 继承
多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可
3.2.1 格式
class 子类名 extends 父类名 {}
3.2.2 特点
(1)Java只支持单继承，不支持多继承。
class SubDemo extends Demo{} //ok
class SubDemo extends Demo1,Demo2...//error
(2) Java支持多层继承(继承体系)
class A{}
class B extends A{}
class C extends B{}
3.2.3 注意事项
(1) 子类只能继承父类所有非私有的成员(成员方法和成员变量)
(2) 子类不能继承父类的构造方法，但是可以通过super()关键字去访问父类构造方法。
Demo:
class Father {
private int num = 10;
public int num2 = 20;
//私有方法，子类不能继承
private void method() {
System.out.println(num);
System.out.println(num2);
}
public void show() {
System.out.println(num);
System.out.println(num2);
}
}
class Son extends Father {
public void function() {
//num可以在Father中访问private
//子类不能继承父类的私有成员变量
//System.out.println(num);
System.out.println(num2);
}
}
class ExtendsDemo {
public static void main(String[] args) {
// 创建对象
Son s = new Son();
//子类不能继承父类的私有成员方法
//s.method();
s.show();
s.function();
}
}
3.3 多态
某一个事物，在不同时刻表现出来的不同状态.前提是要有继承关系,有方法重写
,有父类引用指向子类对象。
Demo：
public class PolymDemo {
public static void main(String[] args) {
Animal animal1 = new Dog();
animal1.eat(); // 狗吃肉
Animal animal2 = new Cat();
animal2.eat(); // 猫吃鱼
}
}
class Animal {
public void eat() {
System.out.println("eat");
}
}
class Dog extends Animal {
public void eat() {
System.out.println("狗吃肉");
}
}
class Cat extends Animal {
public void eat() {
System.out.println("猫吃鱼");
}
}
4. 类的初始化过程
** Demo:**
public class ClassInitDemo {
public static void main(String[] args) {
Base tmp = new Derived();
/** 初始化过程
* Base:static init block invoked.. 1
* Derived:static init block invoked... 2
* Base:normal block invoked.. 3
* Base:constructor invoked.. 4
* Derived:normal block invoked.. 5
* Derived:constructor invoked.. 6
*/
}
}
class Base {
//1. 初始化父类中的静态成员变量和静态代码块
static int b;
static {
System.out.println("Base:static init block invoked..");
}
//3. 初始化父类的普通成员变量和代码块
int a;
{
System.out.println("Base:normal block invoked..");
}
//4. 执行父类的构造方法
public Base() {
System.out.println("Base:constructor invoked..");
}
}
class Derived extends Base {
//2. 初始化子类中的静态成员变量和静态代码块
static int e = 4;
static {
System.out.println("Derived:static init block invoked...");
}
//5. 初始化子类的普通成员变量和代码块
int d;
{
System.out.println("Derived:normal block invoked..");
}
//6. 执行子类的构造方法
public Derived() {
System.out.println("Derived:constructor invoked..");
}
}
5. 抽象类
在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。
-
格式
abstract class 类名 {
public abstract void 抽象方法名();
public void 非抽象方法名();
}
** 注意: **
(a)抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
(b)抽象类有构造方法，但不能被初始化，构造方法用来给子类访问其成员变量
(c)abstract不能与private,final,static关键字共存
6. 接口
为了体现事物功能的扩展性，Java中就提供了接口来定义这些额外功能，并不给出具体实现
6.1 格式
//接口类
interface 接口名 {
void 方法1();
String 方法2();
}
//实现类
class 类名 implements 接口名 {
void 方法1(){
do something;
}
String 方法2(){
do something;
}
}
注意：
(a)接口不能实例化
(b)接口的子类要么是抽象类,要么重写接口中的所有抽象方法
6.2 接口成员的特点
-
成员变量
只能是常量
默认修饰符 public static final
-
构造方法
没有，因为接口主要是扩展功能的，而没有具体存在成员方法
-
只能是抽象方法
默认修饰符 public abstract
6.3 类与接口的关系
-
类与类：
继承关系，只能单继承，但是可以多层继承
-
类与接口：
实现关系，可以单实现，也可以多实现。还可以在继承一个类的同时实现多个接口
-
接口与接口：
继承关系，可以单继承，也可以多继承
6.4 接口与抽象类对比
7. 内部类
把类定义在其他类的内部，这个类就被称为内部类。
访问特点： 内部类可以直接访问外部类的成员，包括私有。外部类要访问内部类的成员，必须创建对象。
Demo:
class Outer {
private int num = 10;
class Inner {
public void show() {
//可以直接访问外部类的私有成员变量
System.out.println(num);
}
}
public void method() {
//找不到符号
//show();
Inner i = new Inner();
i.show();
}
}
-
7.1 成员内部类
class Outer {
public int num = 10;
class Inner {
public int num = 20;
public void show() {
int num = 30;
System.out.println(num);
System.out.println(this.num);
System.out.println(Outer.this.num);
}
}
}
class OuterDemo {
public static void main(String[] args) {
Outer.Inner oi = new Outer().new Inner();
oi.show();
}
}
-
7.2 局部内部类
class Outer {
public void method() {
final int n = 100;
class Inner {
public void show() {
System.out.println(n);
}
}
Inner i = new Inner();
i.show();
}
}
class OuterDemo {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}
-
7.3 匿名内部类
abstract class Person {
public abstract void show();
}
class PersonDemo {
public void method(Person p) {
p.show();
}
}
class PersonTest {
public static void main(String[] args) {
//如何调用PersonDemo中的method方法呢?
PersonDemo pd = new PersonDemo ();
pd.method(new Person() {
public void show() {
System.out.println(“show”);
}
});
}
}
