一、什么是面向对象

面向过程思想
- 步骤清晰简单，第一步做什么，第二步做什么…
- 面对过程适合处理一些较为简单的问题
面向对象思想
- 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
- 面向对象适合处理复杂的问题，适合处理需要多人协作的问题！
对于描述复杂的事物，为了从宏观上把握，从整体上合理分析，我们需要使用面向对象的思路分析整个系统。但是具体到微观操作，仍然需要面向过程的思路去处理。
面向对象编程(Object-Oriented Programming,OOP)
面向对象的本质：以类的方式组织代码，以对象的形式组织(封装)数据。
三大特性：
- 封装：把对象的属性和行为封装在一起，形成一个不可分割的实体，只保留有限的对外接口。在编程上，将属性与方法定义在一个类中，并对来自类外部的访问进行控制。
- 继承：子类继承父类的属性和行为，同时具有自己独特的属性与行为。
- 多态：一种多态是一个类中有多个操作具有相同的名字，但这些操作所接收的输入参数各不相同，称为方法重载。另一种多态与继承有关，指父类的方法被不同的子类继承后表现出不同的行为。
从认识论角度考虑是先有对象后有类。对象，是具体的事物，占内存。类，是抽象的，是对对象的抽象，不占内存。
从代码运行角度考虑是先有类后有对象。类是对象的模板。

二、类与对象的创建

类与抽象的关系
- 类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物
  - 动物、植物、手机、电脑…
  - Person类、Pet类、Car类等，这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为
- 对象是抽象概念的具体实例
  - 张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例。
  - 能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念。

创建与初始化对象

使用new关键字创建对象。
使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象，进行默认的初始化以及对类中构造器的调用。
new操作符创建对象完成了三件事：
- 为对象分配存储空间
- 调用构造方法
- 返回对象的引用
类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：
- 必须和类的名字相同
- 必须没有返回类型，也不能写void

public class Demo05 {public static void main(String[] args) {//类：抽象的，需要实例化//类实例化后会返回一个自己的对象！stu1对象就是一个Stu类的具体实例Stu stu1 = new Stu();Stu stu2 = new Stu();stu1.name = "小明";stu1.age = 3;System.out.println(stu1.name);System.out.println(stu1.age);stu2.name = "小红";stu2.age = 4;System.out.println(stu2.name);System.out.println(stu2.age);}
}
class Stu{//属性：字段String name;int age;//方法public void study(){System.out.println(this.name);}
}
/*
结果：小明3小红4
*/

public class Demo06 {public static void main(String[] args) {//new   实例化了一个对象Per per = new Per("zanbimo");System.out.println(per.name);}
}
class Per{//一个类即使什么都不写，它也会存在一个方法，即构造方法String name;public Per(){}//有参构造：一旦定义了有参构造，无参就必须显示定义public Per(String name){//方法重载this.name=name;}
}
/*
结果：zanbimo
*/

public class Demo07 {public static void main(String[] args) {Pet dog = new Pet();dog.name = "旺财";dog.age = 3;dog.shout();System.out.println(dog.name);System.out.println(dog.age);}
}
class Pet{public String name;public int age;public void shout(){System.out.println("叫了一声");}
}
/*
结果：叫了一声旺财3
*/

三、封装

该露的露，该藏的藏

我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合就是仅暴露少量的方法给外部使用。
封装（数据的隐藏）

通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

记住这句话就够了：属性私有，get/set

/*
* 1.提高程序的安全性，保护数据
* 2.隐藏代码的实现细节
* 3.统一接口
* 4.提高系统可维护性
* */
public class Demo08 {public static void main(String[] args) {Sd s1 = new Sd();s1.setName("赞比么");s1.setAge(990);//不合法System.out.println("年龄："+s1.getAge());}
}
class Sd{//属性私有private String name;//名字private int id;//学号private char sex;//性别private int age;//年龄//提供一些可以操作这个属性的方法//即提供一些public的get、set方法//get   获得这个数据public String getName(){return this.name;}//set   给这个数据设置值public void setName(String name){this.name = name;}//alt+insert自动生成get、set方法public int getId() {return id;}public void setId(int id) {this.id = id;}//public char getSex() {return sex;}public void setSex(char sex) {this.sex = sex;}//public int getAge() {return age;}public void setAge(int age) {if (age>0 && age<150){this.age = age;}else {this.age = -1;System.out.println("年龄不合法，0~150");}}
}

四、继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。（类太多，要抽象）
```
class  子类名  extends  父类名 { ...
} 
```
extends的意思是“扩展”。子类是父类的扩展。
JAVA中类只有单继承，没有多继承！(一个儿子只能有一个爸爸，但是一个爸爸可以有多个儿子)
继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
继承关系的两个类，一个为子类(派生类)，一个为父类(基类)。子类继承父类，使用关键字extends来表示。子类可以“继承父类的实例变量和实例方法”，但是子类“不继承父类的构造方法”
子类和父类之间，从意义上讲应该具有“is a”的关系。

object类：所有的类，都默认直接或间接继承Object

//在JAVA中，所有的类，都默认直接或间接继承Object
public class Demo09 {public static void main(String[] args) {St st = new St();st.say();st.setMoney(500);System.out.println(st.getMoney());}
}
class Pe{//父类private int money = 10_0000;public int getMoney() {return money;}public void setMoney(int money) {this.money = money;}public void say(){System.out.println("说了一加一");}
}
class St extends Pe{//子类}
/*
结果：说了一加一500
*/

super
- super关键字表示当前对象的父类，有两种用法：
  - 在“子类的构造方法”中，使用super关键字指定调用父类的某个构造方法；
  - 在“子类”中，通过super关键字访问父类的成员变量和成员方法。
- super调用父类的构造方法，由参数列表确定调用父类哪个构造方法，必须在构造方法中的第一个语句。这种super语句只起到占位符的作用，用于确定调用父类的哪个构造方法，而不是先执行super语句然后再执行子类构造方法的意思。
- super必须只能出现在子类的方法或者构造方法中
- spuer和this不能同时调用构造方法(二者都必须在构造方法中的第一个语句)
- VS this:
  - 代表的对象不同：
    - this：本身调用者这个对象
    - super:代表父类对象的引用
  - 前提：
    - this：没有继承也可以使用
    - super：只能在继承条件下才能使用
  - 构造方法：
    - this();本类的构造
    - super();父类的构造
  - 使用范围：
    - this：只能用于实例方法和构造方法中，不能用于类方法中
    - super：只能用于实例方法和构造方法中，不能用于类方法中
```
public class Demo10 {public static void main(String[] args) {Std std = new Std();std.test("hh");}
}
class Pes{//父类public Pes() {System.out.println("Pes无参构造执行了");}protected String name = "zan";//私有的东西无法被继承public void print(){System.out.println("Pes");}
}
class Std extends Pes{//子类public Std() {//super();//隐藏代码：调用了父类的无参构造，并须在子类构造器的第一行this("有参构造");System.out.println("Std无参构造执行了");}public Std(String name) {this.name = name;}private String name = "zanbimo";public void test(String name){System.out.println(name);//hhSystem.out.println(this.name);//有参构造System.out.println(super.name);//zanthis.print();//Stdsuper.print();//Pes,子类调父类}public void print(){System.out.println("Std");}
}
/*
结果：Pes无参构造执行了Std无参构造执行了hh有参构造zanStdPes
*/
```

方法重写：

需要有继承关系，子类重写父类的方法！
- 方法名必须相同
- 参数列表必须相同
修饰符：范围可以扩大：public>protected>default>private
抛出异常：范围可以被缩小，但不能扩大：ClassNotFoundException–>Exception(大)
子类的方法和父类必须要一致，方法体不同
为什么需要重写：
- 父类的功能，子类不一定需要，或者不一定满足
- Alt+Insert：override

/*
对于上转型，需要注意以下几点：把子类对象作为实参传给父类的形参，这也是上转型。若存在方法重写，则访问上转型对象时，上转型对象原来是哪个类的对象，则访问的就是哪个类重写的方法。父类不能被子类继承的属性和方法，则上转型对象不能访问。
*/
public class Demo11 {public void f(B b){b.test();}//静态方法：方法的调用只和左边，定义的数据类型有关//非静态方法：重写public static void main(String[] args) {//方法的调用只和左边即定义的数据类型有关A a = new A();a.test();//A//子类对象的上转型，父类的引用指向了子类//子类对象上转型后，不能再使用子类新增的属性和方法，只能使用从父类继承的属性和方法B b = new A();b.test();//BSystem.out.println("========");Demo11 demo11 = new Demo11();demo11.f(new A());//上转型:把子类对象作为实参传给父类的形参}
}
//重写都是方法的重写，和属性无关
class B{public void test(){//staticSystem.out.println("B=>test()");}
}
class A extends B{@Override//注解：有功能的注释，重写/*子类对象上转型后，不能再使用子类新增的属性和方法，只能使用从父类继承的属性和方法。对于父类被子类重写的方法，实际访问的是子类的方法，但访问权限还是按照父类方法的访问权限。*/public void test() {//staticSystem.out.println("A=>test()");}
}
/*结果1：A=>test()A=>test()========A=>test()结果2：A=>test()B=>test()========B=>test()
*/

五、多态

多态是指在程序中相同的名称表现出不同的行为，包括静态多态和动态多态两种。
- 静态多态一般指方法重载
- 动态多态也称为运行时多态，实现条件：
  - 实现继承，或实现接口
  - 子类重写父类方法，或实现类实现接口的方法
  - 执行上转型，通过上转型对象访问父类被重写的方法，或接口被实现的方法（父类引用指向子类对象）。
多态即同一方法可以根据发送对象的不同而采用多种不同的行为方式
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多（父类，有关系的类）

注意：

多态是方法的多态，属性没有多态性。
父类和子类有联系，存在类型转换异常！ClassCastException
无法重写的情况：
- static方法，属于类，不属于实例
- final方法，常量
- private方法，私有

public class Demo12 {public static void main(String[] args) {//new了一个对象，一个对象的实际类型是确定的//new Student();//可以指向的引用类型就不确定了：父类的引用指向子类Stud s1 = new Stud();Pers s2 = new Stud();Object s3 = new Stud();s1.run();s2.run();//子类对象上转型后，子类重写了父类的方法，执行子类的方法//对象能执行哪些方法，主要看对象左边的类型，和右边关系不大s1.eat();//s2.eat();//非法的，上转型对象只能访问从父类继承的成员变量或方法}
}
class Pers{public void run(){System.out.println("run");}
}
class Stud extends Pers{@Overridepublic void run() {System.out.println("son");}public void eat(){System.out.println("eat");}
}
/*
结果：sonson
*/

instanceof 运算符：左操作数是对象，右操作数是类型。当左操作数的对象属于右操作数的类型时，结果是true，否则是false。判断一个对象是什么类型。

public class Demo13 {public static void main(String[] args) {//Object>String//Object>P>T//Object>P>S//System.out.println(X instanceof Y);//能不能编译通过？看X和Y之间是否存在父子关系，存在则通过，反之相反//结果是true还是false?看X所指向的实际类型是否是Y的子类型Object object = new S();System.out.println(object instanceof S);//trueSystem.out.println(object instanceof P);//trueSystem.out.println(object instanceof Object);//trueSystem.out.println(object instanceof T);//falseSystem.out.println(object instanceof String);//falseSystem.out.println("===============");P p = new S();System.out.println(p instanceof S);//trueSystem.out.println(p instanceof P);//trueSystem.out.println(p instanceof Object);//trueSystem.out.println(p instanceof T);//false//System.out.println(p instanceof String);//编译出错System.out.println("===============");S s = new S();System.out.println(s instanceof S);//trueSystem.out.println(s instanceof P);//trueSystem.out.println(s instanceof Object);//true//System.out.println(s instanceof T);//编译出错//System.out.println(s instanceof String);//编译出错}
}
class P{}
class S extends P{}
class T extends P{}
/*
结果：truetruetruefalsefalse===============truetruetruefalse===============truetruetrue
*/

/*
* 下转型需要强制转换，分两种情况：
* (1) 把一个父类对象强制转换为子类对象，这是不允许的，尽管编译能通过，但不能运行；
* (2) 先将子类对象上转型，然后再下转型，这是允许的，上转型对象通过下转型又转换回原来的子类对象，可以使用子类的全部属性和方法。
* */
public class Demo14 {public static void main(String[] args) {//类型之间的转化：父类：高 子类：低PerS p = new StuD();//上转型：把子类对象赋值给父类变量((StuD) p).go();//go//p.go();报错//将p这个对象转换为StuD类型，我们就可以使用StuD类型的方法了StuD s = (StuD) p;//下转型：把父类对象赋值给子类变量，强制转换s.go();//go}
}
class PerS{public void run(){System.out.println("run");}
}
class StuD extends PerS{public void go(){System.out.println("go");}
}
/*
结果：gogo
*/

六、static详解

import static java.lang.Math.random;
public class Demo15 {private static int age;//静态变量private double score;//非静态变量public static void go(){//静态方法System.out.println("go");}public void run(){//非静态方法System.out.println("run");}public static void main(String[] args) {Demo15 demo15 = new Demo15();System.out.println(demo15.age);System.out.println(Demo15.age);new Demo15().run();Demo15.go();go();System.out.println("=========");Dmk dmk1 = new Dmk();System.out.println("=========");Dmk dmk2 = new Dmk();System.out.println("=========");System.out.println(Math.random());//因为import static java.lang.Math.random;System.out.println(random());}
}
final class Dmk{//2：赋初值{System.out.println("匿名代码块");//代码块（匿名代码块）}//1:只执行一次static {System.out.println("静态代码块");//静态代码块}//3public Dmk() {System.out.println("构造方法");}
}
//class Test extends Dmk{}//final类不能被继承，即不能有子类/*
结果：00rungogo=========静态代码块匿名代码块构造方法=========匿名代码块构造方法=========0.262283947911459260.1986239214077118
*/

七、抽象类

abstract修饰符可以用来修饰方法也可以修饰类；如果修饰方法，那么该方法就是抽象方法；如果修饰类，那么该类就是抽象类。
```
abstract class A{...
}
```
抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类。
抽象类：不能使用new关键字来创建对象(即不能用来创建实例)，它是用来让子类继承的。不允许使用final和abstract同时修饰一个类。
抽象方法：只有方法的声明，没有方法的实现，它是用来让子类实现的。同样不允许使用final和abstract同时修饰一个方法。

子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。

public class Demo16 {public static void main(String[] args) {//new Action();抽象类不能被实例化，只能靠子类去实现它Cx cx = new Cx();cx.doSomething();cx.go();}
}
//abstract 抽象类
abstract class Action{//约束~有人帮我们实现//abstract,抽象方法，只有方法名字，没有方法实现public abstract void doSomething();//抽象方法，没有方法体public void go(){// //非抽象方法，有方法体System.out.println("go");}//abstract public Action() {}//构造方法不可以是抽象方法
}
//抽象类的所有方法，继承了它的子类，都必须要实现它的方法，除非它的子类也是抽象的
class Cx extends Action{@Overridepublic void doSomething() {System.out.println("do");}
}
abstract class Zl extends Action{}
/*
结果：dogo
*/

八、接口的定义与实现

接口的定义
- 用关键字interface来声明一个接口。接口中只能有两样东西：常量和抽象方法。
```
[public] interface 接口名 {    //常量声明，公有的静态常量[public] [static] [final] 变量类型 变量名 = 值;...//抽象方法声明，公有的抽象方法[public] [abstract] 返回类型 方法名(参数列表); ...
}
```
- 普通类：只有具体实现
- 抽象类：具体实现和规范(抽象方法)都有！
- 接口：只有规范！自己无法写方法_{专业的约束}约束和实现分离：面向接口编程
- 接口就是规范，定义的是一组规则，体现了现实世界中"如果你是…则必须能…"的思想。如果你是天使必须能飞。
- 接口的本质是契约，就像我们人间的法律一样，制定好后大家都遵守。
- 和抽象类一样，接口不能用来创建对象实例，因为接口中没有构造方法
- OO的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言(比如c++、java、c#等)，就是因为设计模式所研究的，实际上就是如何合理的去抽象。

接口的实现

接口由类来实现，一个类通过关键字implements声明自己实现了一个或多个接口。如果实现了多个接口，用逗号分隔接口名。接口实现的定义格式如下：
```
[修饰符] class 类名 implements 接口1, 接口2, … {//接口方法的实现...//实现类新增的内容...         
}
```
- 一个类实现某个接口也就是要实现该接口的所有抽象方法。如果只实现了一部分，则接口未被实现的那些抽象方法会被实现类所继承，从而成为抽象类。
- 实现类继承接口的常量，成为自己的静态常量，既可以通过接口名访问，也可以通过类名访问，还可以通过实现类的对象访问。
- 在实现类中实现接口的抽象方法时，必须使用完全相同的方法原型，并且不能降低方法的访问权限，因而实现类所实现的方法权限必须是public。
一个类可以在继承某个父类的同时实现若干个接口，这种情况下的定义形式如下：
```
[修饰符] class 类名 extends 父类名 implements 接口1, 接口2, … {...
}
```

有些接口没有声明任何方法，这种接口叫做标识接口。标识接口仅仅充当标识的作用，用来表明实现它的类属于某个特定的类型，如下例：

interface Ore {}  //矿石接口interface Weapon {}  //武器接口interface Rubbish{}  //垃圾接口class Gold implements Ore{ //金矿public String toString(){return "Gold";}
}class Copper implements Ore{  //铜矿public String toString(){return "Copper";}
}class Gun implements Weapon{ //枪public String toString(){return "Gun";}
}class Grenade implements Weapon{ //榴弹 public String toString(){return "Grenade";}
}class Stone implements Rubbish{  //石头public String toString(){return "Stone";}
}

public class Demo17 {public static void main(String[] args) {//new UserService();接口不能用来创建对象实例UserServiceImpl userService = new UserServiceImpl();userService.add("add");userService.delete("delete");userService.update("update");userService.query("query");userService.time();}
}
interface UserService{//接口1//静态常量,在接口中如果有变量声明，那么该变量一定由public、final、static修饰，没有的话系统在编译时也会默认加上。//接口中final常量必须在定义时初始化public static final int age = 9;//接口中的所有定义的方法，默认其实都是抽象的public abstractvoid add(String name);void delete(String name);void update(String name);void query(String name);
}
interface TimeService{//接口2void time();
}
//类可以实现抽象类：extends
//类可以实现接口:implements
//实现接口的类就需要重写接口中的方法
//多继承~利用接口实现多继承
class UserServiceImpl implements UserService,TimeService{//接口实现类@Overridepublic void add(String name) {System.out.println(name);}@Overridepublic void delete(String name) {System.out.println(name);}@Overridepublic void update(String name) {System.out.println(name);}@Overridepublic void query(String name) {System.out.println(name);}@Overridepublic void time() {System.out.println("time");}
}
/*
结果：adddeleteupdatequerytime
*/

接口的继承

Java允许一个接口继承其它的接口，声明格式如下

[public] interface 接口名 extends 父接口1, 父接口2, … {//新增的抽象方法或静态常量...
}

一个接口可以继承一个或多个接口，从而继承其它接口的抽象方法和常量。

实现类除了实现当前接口自己定义的抽象方法，还要实现该接口继承而来的抽象方法。如果在子接口中声明了和父接口同名的常量或原型相同的方法，则父接口中的常量被隐藏，方法被重写(覆盖)。

interface x{//接口xvoid m1();void m2();
}
interface y {//接口yvoid m3();
}
interface z extends x, y{//接口zvoid m4();
}
class xyz implements z{//实现类public void m1() {……//实现代码}public void m2() {……//实现代码}public void m3() {……//实现代码}public void m4() {……//实现代码}
}

接口类型：接口也是一种引用数据类型，可以当作数据类型使用。可以用接口来声明变量，也可以把一个实现类的对象赋值给接口变量，这也是上转型。

接口回调与多态

接口回调是指把实现类的对象赋值给接口变量，然后通过接口变量访问接口方法，则实际访问的是实现类所实现的方法：
```
接口类型 接口变量 = 用实现类创建的对象;        
接口变量.接口方法([参数列表]);
```

通过接口变量来访问接口方法时，由于不同的实现类对同一方法有不同的实现，从而表现出多态。

public class Demo18 {public static void main(String[] args) {ShowMessage sm;//声明接口变量。sm = new TV();//TV的对象赋值给接口变量。sm.showTradeMark();//通过接口回调来调用TV的方法showTradeMark()     sm = new PC();//PC的对象赋值给接口变量。sm.showTradeMark();//通过接口回调来调用PC的方法showTradeMark()           }
}
interface ShowMessage {//接口void showTradeMark();
}
class TV implements ShowMessage {//实现类public void showTradeMark()   {System.out.println("电视机");}
}
class PC implements ShowMessage  {//实现类public void showTradeMark()  {System.out.println("电脑");}
}
/*
结果：电视机电脑
*/

接口做参数
如果一个方法的形参是接口类型，就可以将实现类的对象传给这个参数，这也是上转型。

public class Demo19 {public void f(Show s){//接口作为参数s.show();}public static void main(String[] args) {Demo19 demo19 = new Demo19();demo19.f(new C());//实现类的对象传给接口参数demo19.f(new D());//实现类的对象传给接口参数}
}
interface Show{//接口void show();
}
class C implements Show{//实现类Apublic void show(){System.out.println("I love This Game");}
}
class D implements Show{//实现类Bpublic void show(){System.out.println("我喜欢看NBA");}
}
/*
结果：I love This Game我喜欢看NBA
*/

九、内部类

内部类就是在一个类的内部再定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。

成员内部类：定义在类体中(不是方法体中)且没有用static修饰的类

定义常规内部类时可以使用private、protected、public、友好等访问权限，与用于成员变量和成员方法时的规则相同，可以将常规内部类看作是外部类的一个成员。
在常规内部类中可以访问外部类的成员，用“外部类名.this.外部类成员”的形式访问外部类的实例成员，用“外部类名.外部类成员”的形式访问外部类的*静态成员*。在不引起歧义的情况下，前缀“外部类名.this”和“外部类名”可以省略。
在外部类的实例方法和构造方法中可以直接声明内部类的变量、创建内部类的对象：
```
内部类名 变量名 = new 内部类名(…);
```
在外部类的实例方法和构造方法之外的地方创建常规内部类的对象：
```
外部类名.内部类名 变量名 = 外部类对象.new 内部类名(…);
```

public class Demo20 {public static void main(String[] args) {Outer outer = new Outer();//outer外部类对象//通过这个外部类来实例化内部类Outer.Inner inner = outer.new Inner();inner.getID();System.out.println("========");outer.out();}
}
class Outer{private int id = 99;//staticpublic void out(){System.out.println("这是外部类的方法");Inner inner = new Inner();System.out.println(inner.name);}// 常规内部类：定义在类体中(不是方法体中)且没有用static修饰的类class Inner{//staticprivate String name = "zanbimo";public void in(){System.out.println("这是内部类的方法");}//获得外部类的私有属性public void getID(){System.out.println(id);}}
}
/*
结果：99========这是外部类的方法zanbimo
*/

静态内部类：定义在类体中并且用static关键字修饰的内部类。

静态内部类可以直接访问外部类的*static成员*，但不能直接访问外部类的实例成员。同样可以用权限修饰符限制静态内部类的访问权限。
在static内部类中不能使用“外部类名.this”访问外部类的成员。

创建静态内部类的对象：

外部类名.内部类名 对象变量 = new 外部类名.内部类名(…);

静态内部类可以定义在接口中，定义在接口中的任何类都自动成为public和static的。

public class MyOuter {static int x = 100;int m = 20;static class MyInner{private String y = "Hello!";public void innerMethod(){System.out.println("x = " + x);//x = 100System.out.println("y = " + y);//y = Hello!System.out.println("m = " + m);//错误，静态内部类不能直接访问外部类的实例成员//正确写法：SyOuter myouter = new MyOuter;//需要实例化外部类为一个对象System.out.println("m = " + myouter.m); //通过这个对象来访问}   }public static void main(String[] args) {MyOuter.MyInner si = new MyOuter.MyInner();//创建静态内部类的对象 si.innerMethod();}
}
/*
结果：x = 100y = Hello!m = 20
*/

局部内部类：在方法或语句块中定义的类称为局部内部类。

局部内部类只能在定义它的方法或语句块内可以使用。
局部内部类同局部变量一样不能使用private、protected、public等访问修饰符，也不能使用static修饰。
局部内部类可以访问外部类的成员(static成员和实例成员)，也可以通过“外部类名.this”访问外部类对象及成员。

public class MyOuter{private int size = 5;private static int y = 7;public Object makeInner(int localVar){class MyInner{//该内部类只在makeInner()方法中有效int y = 4;public String toString() {//重写了Object类的toString方法//取得对象信息，返回该对象的字符串表示String s1 = "Outer size = " + size +";";//访问外部类私有成员变量String s2 = " Inner localVar = " + localVar +";";//访问局部变量String s3 = " Inner y = " + this.y +";";//访问内部类的成员变量y，可以省略thisString s4 = " Outer y = " + MyOuter.this.y;//必须通过MyOuter.this访问外部类的同名成员变量yreturn  s1 + s2 + s3 + s4;//5 + 47 + 4 + 7}//方法}//内部类return new MyInner();//返回一个引用，所以方法类型为Object}public static void main(String[] args) {Object obj = new MyOuter().makeInner(47);//创建MyOuter对象，不能使用MyInner来声明对象变量System.out.println(obj.toString());}
}
/*
结果：Outer size = 5; Inner localVar = 47; Inner y = 4; Outer y = 7
*/

匿名内部类 (简称匿名类)：在一个类的内部定义，在定义类的同时创建对象并且类没有名字

定义格式：

new  类或接口(…){匿名内部类的类体    
};

匿名类必须继承一个类或实现一个接口，new后面的名字是匿名类的父类或要实现的接口，new返回的是所创建的匿名类对象。
匿名类的定义和使用都在同一个地方，如果某个类的对象只使用一次，可以考虑使用匿名类。
由于匿名类没有名字，所以不能定义构造方法。
匿名类可以访问外部类的成员变量和成员方法：
- 如果匿名类定义在外部类的静态方法中，那么只能访问外部类的静态成员；如果匿名类定义在外部类的实例方法中，则外部类的静态成员和非静态成员都可以访问。
- 如果匿名类定义在外部类的类体中，那就看把匿名类对象赋值给外部类的静态成员变量还是实例成员变量。如果是赋值给静态成员变量，则只能访问外部类的静态成员；如果赋值给实例成员变量，则外部类的静态的和非静态成员都可以访问。
- 可以用“外部类名.this.成员”的形式来访问外部类的实例成员，用“外部类名.成员”的形式来访问外部类的静态成员。在不引起歧义的情况下，前缀“外部类名.this”和“外部类名”可以省略。

class MyOuter {private  int size = 10;static private int n = 2;Object x = new Object() {public String toString(){//重写父类的toString()方法return "成员变量x的值是: " + MyOuter.this.size / MyOuter.n; //10/2}   };//将匿名类对象赋值给父类Object类型的成员变量x，是上转型public  Object makeInner(int localVar){          int  unit = 2;return new Object() {    public String toString() {//重写父类的toString()方法return "OuterSize =  " + size / unit + "  LocalVar = " + localVar / n;//10/2+48/2} };//将匿名类对象作为方法的返回值}public void printObject(int x) { System.out.println(  new Object(){ public String toString(){ return "输入参数的值是: " + MyOuter.this.size / MyOuter.n;//10/2}}); //匿名类对象做方法的输入参数}public static void main(String args[]) {MyOuter obj = new MyOuter();            obj.printObject(15);            System.out.println(obj.makeInner(48)); System.out.println(obj.x);}
}
/*
结果：输入参数的值是: 5OuterSize =  5  LocalVar = 24成员变量x的值是: 5
*/

public class Demo21 {public static void main(String[] args) {//没有名字初始化类，不用考虑实例保存到变量中new Apple().eat();//eatSystem.out.println("========================");User user = new User() {//匿名内部类@Overridepublic void hello() {System.out.println("hello");}public String toString(){return "重写object类的toString方法";}};user.hello();System.out.println(user.toString());//toString()可以省略，默认调用}
}
class Apple{//类public void eat(){System.out.println("eat");}
}
interface User{//接口void hello();
}
/*
结果：
eat
========================
hello
重写object类的toString方法
*/

查看全文
如若内容造成侵权/违法违规/事实不符，请联系编程学习网邮箱：809451989@qq.com进行投诉反馈，一经查实，立即删除！

EventBus源码学习，android输入法开发
if (defaultInstance null) { synchronized (EventBus.class) { if (defaultInstance null) { defaultInstance new EventBus(); } } } return defaultInstance; } // 调用带参数的构造方法 public EventBus() { this(DEFAULT_BUILDER); } // EventBus(EventB…...
2024/4/30 16:24:04
Java——异常
目录异常异常概念异常体系异常分类异常的产生和处理捕获处理异常try…catch获取异常信息finally 代码块异常注意事项多异常处理自定义异常异常异常概念异常指的是程序在执行过程中，出现的非正常的情况，最终会导致JVM的非正常停止。注意: 在Java等面…...
2024/4/30 21:45:56
【Git操作】
git操作...
2024/4/18 17:15:17
四元素（四元数quaternion)的理解
在游戏动画中，四元素因其在计算上的简易特性而被广泛使用，但对于诸多开发者而言，理解并不是那么容易。下面列几个漂亮的链接，作者做的非常好，一目了然。什么是万向节锁传统的欧拉坐标中，万向节锁的理解…...
2024/4/30 17:38:10
java中的static关键字
//从头开始学java ## 第一章static关键字** **static修饰方法,该方法不可以使用this,super等关键字,因为这些关键字实际上指的是具体的对象的内存地址,静态方法可以被类名.方法名调用,静态方法随着类的加载而加载不依附于任何对象. 并且静态方法中也不能调用非静态方法,因为非…...
2024/4/28 22:05:11
【YBTOJ】行为方案
思路： 可以推出方程 fi,j∑fi,pfp,jf_{i,j}\sum_{}f_{i,p}f_{p,j}fi,j∑fi,pfp,j 这不是矩乘吗（ codecodecode #include<iostream> #include<cstdio>using namespace std;int n, m; int t, a[110][110], ans[110][110];void matrix…...
2024/4/28 17:21:05
第二次前端培训作业
４表单 ６.１from from标签用于为用户输入创建HTML 表单能包含input元素，比如文本，字段，复选框，单选框，提交按钮等。表单用于向服务器输入数据，from元素是块级元素&…...
2024/4/28 12:56:53
前端第二次培训（HTML表单）
<input>标签： <input type"类型属性" name"名称" ....../> type属性值描述 text 文字域 password 密码域 file 文件域 checkbox 复选域 radio 单选域 button 按钮 submit 提交按钮 reset 重置按钮 hidden 隐藏域 image 图像域单…...
2024/4/28 22:12:54
cookie、sessionStorage，localStorage区别
HTML5 Web 存储（localStorage和sessionStorage） 本文链接：HTML5 Web 存储（localStorage和sessionStorage）_sleepwalker_1992的专栏-CSDN博客 HTML5 Web 存储（webStorage）是本地存储&#xff0…...
2024/4/28 16:36:28
Dart开发之——流程控制语句，应届毕业生硬件工程师面试题
当判定值或表达式符合条件时，执行预定的代码和逻辑常见的条件分支语句有：if/if else/if else if 2.2 示例 main() { var n 100; if (n < 60) { print(“不及格”); } else if (n < 85) { print(“良好”); } else if (n < 100) { …...
2024/4/28 8:18:17
吃掉LeetCode之2022/2/5
吃掉LeetCode之2022/2/5 目录吃掉LeetCode之2022/2/5121. 买卖股票的最佳时机代码思路：75. 颜色分类代码思路：64. 最小路径和代码思路：121. 买卖股票的最佳时机给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票…...
2024/4/28 13:05:21
Dart VM 的相关简介与运行模式解析，一个Android程序员的腾讯面试心得
一个后台 JIT 编译器线程；GC sweeper 现场；并发 GC marker 线程； VM 在内部使用线程池 (dart::ThreadPool) 来管理 OS 线程，并且代码是围绕 dart::ThreadPool::Task 概念而不是围绕 OS 线程的概念构建的。例如在 GC VM 中将 da…...
2024/4/28 23:17:33
相对路径和绝对路径（简单易懂）
相对路径：从一个目录为起点到另外一个的目录的路径。举例： 比如你的C盘有一个文件夹叫FIle，文件下有两个文件file one 和 file two 表示出file two的方法有两种第一种（绝对路径表示法）：C：\FIle…...
2024/4/28 21:28:25
【动手学深度学习】week 11b | 全连接神经网络（FCN）
48 全连接神经网络（FCN） FCN是用深度学习来做语意分割的奠基性工作。用转置卷积层来替换CNN最后的全连接层，从而可以实现对每个像素的预测。传统的全连接层和全局平均池化层，没法获得空间信息。转置卷积层会把最后卷积的输出扩…...
2024/4/28 13:36:33
【LeetCode】9. 回文数
题目：9. 回文数给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。例如&#xff0…...
2024/4/28 20:34:29
授权规则
...
2024/4/28 18:00:13
常用工具-持续更新
图片类 postimage图片托管：上传本地图片到网站，自动生成链接进行访问，用于编写blog文档所需图片的插入，以防止本地化图片位置更改或删除后无法访问。...
2024/4/28 14:06:44
什么叫API？
API（Application Program Interface）即应用程序编程接口整个JDK的类库就是一个javase的API 每一个API都会配置一套API帮助文档 SUN公司提前写好的这套类库就是API。（一般每一份API都对应一份API帮助文档。）...
2024/4/28 14:10:56
lbp哈哈
...
2024/4/28 18:26:19
vscode markdown 导出PDF错误
1. 错误提示：“princexml” is required to be installed. 2. 解决：需要安装 prince sudo dpkg -i prince_14.2-1_ubuntu20.04_amd64.deb 预览，右键选择PDF(prince)即可。安装的插件： Markdown All in One， Ma…...
2024/4/28 0:49:05

JAVA课堂随记5面向对象