面向对象&匿名对象&内部类
面向对象
1、定义：
面向对象的思想是把一个项目、一件事情分成更小的项目，或者说分成一个个更小的部分，每一部分负责什么方面的功能，最后再由这些部分组合而成为一个整体。（找合适的人做合适的事情）
2、面向对象思想
（1）面向对象是基于面向过程的编程思想
（2）万物皆对象
（3）对象具有唯一性
（4）任何对象都具有一定的特征和行为，特征是事物的基本描述，行为是事物的功能
（5）类是一组相关的属性和方法的集合，是一个抽象的概念
（6）对象是类的具体存在
（7）在一组相同或相似的对象中，抽取出共性的特征和行为，保留所关注的部分就是类的抽取
（8）类是模板、图纸，通过类创造的对象就是实体
3、面向对象的优点：
（1）直观、高效、与人类的思维习惯一致
（2）信息隐藏，提高了程序的可维护性和安全性
（3）提高了程序的可重用性
类和对象
-
类是对象的抽象，对象是类的具体实现。
-
类是对某一类事物的描述，是抽象的、概念上的定义。类是模板，包含了一类事物所共有的特征（即属性） 和行为（即方法）。
3.对象是类的具体体现（属性和方法），是具体的、独一无二的个体。
类的定义：类是一种自定义的数据类型。
格式：
class 类名{
成员变量;//Field
成员方法;//Method
}
解析：class：定义类的关键字
类名：大驼峰原则，见名知意；类名是一种数据类型（即自定义引用的数据类型），就是模板的名字
成员变量（属性/特征描述）：定义在类中，方法外的变量，用来描述类的特征
成员方法（行为描述）：定义在类中，用来描述类的功能
class Student{
//成员变量
String name;
int age;
char sex;
//成员方法
public void eat() {
System.out.println("吃");
}
public void sleep() {
System.out.println("睡");
}
public void play() {
System.out.println("玩");
}
}
对象的创建
参考扫描器Scanner的创建
Scanner sc=new Scanner(System.in);
格式：
类名 对象名 =new 类名([参数...]);
对象的使用
参考数组和Scanner的使用
//数组：
int[] array = new int[10];
array.length// 注意：这里没有 ()，说明这不是方法，我们用它来表示数组的长度，数组的长度是数组的一个属性
//Scanner
Scanner sc = new Scanner(System.in);
sc.nextInt();
格式：
使用成员变量：
对象名.成员变量
使用成员方法：
对象名.成员方法()
.的含义是"的"
扩展：如果直接打印对象名，会得到一个对象的【地址】
这个地址包含两部分：1、完整的包名；2、当前对象存储在堆区内存中的空间首地址。
// 通过Student类对象student操作name、sex、age属性
// 进行赋值操作
student.name = "张三";
student.age = 25;
student.sex = '男';
// 通过person进行取值操作
System.out.println(student.name);
System.out.println(student.age);
System.out.println(student.sex);
student.eat();
student.sleep();
student.play();
注意：大写开头的都是类，小写开头的都是变量，带()的都是方法
匿名对象
1、概述：没有名字的对象，是对象的一种简化表示形式
2、特性：一次性，每次使用都是一个新的对象
3、使用情景
1、对象调用方法仅使用一次，然后等待销毁
2、作为实际参数传递
4、优点：提高开发效率，简化代码结构
public class TestDog{
public static void main(String[] args) {
// 对象调用方法仅使用一次
new Dog().sleep();
// 作为实际参数传递
useDog(new Dog());
}
public static void useDog(Dog dog) {
dog.sleep();
}
}
class Dog {
String name;
int age;
public void sleep() {
System.out.println("小狗睡觉.....");
}
}
形参和返回值
1.类名作为形参和返回值
1、方法的形参是类名，其实需要的是该类的对象
2、方法的返回值是类名，其实返回的是该类的对象
//猫类
public class Cat{
Public void eat(){
System.out.println("猫吃鱼");
}
}
//猫的操作类
public class CatOperator{
public void useCat(Cat c){// Cat c=new Cat();
c.eat();
}
public Cat getCat(){
Cat c=new Cat();
return c;
}
}
//测试类
public class CatDemo{
public static void main(String[] args){
//创建操作类对象
CatOperator co=new CatOperator();
Cat c=new Cat();
co.useCat(c);
Cat c2=co.getCat();//new Cat();
c2.eat();
}
}
---------------------------------------------------
猫吃鱼
猫吃鱼
2.抽象类名作为形参和返回值
//抽象类
public abstract class Animal{
public abstract void eat();
}
//
public class Cat extends Anmial{
@Overide
public void eat(){
System.out.out("猫吃鱼");
}
}
//操作类
public class AnimalOperator{
piblic void useAnimal(Animal a){
a.eat();
}
}
//测试类
public class AnimalDemo{
public static void main(String[] args){
AnimalOperator ao=new AnimalOperator();
Animal a=new Cat();
ao.useAnimal(a);
}
}
------------------------------------------------------
猫吃鱼
3.接口名作为形参作为返回值
1、如果方法的形参是一个接口名，其实所需要的是这个接口的实现类对象
2、方法富人返回值是一个接口名，其实所需要的是这个接口的实现类对象
//接口
public interface Jumpping{
void jump();
}
//接口的操作类
public class JumppingOperator{
public void useJumpping(Jumpping j){// Jumpping j=new Cat();
j.jump();
}
public Jumpping getJumpping(){
Jumpping j=new Cat();
return j;
}
}
//猫类
public class Cat implements Jumpping{
@Override
public void jump(){
System.out.println("猫可以跳高了");
}
}
//测试类
public class JumppingDemo{
public static void main(String[] args){
//创建操作类和对象，并调用方法
JumppingOperator jo=new JumppingOperator();
Jumpping j=new Cat();
jo.useJumpping(j);
//ctrl alt v
Jumpping j2= jo.getJumpping();//new Cat();
j2.jump();
}
}
-------------------------------------------------------------------------
猫可以跳高了
猫可以跳高了
4.内部类
1.概念：就是在一个类中定义一个类
（在一个类A的内部定义一个类B，则类B就被称为内部类）
2、格式
public class 类名{
修饰符 class 类名{
}
}
3、内部类的访问特点
（1）内部类可以直接访问外部类的成员，包括私有
（2）外部类要访问内部类，必须创建对象
4、举例
public class Outer{
private int num=10;
public class Inner{
public void show(){
System.out.println(num);
}
}
public void method(){
Inner i=new Inner();
i.show();
}
}
5.成员内部类和局部内部类
1、分类
在类的成员位置：成员内部类
在类的局部位置：局部内部类
2、成员内部类，外界是如何创建对象使用
格式：外部类名.内部类民 对象名=外部类对象.内部类对象
3、举例
//成员内部类
//内部类
pubilc class Outer{
private int num=10;
/**
public class Inner{
public void show(){
System.out.println(num);
}
}
**/
private class Inner{
public void show(){
System.out.println(num);
}
}
public void method(){
Inner i=new Inner();
i.show();
}
}
//测试类
public class InnerDemo{
public static void main(String[] args){
//创建内部类对象
/**
Outer.Inner oi=new Outer().new Inner();
oi.show();
**/
//创建外部类对象
Outer o=new Outer();
o.method();
}
}
----------------------------------------------------------------------
10
//局部内部类
//内部类
public class Outer{
private int num=10;
public void method(){
int num2=20;
class Inner{
public void show(){
System.out.println(num);
System.out.println(num2);
}
}
Inner i=new Inner();
i.show();
}
}
//测试类
public class OuterDemo{
public static void main(String[] args){
Outer o=new Outer();
o.method();
}
}
--------------------------------------------------------------------------
10
20
6.匿名内部类(局部内部类)
前提：存在一个类或者接口，这里的类可以是具体类也可以是抽象类
1.格式
new 类名或者接口名(){
重写方法;
}
//内部类
public class Outer{
public void method(){
Inter i= new Inter(){
@Override
public void show(){
System.out.println("匿名内部类");
}
};
i.show();
i.show();
/**多次调用
new Inter(){
@Override
public void show(){
System.out.println("匿名内部类");
}
}.show();**/
}
}
//接口
public interface Inter{
void show();
}
//测试类
public class OuterDemo{
public static void main(String[] args){
Outer o=new Outer();
o.method();
}
}
--------------------------------------------------------
匿名内部类
匿名内部类
7.匿名内部类在开发中的使用
//接口
public interface Jumpping{
void jump();
}
//接口的操作类
public class JumppingOperator{
public void method(Jumpping j){//new Cat();
j.jump();
}
}
//猫类
public class Cat implements Jumpping{
@Override
public void jump(){
System.out.println("猫可以跳高了");
}
}
//猫类
public class Dog implements Jumpping{
@Override
public void jump(){
System.out.println("狗可以跳高了");
}
}
//测试类
public class JumppingDemo{
public static void main(String[] args){
JumppingOperator jo=new JumppingOperator();
Jumpping j=new Cat();
jo.method(j);
Jumpping j2=new Dog();
jo.method(j2);
System.out.println("===============");
jo.method(new Jumpping(){
@Override
public void jump(){
System.out.println("猫可以跳高了");
}
});
jo.method(new Jumpping(){
@Override
public void jump(){
System.out.println("狗可以跳高了");
}
});
}
}
----------------------------------------------------
猫可以跳高了
狗可以跳高了
===============
猫可以跳高了
狗可以跳高了
浙公网安备 33010602011771号