数据类型

基本数据类型 1.整数: byte1 short2 int4 long8

2.浮点数: float4 double8

3.字符: char2

4.布尔值: boolean1

引用数据类型 1.类 2.接口 3.数组

变量和常量

变量作用域 1.类变量static 2.实例变量 3.成员变量,局部变量

命名

1.类,首字母大写,驼峰 2.常量: 大写+下划线

类

面向对象编程的本质: 以类的方法组织代码,以对象的组织(封装)数据

1.类是一种抽象的数据类型,是对一类事物整体描述/定义,但是并不能代表某一个具体的事物

2.类里面只有属性和方法

使用new关键字创建时,除了分配内存空间之外,还会给创建好的对象进行默认的初始化,以及对类中构造器的调用

// 类实例化
new Student();
// 类实例化后会返回一个自己的对象!
Student student = new Student();
---------------------------------------------
public class Application{
    public static void main(String[] args) {

        // student对象就是Student类的具体实例
        Student xiaoming = new Student();
        Student xiaobai = new Student();

        xiaoming.name = "小明";
        xiaoming.age = 3;

        System.out.println(xiaoming.name);
        System.out.println(xiaobai.age);


        xiaobai.name = "小白";
        xiaobai.age = 3;
        System.out.println(xiaobai.name);
        System.out.println(xiaobai.age);

    }
}
--------------------------------------------------------------------
// 学生类
public class Student {

    // 属性: 字段
    String name;
    int age;

    // 方法
    public void study(){
        System.out.println(this.name+"在学习");
    }
}

对象

1.对象是抽象概念的具体实例,能体现出特点,展现出功能的是具体的实例,而不是一个抽象的概念对象是具体的事物,类是抽象的,类是对象的模板

2.对象是通过引用来操作的：栈－－＞堆（地址）

3.对象属性：字段field ,成员变量

默认初始化:

int,double : 0,0.0

char: u0000

boolean: false

引用类型: null

对象的创建和使用

必须使用new关键字创造对象,构造器 Person jiapeidong = new Person();
对象的属性 jiapeidong.name
对象的方法 jiapeidong.sleep()

方法

修饰符返回值类型方法名(参数)

public String sayHello(){
    // 方法体
    // 返回值
    return"hello World"
}

静态方法被static修饰,类加载的时候就是生成

public class Demo01 {
    public static void main(String[] args) {
        //实例化这个类new
        //对象类型 对象名 = 对象值;
        Student student = new Student();
        student.say();
    }
}

形参和实参

public class Demo03 {
    public static void main(String[] args) {
        // 实际参数和形式参数的类型要对应
        int add = new Demo03().add(1, 2);
        System.out.println(add);
    }

    public int add(int a,int b){
        return a+b;
    }
}

传递

// 引用传递 传递对象,本质还是值传递
public class Demo05 {
    public static void main(String[] args) {
        // 使用下面的类
        Person person = new Person();
        System.out.println(person.name);

        Demo05.change(person);
        System.out.println(person.name);
    }
    public static void change(Person person){
        // person是一个对象,指向的是--->Person person = new Person(); 这是一个具体的人可以改变属性
        person.name = "贾培东";
    }
}
// 定义了一个Person类,有一个属性:name
class Person{
    String name; //默认值为null
}

构造函数

类中的构造器也称为构造方法,是在进行创建对象的时候必须要调用的.

1.构造器必须和类的名字相同

2.没有返回值,也不能写void

作用:

new 本质是在调用构造方法
初始化对象的值

注意点:

1.定义了有参构造后,如果想要使用无参构造,需要显示的定义一个无参构造

public class Person {

    // 一个类即使什么都不写,也会存在一个方法
    // 显示定义构造器,无参构造
    String name;

    // 实例化初始值
    // 1. 使用new关键字, 本质是在调用构造器
    // 2. 用来初始化值
    public Person() {
    }
    // 有参构造,一旦定义了有参构造,无参构造就必须显示定义
    public Person(String name){
        this.name = name;
        }
        
    }
-------------------------------------------------------------------------

// 一个项目只存在一个mian方法
public class Application{
   public static void main(String[] args) {
       // new 实例化了一个对象
       Person person = new Person("贾培东");

       System.out.println(person.name);
//

封装

1.提高程序的安全性,保护数据

2.隐藏代码的实现细节

统一接口

系统可维护性增加

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

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

属性私有get/set

继承

1.继承的本质是对某一批类的抽象,从而实现对现实世界更好的建模

2.继承就是扩展的意思,子类是父类的扩展

3.单继承,一个子类只有一个父类,一个父类可以有多个儿子

super

注意点:

1.调用父类的构造方法,必须在构造方法的第一个

2.super 必须只能出现在子类的方法或构造方法中

3.super 和 this 不能同时调用构造方法

4.构造方法默认调用父类的构造

重写

需要有继承关系,子类重写父类的方法

子类的方法必须和父类必须要一致:方法体不同

1.方法名必须相同2.参数列表必须相同

3.修饰符: 范围可以扩大: Public>Protected>Default>Private

4.抛出异常: 范围可以缩小,但不能扩大

为什么需要重写:

1.父类的功能子类不一定需要,或者不一定满足

alt + inset : override

//方法的调用之和左边,定义的数据类型有关
A a = new A();
a.test();
// 父类的引用指向子类
B b = new A(); // 子类重写了父类的方法 
b.test();

多态

同一个方法可以根据发送对象的不同而采用多种不同的行为模式

多态是方法的多态,属性没有
父类和子类, 有联系类型转换异常! classCastException
存在的条件: 继承关系,方法需要重写
父类引用指向子类对象 father f1 = new Son();
把父类转换为子类,向下转型,需要强转会丢失精度
方便方法的调用,减少重复的代码

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

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

// 对象能执行哪些方法,主要看左边的类型,和右边关系不大
((Student) s2).eat(); // 子类重写了父类的方法,执行子类的方法
s1.run();

instanceof

判断一个对象是什么类型

Person obj = new Student();
   // 将student对象转换为Student类型,就可以使用Student类型的方法了
   Student student = (Student) obj;
   student.go();
   // 子类转换为父类,可能丢失自己本来的一些方法
}

static

静态代码块只执行一次

被static修饰的方法和属性,和类一起加载,不实例化类就可以直接调用

抽象类

// abstract 抽象类,本质是类需要被继承,需要extends: 单继承
public abstract class Action {

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

    // 1. 不能new出来,只能靠子类去实现,是约束
    // 2. 抽象类中可以写普通方法
    // 3. 抽象方法必须在抽象类中

 
}

接口

普通类: 只有具体实现

抽象类: 具体实现和规范

接口: 只有规范! 自己无法写方法, 约束和实现分离:面向接口编程

接口是面向对象的精髓,是对对象的抽象,最能体现这一点的就是接口

public interface UserService {
    // 接口中的所有定义都是抽象的 public abstract

    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}
---------------------------------------------------------------
// 类通过implements实现接口
// 实现了接口的类就需要重写类中的所有方法
// 利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService {

    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

作用:

定义一些方法,让不同的人实现
接口中默认的方法都是public abstract
所有的常量都是 public static final
接口不能被实例化,因为接口中没有构造方法
接口可以实现多个,必须要重写接口中的方法

内部类

// 内部类,加上static为静态内部类
public class Outer {

    private int id = 10;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    public  class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        // 获得外部类的私有属性,私有属性
        public void getID(){
            System.out.println(id);
        }
    }
}
----------------------------------------------------------

// 外部类来 new
Outer outer = new Outer();
// 通过外部类来实例化内部类
Outer.Inner inner = outer.new Inner();
inner.in();

局部内部类

 // 局部内部类
    public void method(){
        class Inner{
            public void in(){
                
            }
        }
    }
-----------------------------------------------

public class Outer {
    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();
   }

异常Exception

public class Demo01 {
    public static void main(String[] args) {
        // 递归调用
        new Demo01().a();
    }
    public void a(){
        b();
    }
    public void b(){
        a();
    }
}

检查性异常: 最具代表的是用户错误引起的异常
运行时异常: 有可能被程序员避免,在编译时会被忽略
错误ERROR: 脱离程序员控制,在代码中通常被忽略,例如栈溢出 Error类对象由Java虚拟机生成并抛出,大多数是虚拟机运行错误,这些错误是不可查的

OutOfMemoryError,栈溢出JVM会线程终止

NoClassDefFoundError,类定义错误 LinkageError,链接错误

Java把异常当作对象

定义一个基类java.lang.Throwable作为所有异常的超类,所有异常分为两类,Error和Exception

Exception

1.RuntimeException(运行时异常) 2.NullPointerException(空指针异常) 3.ArrayindexOutOfBoundsException(数组下标越界) 4.ArithmeticException(算数异常) 5.MissingResourceException(丢失资源) 6.ClassNotFoundException(找不到类)

异常处理

代码块快捷键 ctrl+alt+t

try { //try监控区域
    System.out.println(a/b);
}catch (ArithmeticException e){  //catch 捕获异常
    System.out.println("程序出现异常,变量b不能为0");
}finally { //处理善后工作
    System.out.println("finally");
}

 try {
        new Test().test(1,0);
    } catch (ArithmeticException e) {
        e.printStackTrace();
    }

}
    // 假设方法中,处理不了这个异常,方法上抛出异常
    public void test(int a ,int b) throws ArithmeticException{
        if (b == 0) {  
            throw new ArithmeticException(); //主动抛出异常, 一般在方法中使用
        }
        System.out.println(a/b);
    }

自定义异常

// 继承Exception类之后就是自定义异常类
public class MyException extends Exception {

    // 传递数字>10
    private int deltal;

    public MyException(int a ) {
        deltal = a;
    }

    //toString: 异常的打印信息

    @Override
    public String toString() {
        return "MyException{" + "deltal=" + deltal + '}';
    }
}

组合

oop原则: 组合,大于继承

class A{
    public B b;
}

JavaSE回顾