JAVASE学习 面向对象初学

0x00 

本篇大纲,计划是分成几天来学,这几天要期末复习了

JAVAd的核心思想就是OOP(面向对象)

(看到接口我很兴奋

0x01 初始面向对象

属性+方法就是一个类

先有类再有对象,类是对象的模板

0x02 回顾方法

方法的调用

调用非静态方法

调用了student类中的非静态方法

 

静态方法:

形式参数和实际参数

 

值传递

引用传递

0x03 类与对象的关系

 

创建与初始化对象

 

先有个主类,在这个Application主类中有唯一的main方法

然后还有一个学生类

构造器

构造器也叫构造方法

构造器的几个特点:

0x04 创建对象和内存分析

第一步:加载Application这个类,里面有个main方法和一些常量

第二步:new的时候加载宠物类(生成这个模板),加载里面的属性和方法

第三步:生成一个实例dog,引用变量名dog放到了栈里,在堆里放了变量名dog引用的实例

                                                              这个时候name还是null

第四步:原来在第一步里加载的常量比如旺财,(值传递)传给了堆里的dog,这个时候dog里的属性才有值

 

引用变量名就是指向堆中的实例

 

静态方法区中关键字static定义的静态方法,会和类一起加载

    这个图一定要理解!

0x05 简单小结类和对象

                  

     封装,继承,多态

0x06 封装

高内聚:类的内部数据操作细节自己完成,不允许外部干涉

低耦合:仅暴露少量方法给外部使用

属性私有:get/set

package OOP.OOP.Demo04;

public class Student {
    //封装多对于属性:封装的核心在于私有

    //属性私有
    private String name;
    private int age;
    private char sex;

    //提供一些可以操作这些私有属性的方法
    //提供一些public的get,set方法
    //get 获得这个数据
    public String getName(){
        return this.name;//可以获取到这个私有属性name
    }

    //set 给这个数据设置属性
    public void setName(String name){
        this.name = name;
    }
    //alt + insert 可以自动生成get,set方法

    //通过内部的封装给set设置安全性验证的判断
    public void setAge(int age) {
        if(age>120||age<0){
            this.age = 3;
        }else{
            this.age = age;
        }
    }

    public int getAge() {
        return age;
    }
    /*
        封装的意义:
        1.提高程序的安全性,保护数据
        2.隐藏代码的实现细节
        3.统一接口
        4.提高程序的可维护性
    * */
}

                                                                                                                                        

补充:println方法里面写了很多重载方法

0x07 什么是继承

要想办法对类再进行抽象,所以出现了继承,对类再次进行细分抽象

 

继承就是拓展,是子类对父类的拓展

学生:派生类,字类

                                                                                      

  一个爸爸能有多个儿子,但是一个儿子只能有一个爸爸:单继承

Person.java

package OOP.OOP.Demo05;

//Java中,所有的类都默认继承object类
//父类 人
public class Person {
    public void say(){
        System.out.println("收了一句话");
    }
    public int money = 1000000000;
    //ctrl+h 打开继承树
}

Student.java

package OOP.OOP.Demo05;

//学生 is 人
public class Student extends Person{

}

Application.java

package OOP.OOP;

import OOP.OOP.Demo05.Student;

public class Application {
    public static void main(String[] args) {

        Student s1 = new Student();

        //子类可以继承父类的所有方法和属性,前提是public修饰符
        s1.say();
        System.out.println(s1.money);

    }
}

super

super可以和this对比,一个代表父,一个代表当前的

  方法也可以用super调用

                                                                              

但是如果父类的方法用private构造会不能访问

 

 

super(); 能调用父类的构造器,必须要在子类构造器的第一行

 

0x08 方法的重写

重写都是方法的重写,和属性无关

静态方法(static)的调用只和左边,定义的数据类型有关(和多态有关系)

重写只和非静态方法有关

 

可以alt+insert来直接构建重写方法

下面用非静态方法演示重写

 

 

0x09 什么是多态

多态,可以实现程序的动态编译,可以让可扩展性更强

Application方法

package OOP.OOP;

import OOP.OOP.Demo06.Person;
import OOP.OOP.Demo06.Student;

public class Application {
    public static void main(String[] args) {

        //一个对象的实际类型是决定的
        //new Student();
        //new Person();

        //可以指向的引用类型就不确定了:父类的引用指向子类
        Student s1 = new Student();
        //Student 能调用的方法都是自己的或者继承父类的
        Person s2 = new Student();
        //Person 父亲类,可以指向字类,但是不能调用子类独有的方法
        Object s3 = new Student();


        //对象能执行哪些方法,主要看对象左边的类型,和右边关系不大
        //强转类型从
        ((Student) s2).run();
        s1.run();


    }
}

 

static,final,private方法无法实现重写,更别谈多态了

引用一般指父类,或者有关系的类

 

0x010 instanceof 和类型转换

instanceof关键字,判断是否属于

 

如果没有关系,就会报错

 

类型的转换

Application.java

package OOP.OOP;

import OOP.OOP.Demo06.Person;
import OOP.OOP.Demo06.Student;
import OOP.OOP.Demo06.Teacher;

public class Application {
    public static void main(String[] args) {
       //类型之间的转换:父 子

        //高     转     低
        Person obj = new Student();

        //student将这个对象转换为Student类型,我们就可以使用Student类型的方法了!

        Student student = (Student) obj;
        //go方法在student类型里
        //将这个类转为student类型,就能使用Student里的方法了
        
        student.go();
    }
}

 

但是如果子类要转换为父类,向上转,就可能会丢失自己本来的一些方法

 

0x011 static关键字详解

静态属性和方法

只能Stunent.age,调用静态的变量

 

 

非静态方法可以调用静态方法

静态方法只能调用静态方法,因为static在类加载的时候一起载了,这个时候没有加static的东西还没有被实例化加入内存

这些都和类的加载顺序有关

静态代码块

package OOP.OOP.Demo07;

public class Person {
    {
        //代码块(匿名代码块)
        System.out.println("匿名代码块");
    }

    static {
        System.out.println("静态代码块");
    }

    public Person(){
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person p1 = new Person();
        System.out.println("++++++++++++++++++++++++");
        Person p2 = new Person();
    }
}

输出如图:

 

所以静态代码块只加载一次

 

静态导入包

 

修饰符final

被final修饰的不能被继承

 

0x012 抽象类

关键字abstract

 

Action.java

package OOP.OOP.Demo08;

//抽象类:类 extends:单继承         (但是接口可以实现多继承)类比于插座
public abstract class Action {

    //约束    有人帮我们实现
    //abstract 抽象方法,只有方法的名字,没有方法的实现
    public abstract void doSomething();

    //抽象类的特点:
    //1. 不能new出来,只能靠子类去实现它; 对子类实现约束
    //2. 抽象类中可以写普通方法
    //3. 抽象方法必须在抽象类中
    //抽象的抽象:就是约束
    
}

 

A.java

package OOP.OOP.Demo08;

//抽象类的所有方法,继承了他的子类必须要实现他的方法,除非他的子类也是抽象类。。。
public class A extends Action{
    //继承抽象类,必须要重写抽象类的方法
    @Override
    public void doSomething(){

    }
}
  1. 有抽象方法的类一定是抽象类

  2. 是抽象的类不一定要有抽象方法

  3. 无法通过new实例,通过继承

  4. 子类必须实现所有的父类抽象方法,否则也要注明abstract

思考题

抽象类存在构造器吗

答:存在的,给子类用的,即使你没有提供任何构造函数,编译器将为抽象类添加默认的无参数的构造函数,没有的话你的子类将无法编译,因为在任何构造函数中的第一条语句隐式调用super()。

 

抽象类存在的意义:

答:抽象出来必须要实现的东西,提高开发效率,进行约束

 

0x013 接口

interface关键字

 

TimeService接口

package OOP.OOP.Demo09;

public interface TimeService {
    void timer();

}

 

UserService接口

package OOP.OOP.Demo09;

//锻炼抽象的思维
public interface UserService {
    //接口中的所有定义方法都是抽象的,都是public abstract的
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
    //接口中定义的属性都是常量public static final
    int AGE = 99;

}

UserServiceImpl

调用接口的类

package OOP.OOP.Demo09;

//接口可以多继承
//接口的实现类,用Impl来命名结尾,来实现UserService接口
//实现了接口的类,就需要重写接口中的方法
public class UserServiceImpl implements UserService,TimeService{
    //利用接口实现多继承
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}

 

接口的一些作用:

1.约束

2.定义一些方法,让不同的人实现

3.public abstract

4.public static final

5.接口不能被实例化,接口中没有构造方法

6.implements可以实现多个接口

7.必须要重写接口中的方法

 

0x014 内部类

内部类就是在一个类的内部再定义一个类

正常内部类

package OOP.OOP.Demo10;

public class Outer {
    private int id;
    public void out(){
        System.out.println("外部类的方法");
    }

    public class Inner{
        public void in(){
            System.out.println("内部类的方法");
        }
    }

    //获得外部类的私有属性
    public void getID(){
        System.out.println(id);
    }
}

++++++++++++++++++++++++++++++++++++++++++++++++

package OOP.OOP;


import OOP.OOP.Demo10.Outer;

public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
        //通过这个外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();
    }
}

静态内部类无法访问外类中的方法

 

局部内部类

package OOP.OOP.Demo10;

public class Outer {
    //局部内部类
    public void method(){

        class Inner{
            public void in(){
                
            }
        }
    }
}

//一个java类中可以有多个类,但是只能有一个public类
class A{
    public static void main(String[] args) {

    }
}

 

下面的看懂即可

package OOP.OOP.Demo10;

public class Test {
    public static void main(String[] args) {
        //没有名字初始类
        new Apple().eat();
        
        UserService userService = new UserService() {
            @Override
            public void hello() {
                
            }
        };
    }
}
class Apple{
    public void eat(){
        System.out.println("1");
    }
}
interface UserService {
    void hello();
}

 

 

 

 

 

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值