类与对象

一,类（class）：（是对象的抽象，可以说是一个模板）

1.类的定义：

Class
类名称{

属性1；

属性…；

方法1（）{}

方法n（）{}…….

}

例：

   class Person {

public String name; //属性

public int age;



public Person(String name, int age) {  //方法

    this.name = name;

    this.age=age;

}  }

2.内部类：所谓内部类就是在一个类的内部进行其他类结构的嵌套的操作

例：

class Outer{

private int age=10;

class Inner{  //定义一个内部类

    public void print(){              System.out.println("age");  //调用age属性

    }}}

（1）成员内部类（实例内部类）:

例：

   class Innerclass{

 public int data=10;

 public Innerclass(){

    System.out.println("Innerclass.init()");
  }}

A.不能存在static的变量和方法。

B.依附于外围类，只有先创建了外围类才能够创建内部类。

C.实例内部类对象有额外的内存消耗，实例内部类拥有外层内部类的this引用。

（2）静态内部类（使用static修饰为静态内部类）:

例:

 class Inner {

    static class print() {  //定义一个内部类        }}

A.创建是不需要依赖于外围类，可以直接创建。

B.不能使用任何外围类的非static成员变量和方法，而内部类则都可以。

C.静态内部类可以访问外部类的实例数据成员。

（3）方法内部类（定义在外部类的方法中）

例：

class Outer{public void display(int test){

class Inner{  //方法内部类

}}}
（4）匿名内部类（没有名字的方法内部类）

例：匿名内部类的使用

 interface A {

void test();

}

class Outter{

private int num;

public void display(int p){

    new A(){



        @Override

        public void test() {

            System.out.println("匿名内部类"+p);

        }

    }.test();

}

}
public class Demo3{

public static void main(String[] args) {

    Outter outter=new Outter();

    outter.display(20);

}

}

注意：A.匿名内部类是没有访问修饰符的。

B.匿名内部类必须继承一个父类或者实现一个接口，但最多只能有继承一个父类或者实现一个接口，而且必须实现接口或者父类里的所有抽象方法。

C.匿名内部类中不能存在任何静态成员或方法。

D.匿名内部类没有类名，不能定义构造器。。

E.如果匿名内部类需要访问外部类的局部变量，则需要使用final修饰符来修饰外部类的局部变量

F．匿名内部类不能是抽象类。

二,对象（object）：（或被称为实例：instance是一个具体存在的实体）

例：

class Person {

String name;

int age;

}

 public class Demo1 { 

public static void main(String[] args) { 

    Person p=new Person();

    p.name="bit";

    p.age=10;

            }

}

在上述的代码中“Person p=new Person();”

创建了一个Person实例，称为Person对象，这个Person对象被赋值给p变量。

1.对象的产生（分为两步）：A.为对象开辟内存
B.调用合适的构造函数（构造函数不止一个）
2.初始化对象：
类名称
对象名称=new 类名称（）；

3.对象属性的初始化方式：A.提供一系列的get和set方法
B.提供合适的构造函数
C.静态代码块和实例代码块

三,面向对象的三大特征：

1.封装：将对象的状态信息隐藏在对象内部，不允许外部程序直接访问对象内部信息，而是通过该类所提供的方法来实现对内部信息的操作和访问。

使用private实现封装：让内部操作对外部不可见。

例：

private String name;

private int age;

要访问私有属性：

getter方法：主要用于进行属性内容的设置和修改

setter方法：主要用于属性内容的取得

2.继承：

继承的实现：使用extends关键字实现：

修饰符class子类extends父类{

//类定义的部分

}

例：

public class Fruit {

public double weight;

public void info()

{

    System.out.println("我是一个水果！重"+weight+"g!");

}

}

 class Apple extends Fruit{

public static void main(String[] args) {

    Apple a=new Apple();

    a.weight=56;

    a.info();

}

}

作用：对类进行扩充以及代码的重用。

注意：java不允许多重继承，每个类最多只有一个直接父类，但是允许多层继承。

子类对象的实例化流程：不管如何操作，一定要先实例化父类对象。

例：多重继承会引起编译错误：

class Sclass extends B1,B2...{....} //是错误的

3.多态：

基类引用派生类对象，并且基类和
派生类有同名的重写方法。

四,覆写（override）和重载（overload）：

注意：由final关键字修饰的方法被称为密封方法，不能发生覆写。

五,向上转型和向下转型：

1.向上转型（运行时多态）。

2.向下转型：要进行强制类型转换而且前提是要先进行向上转型。

六, this关键字：

（1）this调用本类属性。

（2）this调用本类方法。

（3）this表示当前对象。

七,super关键字：

Super(参数列表); //调用基类的构造函数（必须放在派生类构造函数的第一行）

Super.data(); //访问基类的属性

Super.func(); //调用基类的成员函数

八,final关键字：

A.可以修饰类，方法，属性。

B.final成员变量必须在声明的时候初始化或者在构造器中初始化，否则就会报编译错误。

C.使用其定义的类不能有子类。

例：

  final  class  A{}   //A类不能有子类

D.final一旦修饰一个类后，该类的所有方法默认都会加上final修饰（不包含成员变量）。

E.使用final修饰的方法不能被子类重写，若发生重写将引发编译错误。

例：

class  A{  public final void fun(){}//fun方法不能被重写}

使用final修饰的方法可以被重载：
例：

public class A{

    public final void test(){}

    public final void test(String[] args){}

    }

F.使用final修饰的变量，在定义该final变量时就指定了初始值，在编译时就被确定下来，不能被修改。

例：

 final int a = 5; //a不能被修改

G.定义常量（public static final），常量全用大写字母，多个单词间以“_”分隔。
例：

Public static final int MAX_AGE=120;

九, 四种访问权限：Public==>protected==>包访问权限==>private

十,代码块：

1.普通代码块：定义在方法中的代码块。

2.构造块：定义在类中的代码块（不加修饰符）。

构造块优先于构造方法执行，每产生一个新的对象就调用一次构造块，构造快可以进行简单的逻辑操作（在构造方法前）。

3.静态块：使用static定义的代码块。根据静态块所在的类不同分为两种类型:。

在非主类中：（1）静态块优先于构造块执行。
（2）无论产生多少个实例化对象，静态块都只执行一次。
（3）静态块的主要作用是为static属性进行初始化。

在主类中：在主类中的定义的代码块，优先于主方法（main）执行。

4.同步代码块。