本篇文章为你整理了java基础（六）：面向对象（java面向对象基础知识）的详细内容，包含有java中面向对象的概念 java面向对象基础知识 java面向对象的三大特征及实现方法 java面向对象简单例子 java基础（六）：面向对象，希望能帮助你了解 java基础（六）：面向对象。

　　面向对象的概念适合复杂系统、多人协作

　　从宏观上来说，java是面向对象的，但在微观上是面向过程的

　　
构造器在实例化时首先被自动调用，用于初始化参数。

　　new的本质是调用了构造器，返回一个对象

　　
封装--访问控制

　　“高耦合，低内聚”，内部数据操作细节自己完成，不由外部干涉， 暴露少部分方法给外部使用。

　　封装：禁止访问对象的实际表示，而应该通过接口来访问。

　　修饰词：

　　public:可以由外部调用，公开使用

　　private:不可由外部调用

　　protected：由本包内或不同包的子类调用
 

　　
使用super可以访问到父类，构造器中super.generator()可以调用父类的构造器。

public class Person {

　　 String name;

　　 public Person(String name){

　　 //构造器

　　 this.name = name;

public class Student extends Person{

　　 Student(String name){

　　 super(name);

public class Demo2 {

　　 public static void main(String[] args){

　　 Student s = new Student("小明");

　　 System.out.println(s.name);

　　输出“小明”。

　　如果在子类中不指定调用super，会自动调用

public class Person {

　　 String name;

　　 public Person() {

　　 //构造器

　　 System.out.println("父类Person无参数构造器执行");

public class Student extends Person{

　　 Student(){

　　 System.out.println("子类Student无参数构造器执行");

　　在new Student时输出：
 

　　若将子类构造器改为有参，仍然会首先调用父类的无参构造器
 

　　大致逻辑如下：
 

　　注：

　　调用构造器时，需要将父类构造器调用语句放在子类构造器的第一句

　　父类没写无参，默认有一个空的构造器函数

　　如果写了一个有参构造器，那么父类就没有无参构造器了，子类不能自动调用构造器，即子类中必须显式调用有参构造器了。

　　Person类:

public static void test(){

　　 System.out.println("Person Test");

　　Student类：

public static void test(){

　　 System.out.println("Student Test");

　　调用：

public static void main(String[] args){

　　 Student s = new Student("小明");

　　 s.test();

　　结果：
 

　　但是，如果修改main

public static void main(String[] args){

　　 Person s = new Student("小明");

　　 s.test();

　　会导致输出：
 

　　这可以说明

　　调用的方法根据声明的类型确定

　　
修饰符的范围只能扩大不能缩小 public protected default private

　　异常的范围可以被缩小但不能扩大,如：ClassNotFoundException- Exception

　　同一方法根据对象的不同采用不同的行为

　　一个对象的实际类型是确定的，但引用类型并不一致

　　如

Student s = new Student();

　　Person s1 = new Student();

　　Object s2 = new Student();

　　实际类型都是Student，而引用类型可以是其任意父类

　　对于这样的对象s1/s2，如果没有static修饰，调用一个方法时

　　
若只有子类有，则无法调用（需要强制类型转换修改引用类型）

　　如在Student写一个新的eat方法：
 

System.out.println(s instanceof Student);//true

　　 System.out.println(s1 instanceof Student);//true

　　 System.out.println(s1 instanceof Object);//true

　　 System.out.println(s2 instanceof Student);//true

　　 System.out.println(s2 instanceof Teacher);//false

　　如果对象的类是class或class的子类，则为True

　　在编译状态中，class可以是object对象的父类，自身类，子类。在这三种情况下Java编译时不会报错。(需要在同一条继承链上)

　　在运行转态中，class可以是object对象的父类，自身类，不能是子类。在前两种情况下result的结果为true，最后一种为false。但是class为子类时编译不会报错。运行结果为false。

　　编译的时候查看其引用类型判断是否报错。

　　运行的时候查看其实际类型判断是否为true。

　　强制类型转换

　　优先级：父类 子类。

　　子类转父类自动转换。

　　父类转子类需要强制转换。

　　转父类后部分方法可能无法再调用。

　　static

　　
有static修饰的变量为静态变量，在该类的内存中只能存在一个，可以使用类名.变量名进行访问

　　内部任何方法都可以直接访问静态变量（可以不使用类名.静态成员进行访问）

　　类外部可以使用类名访问类中静态变量

　　
静态变量被所有实例共享，可以作为实例对象间的共享数据

　　如果所有实例都有一个相同的常量属性，可以定义为static以节省空间

　　静态方法（类方法）

　　静态方法不需要通过任何实例就可以被调用，

　　不能使用this/super关键字

　　也不能直接访问类内部的实例变量和实力方法

　　可以直接调用类内部的静态变量和静态方法

　　通过实例对象访问

　　静态代码块

　　static{}代码块

　　用于初始化类（一次性的），为类的静态变量赋初值

　　类似于一个方法，但不在方法体中

　　可以在类的任意位置，可以有任意多个

　　java虚拟机在加载类的时候执行静态代码块

　　多个代码块按顺序运行

　　静态代码块和静态方法类似，不能访问非静态成员

　　非静态代码块

　　创建对象时自动执行，不创建对象不执行

　　代码域中的变量都是局部的，只在内部使用

　　
抽象类：有具体实现和规范（抽象方法）

　　接口：只有规范，没有具体实现 专业的约束，实现约束和实现的分离，比抽象类更加抽象

[public] interface interface_name [extends interface1_name[, interface2_name,…]] {

　　 // 接口体，其中可以包含定义常量和声明方法

　　 [public] [static] [final] type constant_name = value; // 定义常量

　　 [public] [abstract] returnType method_name(parameter_list); // 声明方法

　　接口只能继承接口

　　public定义的接口可以被任何类使用，而没有public只能被包内使用

　　接口中的变量隐式声明为public static final（可以不写），即为常量，所以全部必须初始化

　　接口中的方法隐式声明为 public abstract

　　
实现使用implements关键字

 public class class_name [extends superclass_name] [implements interface1_name[, interface2_name…]] {

　　 // 主体

　　
内部类还是一个独立的类，会编译为独立的.class文件，但前面会冠以类名和$符号

　　是内部类的一个成员，可以操作到外部类的私有属性

　　外部类只有两种级别：public和默认

　　内部类有四种级别：public、protected、private、默认

　　
和实例方法、实例变量相同，在外部类/外部类以外，必须通过外部类的实例创建内部类的实例

　　实例内部类中可以访问外部类的所有成员（多层嵌套也可）

　　外部类中不能直接访问内部类的成员，而必须通过内部类的实例访问（不是很懂）

　　实例内部类中的成员不能使用static修饰，除非同时有final修饰

　　静态内部类

　　static修饰的内部类，例：

public class Outer {

　　 static class Inner {

　　 // 静态内部类

　　可以通过外部类创建内部类的实例

　　类中可定义静态成员/实例成员

　　可直接访问外部类的静态成员，如果要访问外部类的实例成员，则需要通过外部类的实例去访问。

　　局部内部类

　　一个方法中定义的类，如:

public class Test {

　　 public void method() {

　　 class Inner {

　　 // 局部内部类

　　类似局部变量，不用访问控制修饰符和static修饰符修饰

　　只在方法内可用

　　不能定义static成员

　　内部类的内部类也不能用访问控制修饰符和static修饰符

　　可访问外部类的所有成员

　　方法中的成员与外部类成员同名，可以使用 .this. 的形式访问外部类中的成员。

　　匿名内部类

　　没有类名的内部类，直接使用new来声明，例：

new 类或接口 () {

　　 // 类的主体

　　一般用法：

　　继承一个类，重写其方法。

　　实现一个接口（可以是多个），实现其方法。

public class Out {

　　 void show() {

　　 System.out.println("调用 Out 类的 show() 方法");

　　public class TestAnonymousInterClass {

　　 // 在这个方法中构造一个匿名内部类

　　 private void show() {

　　 Out anonyInter = new Out() {

　　 // 获取匿名内部类的实例

　　 void show() {

　　 System.out.println("调用匿名类中的 show() 方法");

　　 anonyInter.show();

　　 public static void main(String[] args) {

　　 TestAnonymousInterClass test = new TestAnonymousInterClass();

　　 test.show();

　　和局部内部类相同，可访问外部类所有成员。若位于方法中，只能访问方法中final修饰的量

　　可以使用非静态代码块进行初始化，在父类的构造函数后执行

　　以上就是java基础（六）：面向对象（java面向对象基础知识）的详细内容，想要了解更多 java基础（六）：面向对象的内容，请持续关注盛行IT软件开发工作室。

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。