JAVA基础-面型对象

java_白小纯

已于 2022-10-05 22:07:07 修改

阅读量735

点赞数

分类专栏： JAVASE基础部分文章标签： java 开发语言

于 2022-09-19 13:20:16 首次发布

本文链接：https://blog.csdn.net/weixin_42497022/article/details/126931680

版权

JAVASE基础部分专栏收录该内容

9 篇文章 0 订阅

订阅专栏

1.面向对象

面向过程:开发一个个方法,有需求就调用来处理

面向对象,开发一个个对象,把数据交给对象,再调用对象完成对方法的处理

面向对象的好处:

1.更加符合懒人思维,

2,将复杂的事情简单化

3,将任务的执行者变成指挥者

面向对象的步骤:

1.找到所在的类 (导包)

2.创建对象 (找到具体的对象)

3.调用方法 (解决问题)

对象中的方法不能够使用static修饰

面向对象有三大特性:封装,继承,多态

2.封装性

封装定义:封装就是用类设计对象处理某一个事物的数据时,应该把要处理的数据,以及处理这些数据的方法设计到一个对象中去,

2.设计规范

合理隐藏,合理暴露

1.类的名字必须是Public

2.成员变量必须是private

3.每一个成员变量必须有get和set方法

2.1 this关键字

1.就是一个变量,可以在方法中,拿到当前对象,哪个对象调用方法,this就指向哪个对象,也就是拿到哪个对象

2.在开发中用来解决成员变量与局部变量名称一样时访问冲突导致的问题

2.2构造器

注意事项:

1.在类的设计时,java通常会给我们自动生成一个空参构造器

2.一旦类以了有参构造器,就不会帮我们生成无参构造器,此时建议手写出一个空参构造器

3.构造方法也可以重载

构造器应该满足的规则:

1.权限修饰符不能使用static修饰

2.构造器的名称和类一致

3.构造器没有返回方法,连void也不能有

4.参数列表和普通方法没有查询,可以有参数也可以无参数

5.构造方法和成员变量都属于类的成员

构造器的作用:

1.创建对象

2.在创建对象的同时给成员变量初始化

2.3成员变量和局部变量的区别

成员变量:在类中,在方法外

局部变量:只能在(),或者方法的()中

3.继承

继承的定义:子类中具有父类的属性和方法,但是子类可以重新定义(属性,方法)

Class A extends B {
	
}
代表A继承B类,       子类:派生类   父类:基类,超类 
java中只能单继承

继承的好处:

1.提高了代码的复用性

2.提高的代码的维护性

继承的缺点:削弱了子类的独立性

子类所有的构造方法,都会默认访问父类的无参数方法

3.1super

通过super访问父类的属性以及方法

Super.属性/super.方法

3.2重写

子类在继承父类的方法后,可以对方法进行重写.

没有重写,但是还是回默认有父类的方法.

4.多态

定义:同一个对象在不同的时刻表现出来的状态

多态的前提

1.有类的继承/实现关系

2.有方法重写

3.父类引用指向子类引用

成员变量访问特点编译看左边,执行看左边

成员方法访问特点编译看左边,执行看右边

父类
public class Person {
    int age=20;
    public void  show (){
        System.out.println("父类的方法");
    }
}
子类和测试类
public class Student extends Person {
    int age=6;

    @Override
    public void show() {
        System.out.println("子类的方法");
    }
}
class Test{

    public static void main(String[] args) {
        Person person=new Student();
        //成员变量,编译看左边,执行看左边
        System.out.println(person.age);
        //成员方法编译看左边,执行看右边
        person.show();
    }
}

多态的好处

1.提高了程序的扩展性

具体的体现:定义方法的时候,使用父类作为参数,将来使用的时候,使用子类的操作类型

缺点:不能拥有子类特有的功能

多态的使用

父类
public class Animl {
    public void eat(){
        System.out.println("动物吃东西");
    }
}
子类
public class Dog extends Animl{
    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }
    public void fit(){
        System.out.println("狗叫");
    }
}
实现类
public class Op {
    public  void eat(Animl A){
        A.eat();

    }
}
测试类
class test{

    public static void main(String[] args) {
        Op op=new Op();
        Dog dog=new Dog();
        op.eat(dog);

    }
}

4.1多态的转型

父类
public class Person {
    int age=20;
    public void  show (){
        System.out.println("父类的方法");
    }
}
子类
public class Student extends Person {
    int age=6;

    @Override
    public void show() {
        System.out.println("子类的方法");
    }
    public void eat(){
        System.out.println("学生吃东西");
    }
}
测试类
class Test{

    public static void main(String[] args) {
        //向上转型
        Person person=new Student();
        //成员变量,编译看左边,执行看组边
        System.out.println(person.age);
        //成员方法编译看左边,执行看右边
        person.show();

        //向下转型
        Student person1 = (Student) person;
        person1.eat();
    }
}

5.修饰符

5.1权限修饰符

5.2状态修饰符

5.2.1静态的static

作用:可以修饰成员方法,成员变量

调用方式,类名,对象名,推荐使用类名调用

修饰变量:

静态成员变量,所有都共享

修饰方法,方法就变成静态的,静态的成员方法只能访问静态的成员

非静态方法可以访问,静态,非静态的成员方法和变量

静态方法只能访问静态的成员方法和变量

5.2.2最终的final

作用修饰方法,变量,类.

1.修饰方法,方法能被继承, 无法重写

2.修饰成员变量,变量无法被修改

3.修饰类无法被继承

4.修饰局部变量如果是基本数据类型数据值无法改变

如果是引用数据类型数据地址值无法更改,但是内容可以更改

6.抽象类

在Java中,一个没有方法体的方法应该定义为抽象方法,类中如果有抽象方法,该类为抽象类

//抽象类
public abstract  class Animal
{
    //抽象方法
    public  abstract  void eat();
    public void shot(){
        System.out.println("叫");
    }
}

class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃东西");
    }

   /* @Override
    public void shot() {
        System.out.println("狗叫");
    }*/
}
class test{
    public static void main(String[] args) {
        Animal A=new Dog();
        //编译看左边,执行看右边
        A.eat();
        A.shot();

    }

}

注意,抽象类中不一定有抽象方法,但是有抽象方法的一定是抽象类

抽象类不能实例化,参照多态的形式,通过子类的实例化,这就叫抽象类多态

抽象类的子类,要么重写抽象类的所有抽象方法,要么自己是一个抽象类

6.1抽象类的成员变量

成员变量:可以是变量,也可以是常量

构造方法:有构造方法,但是不能实例化,用于子类访问父类数据的初始化.(子类继承父类后成员方法会访问无参构造)

成员方法:可以有抽象方法,限定子类必须完成

非抽象方法,提高代码的复用性

7.接口

接口:就是一种公共的规范标准,只要符合规范,大家都通用

java中的接口更多的体现在行为的抽象

接口的特点:

public interface 接口名字{}
//接口实例化
public class 类名 implements 接口名{};

接口不能够直接实例化,参照多态实例化,通过对象的实例化,这叫接口多态

多态的形式:具体类多态,抽象类多态,接口多态

多态前提,有继承或者接口实现,有方法的重写 , 有父类引用指向子类的对象.,有父接口引用指向实现类对象

接口的实现:

要么重写接口中所有的抽象方法,

要么是抽象类

7.1接口成员特点

成员变量:

接口中的变量是公共的静态的常量

构造方法:

接口中没有构造方法,

成员方法:

只能是抽象方法public abstract

7.2类和接口的关系

类和类的关系

只能单继承,但是可以多层继承

类和接口的关系

实现关系,类可以实现多个接口用,分隔开

接口和接口的关系:

继承关系,可以单继承,也可以多继承

7.3抽象类和接口的区别

7.4jdk8新增

public interface Myiner {
    //默认方法
    public default void  show(){

    }
    //静态方法  通过接口名字.静态方法调用
    public static void show2(){
       
    }
    //私有方法
    private void show3(){}
    private static void show4(){}
}

8.内部类

内部类:就是在A类中定义的类

内部类访问的特点:

内部类可以直接访问外部的成员,包括私有的.

外部类:要访问内部的对象必须创建方法

ublic class Test {
    public static void main(String[] args) {
        A a =new A();
        a.showA();
    }
}
class A {
    private int Anumber = 20;
    //外部类访问内部类的成员必须创建对象
    public void showA() {
        B b = new B();
        b.showB();
        System.out.println(b.bnumber);
    }
    class B {
        //内部类可以访问外部的成员
        int bnumber=10;
        public void showB() {
            System.out.println(Anumber);
            //showA();
            System.out.println(bnumber);
        }
    }
}

8.1局部内部类

局部内部类是在方法中定义的类，所以外界是无法直接使用，需要在方法内部创建对象并使用

该类可以直接访问外部类的成员，也可以访问方法内的局部变量


public class OuterTest {
    public static void main(String[] args) {
        Outer outer=new Outer();
        outer.methd();

    }
}
class Outer{
    private  int outernum=10;
    public void methd(){
        int num=20;
        //在方法中定义了局部内部类
      class  Inner{
          public void show(){
              System.out.println(outernum);
              System.out.println(num);
          }
      }
      //在内部方法中创建对象调用内部方法
      Inner inner=new Inner();
      inner.show();
    }
}

8.2成员内部类

格式：外部类名.内部类名对象名 = 外部类对象.内部类对象;

范例：Outer.Inner oi = new Outer().new Inner();

public class Test {
    public static void main(String[] args) {
   //外部类名字.内部类名   对象名字=外部类对象.内部类对象
      /*  Outer.inner inner=new Outer().new inner();
      inner.showInner();*/
        //使用外部方法调用
        Outer outer=new Outer();
        outer.show();
    }
}

class Outer {
    private int num = 10;
     //成员内部类
    /* class inner {
        public void showInner() {
            System.out.println(num);
        }
    }
*/

   private class inner {
        public void showInner() {
            System.out.println(num);
        }
    }
    //在方法中调用私有的内部类
    public void show (){
       inner inner=new inner();
       inner.showInner();
    }

}

8.3匿名内部类

前提:存在一个类或者接口，这里的类可以是具体类也可以是抽象类


public interface Inter {
    public void show();
}

class Outer {
    public void method() {
        //创建匿名对象
       /*new Inter() {
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        }.show(); //调用方法*/
              //多态的方式进行创建
        Inter i = new Inter() {
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        };
      i.show();
    }
}

class Test {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.method();
    }
}

9.Lambda

 //lambda
        UseInter(() -> {
            System.out.println("lambda");
        });
    }

三要素;形式参数,箭头,代码块

():表示里面没有参数列表如果有多个参数用,隔开,没有参数就空着

->b:表示后面要做的事情固定写法,代表指向的动作

{}:可以看成方法体,代码块具体要做得事情

标准格式

(形式参数)->{代码块}

小结拿着形式参数去做代码块中的事情

使用前提:有一个接口,

接口中只能有一个抽象方法

9.1无参数,无返回值

public interface Eatable {
    void eat();
}
public class T1 {
    public static void main(String[] args) {
          //匿名内部类
        uesEatable(new Eatable() {
            @Override
            public void eat() {
                System.out.println("匿名内部类");
            }
        });
		
        //lambda
       uesEatable(()->{
           System.out.println("lambda");
       });

    }
	//定义一个接口的实现方法
    public static void uesEatable(Eatable e){
        e.eat();
    }
}

9.2有参数无返回值

public interface Fly {
    //有参数
    void fly2(String S);
}
public class Test2 {
    public static void main(String[] args) {
        uerfly((String S)->{
            System.out.println(S);
            System.out.println("飞起来");
        });

    }
    //接口的实现方法           存放接口类  参数
    public static void uerfly(Fly f){
		参数.接口中的方法
        f.fly2("飞");
    }
}

9.3有参数有返回值

public interface Addable {
   int add(int x, int y) ;
}
public class Tes3 {
    public static void main(String[] args) {
        userAddable((int x, int y) -> {

            return x+y;
        });

    }

    //定义接口的实现
    public static int userAddable(Addable a) {
        int add = a.add(15, 2);

        System.out.println(add);
        return add;
    }
}

9.4省略模式

//定义一个有参数有返回值的接口
public interface Add {
    int add(int x,int y);
}
//定义一个又参数,无返回值的接口
public interface Fly {
    void  fly(String S);
}
//创建接口的实现
public  static void   useFly(Fly f){
	f.fly("郑涛在飞");
}
//创建接口的实现
public static  int uesAdd(Add a){
	int add = a.add(15, 15);
System.out.println(add);
return add;
}

//主函数里面实现有参数无返回值
useFly((String S)->{
	System.out.println(S);
});
//使用省略模式后
1.省略参数
useFly((S)->{
	System.out.println(S);
});
2.参数只有一个可以省略括号
useFly(S)->{
	System.out.println(S);
});	
3.代码块语句只有一条可以省略;和{}
useFly(S)->System.out.println(S));	


//主函数里面实现有参数,有返回值
uesAdd((int x,int y)->{
	return x+y;
});
//使用省略模式后
1.省略参数
uesAdd((x,y)->{
	return x+y;
});	
2.省略;{}和return
uesAdd((x,y)->x+y);

9.5匿名内部类和lambda比较

1.类型不同
lambda只能修饰接口
匿名内部类可以修饰接口,抽象类,具体类
2.使用限制不同
如果接口中只有一个抽象方法,可以使用两者
如果接口中有两个以上的抽象方法就只有使用匿名内部类
3.实现的原理不用
匿名内部类会在编译之后产生一个.class文件
Lambda	编译之后,对应的字节码在运行的时候回动态生成

//定义一个接口
public interface Fly {
    void fly();
}
//定义抽象类
public abstract class Phone {
    //定义抽象方法
   public abstract void tallk();
}
//定义一个具体的类
public class Student {
    public void eat(){
        System.out.println("吃");
    }
}


    //定义接口的实现
    public static void useFly(Fly f) {
        f.fly();
    }

    //定义抽象类的实现
    public static void usePhone(Phone p) {
        p.tallk();
    }

    //定义具体类的实现
    public static void useStudent(Student s) {
        s.eat();
    }
 //采用匿名内部内的情况实现  接口,抽象类,具体类
        useFly(new Fly() {
            @Override
            public void fly() {
                System.out.println("接口");
            }
        });
        usePhone(new Phone() {
            @Override
            public void tallk() {
                System.out.println("抽象类");
            }
        });
        useStudent(new Student(){
            @Override
            public void eat() {
                System.out.println("具体类");
            }
        });

//采用lamdba实现接口
        useFly(()-> System.out.println("lambda"));
       //usePhone(()-> System.out.println("抽象类"));
      // useStudent(()-> System.out.println("抽象类"));