JAVA基础——数组、面向对象

提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档

文章目录

  • JAVA基础
  • 三、方法
  • 一、数组
      • 1 数组基础
        • 1.1 数组初始化
        • 1.2 数组的四个基本特点
        • 1.3 数组的使用
        • 1.4 多维数组
      • 2、数组的应用
        • 2.1 Arrays 类
        • 2.2 排序算法(8种)
          • (1)冒泡排序
        • 2.3 数据结构——稀疏数组
  • 二、面向对象
      • 1 面向过程思想
      • 2 面向对象思想
      • 3 面向对象编程(Object-Oriented Programing,OOP)
      • 4 方法
        • 4.1 方法的定义
        • 4.2 方法的调用
        • 4.3 实参和形参
        • 4.4 值传递和引用传递
      • 5 类与对象的关系
        • 5.1 创建与初始化对象
        • 5.2 类、对象、实例化
        • 5.3 构造器
      • 6、创建对象内存分析
      • 7、封装、多态、继承
        • 7.1 封装
          • (1)属性私有(private):get/set
        • 7.2 继承
          • (1)object 类
          • (2)Super和 this
          • (3) private、default、projected、public的优先级
          • (4)方法的重写
        • 7.3多态
          • (1)instanceof关键字类型转换
          • (2)Static 总结
          • (3)抽象类——abstract*
          • (4)接口
          • (5)内部类
        • 8、异常


JAVA基础

提示:这里可以添加本文要记录的大概内容:

例如:随着人工智能的不断发展,机器学习这门技术也越来越重要,很多人都开启了学习机器学习,本文就介绍了机器学习的基础内容。


提示:以下是本篇文章正文内容,下面案例可供参考

三、方法

一、数组

1 数组基础

1.1 数组初始化

静态初始化、动态初始化

//静态初始化:创建+赋值
int[] a={1,2,3,4,5,6,10};
//动态初始化:包含默认初始化即没有被赋值的元素就是0
int[] b=new int[10];
b[0]=10;

1.2 数组的四个基本特点

(1)其长度是确定的,数组一旦被创建,他的大小不可以改变
(2)其元素必须是相同类型,不允许出现混合类型
(3)数组中的元素可以是任何数据类型,包括基本类型和引用类型
(4)数组变量引用类型,数组也可以看成是对象,数组中的每个元素相当于该对象的成员变量,数组本身就是对象,java中对象是堆中的,因此数组无论保存原始类型还是其他对象类型,数组对象本身是在堆中的。

1.3 数组的使用

遍历数组、查找数组中的最大值、反转数组、打印数组

int[] array={1,2,3,4};
//遍历数组
for (int i=0;i<array.length;i++){
	System.out.println(array[i]);
}
//查找数组中的最大元素
public static void main(String[] args) {
      int[] array={1,98,78,30,50};
      int max=array[0];
        for (int i = 0; i < array.length; i++) {
            if(array[i]>max){
                max=array[i];
            }
        }
        System.out.println(max);
    }
    public static void main(String[] args) {
        int[] arrays = {1, 2, 3, 4, 6};
        //printArray(arrays);
        int[] reverse=reverse(arrays);
        printArray(reverse);
    }
    //反转数组
    public static int[] reverse(int[] arrays) {
        int[] result=new int[arrays.length];
        //反转操作
        for (int i = 0,j=result.length-1;i <arrays.length ; i++,j--) {
            result[j]=arrays[i];
        }
        return result;
        }
    //打印数组
    public static void printArray(int[] arrays){
        for (int i = 0; i <arrays.length ; i++) {
            System.out.print(arrays[i]+" ");
        }

1.4 多维数组

多维数组:可以看成是数组的数组,比如二维数组就是一个特殊的一维数组,其每一个元素都是一个一维数组。
(a) 二维数组打印某一个数
(b)二维数组打印某一行
© 二维数组的打印方式

public static void main(String[] args) {
        int a[][]=new int[2][5];
        int[][] array={{1,2},{3,4}};
        printArray(array[0]);//打印array第0行
        printArray(array[1]);//打印array第1行
        System.out.println(array[0][1]);//打印array的第0行第一个元素
        System.out.println(array[0][0]);//打印array的第0行第0个元素

        //打印二维数组的方式:
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.println(array[i][j]);
            }
        }
    }
    //打印数组
    public static void printArray(int[] array){
        for (int i = 0; i <array.length ; i++) {
            System.out.print(array[i]+" ");
        }
    }

2、数组的应用

2.1 Arrays 类

数组的工具类java.util.Arrays
由于数组对象本身并没有什么方法可以供我们调用,但API中提供了一个工具类Arrays供我们使用,从而可以对数据对象进行一些基本的操作。
查看JDK帮助文档
Arrays类中的方法都是Static修饰的静态方法,在使用的时候可以直接使用类名进行调用,而“不用”使用对象来调用(注意:是“不用”而不是“不能”)
具有以下常用功能:
1、给数组赋值:通过fill方法
2、对数组排序:通过sort方法,按升序
3、比较数组:通过equals方法比较数组中元素值是否相等
4、查找数组元素:通过binarySearch方法能对排序好的数组进行二分查找法操作。

打印数组:Arrays.toString
自己仿照Arrays类进行打印数组

    public static void main(String[] args) {
        int[] a={1,27,3,4,566,788,4};
        System.out.println(a);//[I@1540e19d
        //打印数组元素用Arrays.toString
        System.out.println(Arrays.toString(a));
        printArray(a);
    }
    //自己的方法打印
    public static void printArray(int[] a) {
        for (int i = 0; i < a.length; i++) {
            if(i==0){
                System.out.print("[");
            }
            if(i==a.length-1){
                System.out.print(a[i]+"]");
            }else {
                System.out.print(a[i]+", ");
            }
        }
    }

Arrays.sort 升序排序打印数组

      public static void main(String[] args) {
        int[] a={234,556,67,254,66,43};
        Arrays.sort(a);//数组排序
        System.out.println(Arrays.toString(a));//打印数组元素
    }

Arrays.fill 数组填充:将数组所有元素都填充成val的值:

public class Demo3_Arrayssort {
    public static void main(String[] args) {
        int[] a={234,556,67,254,66,43};
        Arrays.sort(a);//数组排序
        System.out.println(Arrays.toString(a));//打印数组元素
        Arrays.fill(a,0);//数组填充
        System.out.println(Arrays.toString(a));
        Arrays.fill(a,2,4,0);//第二个元素到第四个元素之间被0填充
        System.out.println(Arrays.toString(a));
    }
}
//打印结果:
// [43, 66, 67, 234, 254, 556]
//[0, 0, 0, 0, 0, 0]
//[43, 66, 0, 0, 254, 556]

2.2 排序算法(8种)

(1)冒泡排序

比较数组中两个相邻的元素,如果第一个数比第二数大就交换位置;
每一次比较都会产生出一个最大或者最小的数字;
下一轮则可以少一次排序;
依次循环,直到结束。

    public static void main(String[] args) {
        int[] a={2,8,9,5,74,23};
        int[] sorts=sorta(a);//调用完我们自己写的排序方法以后,返回一个排序后的数组
        System.out.println(Arrays.toString(sorts));
    }
    //冒泡排序
    public static int[] sorta(int[] a) {
        int temp=0;
        //外层循环,判断我们这个要走多少次
        for (int i = 0; i <a.length-1 ; i++) {
            //内层循环,比较判断2个数,第一个比第二个数大就交换位置
            for (int j = 0; j <a.length-1-i ; j++) {
                if (a[j]>a[j+1]){
                    temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }
            }
        }
        return a;
    }

2.3 数据结构——稀疏数组

JAVA基础——数组、面向对象_第1张图片

二、面向对象

1 面向过程思想

步骤清晰简单,第一步做什么,第二步做什么…
面对过程适合处理一些较为简单的问题

2 面向对象思想

物以类聚,分类的思维模式,思考问题首先会解决问题需要哪些分类,然后对这些分类进行单独思考。最后,才对某个分类下的细节进行面向过程的思索。
面向对象适合处理复杂的问题,适合处理需要多人协作的问题!
总结: 对于描述复杂的事物,为了从宏观上把握、从整体上合理分析,我们需要使用面向对象的思路来分析整个系统。但是,具体到微观操作,仍然需要面向过程的思路去处理。

3 面向对象编程(Object-Oriented Programing,OOP)

**面向对象编程的本质:**以类的方式组织代码,以对象的组织(封装)数据。
三大特性: 封装、继承、多态
从认识角度考虑是先有对象后有类。对象,是具体的事物。类,是抽象的,是对对象的抽象。
从代码运行角度考虑是先有类后有对象。类是对象的模板。

4 方法

4.1 方法的定义

修饰符
返回类型
break:跳出Switch,结束循环和return的区别
方法名:注意规范就ok,驼峰命名+见名如意
参数列表:(参数类型,参数名)…
异常抛出:IOException

4.2 方法的调用

静态方法
非静态方法
形参和实参
值传递和引用传递
this关键字

方法:
修饰符 返回值类型 方法名(…){
//方法体
return 返回值;
}

    public String sayhello(){
        return "hello world";
    }
    public void hello(){
        return;//void类型 返回是空
    }
    public int max(int a,int b){
        return a>b?a:b;//三元运算符:如果a大于b就返回a,否则返回b
    }
        //抛出异常
       //数组下标越界异常:ArrayIndexOutOfBoundsException
    public void readFile(String file)throws IOException{
    }

方法的调用
想要调用学生类(静态方法):直接类.方法名

public class Demo02 {
    public static void main(String[] args) {
        //静态方法:类名.方法名
        Student.say();
    }
}

//学生类
public class Student {
    //静态方法
    public static void say(){
        System.out.println("学生说话了");
    }
}

想要调用学生类(非静态):需要new这个方法

public class Demo02 {
    public static void main(String[] args) {
        //非静态方法:
        //实例化这个类 new
        //对象类型 对象名=对象值
        Student student=new Student();
        student.say();
    }
}
public class Student {
    //非静态方法
    public void say(){
        System.out.println("学生说话了");
    }
}

两个方法同时是static,互相调用不出错
两个方法同时不是static,互相调用也不出错
一个方法是static,一个方法不是static时,调用会出错
原因如下:

      //和类一起加载的
    public static void a() {
        b();
    }
    //类实例化之后才存在
    public void b() {

    }

4.3 实参和形参

实际参数和形式参数的类型要对应

public class Demo03 {
    public static void main(String[] args) {
        int add=Demo03.add(1,2);//实参
        System.out.println(add);
        
    }
    public static int add(int a,int b){//形参
        return a+b;
    }
}

4.4 值传递和引用传递

1、值传递

//值传递
public class Demo03 {
    public static void main(String[] args) {
        int a=1;
        System.out.println(a);
        Demo03.change(a);
        System.out.println(a);//a=1
    }
    //返回值为空
    public static void change(int a){
        a=10;
    }
}

2、引用传递
引用传递:对象,本质还是值传递

//引用传递:对象,本质还是值传递
public class Demo04 {
    public static void main(String[] args) {
        Person person=new Person();
        System.out.println(person.name);//null
        Demo04.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
}

5 类与对象的关系

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

5.1 创建与初始化对象

使用new关键字创建对象
使用new关键字创建的时候,除了分配内存空间之外,还会给创建好的对象进行默认的初始化以及对类中构造器的调用。
类中的构造器也称为构造方法,是在进行创建对象的时候必须要调用的。并且构造器有以下2个特点:
1、必须和类的名字相同
2、必须没有返回类型,也不能写void。

5.2 类、对象、实例化

一个类中只有属性和方法
类是抽象的,需要被实例化
学生guoyu是类的对象,
创建类的对象的过程就是类的实例化:使用new关键字来实例化一个对象

以下方代码举例:
类=学生
类的对象=学生guoyu
类的实例化=创建对象的过程

//学生类
public class Student {
    //属性:字段
    String name;//null
    int age;//0

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

    public static void main(String[] args) {
        //类:抽象的,实例化
        //guoyu是类的对象,创建类的对象的过程就是类的实例化。
        //类实例化后会返回一个自己的对象!
        //国宇对象就是一个Student类的具有实例!
        Student guoyu = new Student();//类的实例化=创建对象的过程
        Student yangchenchen = new Student();
        guoyu.name="国宇";
        guoyu.age=18;
        System.out.println(guoyu.name);
        System.out.println(guoyu.age);
    }
}

5.3 构造器

Alt+insert 一键生成有参无参构造器
使用new关键字,本质是调用构造器
构造器一般用来初始化值
例如:无参构造

//学生类
public class Student {
//一个类即使什么都不写,它也会存在一个方法
// 显示的定义构造器
    String name;
    //实例化初始值
    //使用new关键字,本质是调用构造器
    
    //无惨构造
    public Student(){
        this.name="杨晨晨";
    }
}
public class Aplication {

    public static void main(String[] args) {
        //new 实例化了一个对象
        Student student = new Student();
        System.out.println(student.name);//杨晨晨

    }
}

有参构造
(1)一旦定义了有参构造,无参构造必须要写上去,否则new实例化时会报错!

//学生类
public class Student {
    String name;
    //无参构造
    public Student(){}//很重要!!!
  //有参构造
    public Student(String name){
        this.name=name;
    }
}
public class Aplication {
    public static void main(String[] args) {
        //new 实例化了一个对象
        Student student = new Student();
        System.out.println(student.name);//杨晨晨
    }
}

(2)有参构造——new实例化传参数
传递结果只走有参的。

//学生类
public class Student {
    String name;
    //无参构造
    public Student(){}
  //有参构造
    public Student(String name){
        this.name=name;
    }
}

public class Aplication {

    public static void main(String[] args) {
        //new 实例化了一个对象
        Student student = new Student("yangchenchen");
        System.out.println(student.name);//杨晨晨
    }
}

6、创建对象内存分析

栈:方法和变量的引用
堆:存放具体创建出来的对象

下图的具体流程详解及其代码:
1、main方法在栈里的最底下,当栈结束时会被弹出。首先程序先从Application_pet类中进来,进入main函数。
2、当执行到new Pet()时会跳转到宠物Pet类,此时实例化对象dog就有了name和age这两个属性,以及shout方法;但是此时的name 和age没有值。
3、接下来定义dog的name名字叫“富贵”,dog的age是3。此时的dog这个名字是在栈里,真正的dog对象是在堆中,此时name=null,age=0,shout是空。
4、堆中的dog调用方法区的name=‘富贵“,和age=1以及Pet类中的调用的shout(),此时dog就有了名字和年龄。所有的值赋完,dog这个对象在堆中就有值了。以此类推,cat也是,但是cat在方法区中没有赋name和
5、static静态方法区和类一起加载,堆中所有对象都可以调用它。

JAVA基础——数组、面向对象_第2张图片

public class Application_pet {
    public static void main(String[] args) {
    
        Pet dog = new Pet();//创建dog对象
        dog.age=3;
        dog.name="富贵";
        dog.shout();
        System.out.println(dog.age);
        System.out.println(dog.name);
        Pet cat = new Pet();//创建cat对象
    }
}
public class Pet {
    public String name;
    public int age;

    public void shout() {
        System.out.println("叫了一声");
    }
}

7、封装、多态、继承

7.1 封装

该露的露,该藏的藏
程序设计要追求“高内聚,低耦合”。高内聚就是类的内部数据操作细节自己完成,不允许外部干涉;低耦合:仅暴露少量的方法给外部使用
封装(数据的隐藏)
通常,应禁止直接访问一个对象中数据的实际表示,而应通过操作接口来访问,这称为信息隐藏。

(1)属性私有(private):get/set

使用private 的属性,当实例化类后,实例化对象不能直接调用其属性,所以此时要`采用另一个方式,来操作private属性。使用get/set方法
get:获取这个数据;
set:给这个数据设置值
右键 Generate Getter and Setter自动生成get 和set

public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("杨晨晨");
        s1.setAge(999);//不合法!!!
        System.out.println(s1.getName());
        System.out.println(s1.getAge());
    }
}
public class Student {
    //名字
    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;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if(age<120&&age>0){
            this.age = age;
        }else {
            this.age=3;
        }
    }
}

私有化的意义:
(1)提高程序的安全性、保护数据
(2)隐藏代码的实现细节
(3)统一接口
(4)系统可维护增加了

7.2 继承

继承的本质是对某一批类的抽象,从而实现对现实世界更好的建模。
extends是扩展的意思。子类是父类的扩展。
JAVA中类只有单继承,没有多继承! 一个儿子只能有一个爸爸;一个爸爸可以有多个儿子!
继承是类和类之间的一种关系,除此之外,类和类之间的关系还有依赖、组合、聚合等。
继承关系的两个类,一个为子类(派生类),一个为父类(基类)。子类继承父类,使用**关键字extends来表示。
子类和父类之间,从意义上讲应该具有“is a“的关系。

(1)object 类

super
方法重写
优先级从高到低
public > protected > default > private
【继承】例子如下程序:
父类:人
子类:学生
即使子类里面什么都没写,但是父类里面定义了属性,所以在new子类的实例化对象时,子类对象可以继承父类的属性。

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();
        System.out.println(student.money);
    }
}
public class Person {
    //优先级从高到低
    //public
    //protected
    //default
    //private
    public int money=10000;
    public void say(){
        System.out.println("说了一句话");
    }
}
public class Student extends Person {
//ctrl+H
}
==================打印结果==================:
说了一句话
10000

在JAVA中,所有的类,都默认直接或者间接继承object类

(2)Super和 this

子类访问父类,
1、想要调用父类的name属性并输出,用super.name
输出当前类的属性值用this.name
2、想要调用父类的构造函数,用super();
super需要注意:
1、super是调用父类的构造方法,必须在构造方法的第一个
2、super必须只能出现在子类的方法或者构造方法中
3、super和this不能同时调用构造方法
super VS this:
1、super和this代表的对象不同:
this:本身调用这个对象
super:代表父类对象的应用
前提
this:没有继承也可以使用
super:只能在继承条件下才可以使用
构造方法
this():本类的构造
super():父类的构造

public class Aplication {
    public static void main(String[] args) {
        Student student = new Student();
        student.test("杨");
        student.test1();
    }
}

public class Person {
    public Person(){
        System.out.println("Person无参执行了");
    }
    protected String name="ren";
    public void print(){
        System.out.println("Person");
    }
}
public class Student extends Person{
    public Student(){
        //隐藏代码:默认调用了父类的无参构造
        super();//调用父类的构造器,必须要在子类构造器的第一行
        System.out.println("Student无参构造执行了");
        System.out.println("=======1=======");
    }
    private String name="yangchenchen";
    public void print(){
        System.out.println("Student");
    }
    public void test1(){
        print();
        this.print();//当前类的public定义的函数
        super.print();//父类的public定义的函数
        System.out.println("=========3=========");
    }
    public void test(String name){
        System.out.println(name);//传递的参数
        System.out.println(this.name);//当前属于哪个类就输出类里面的东西
        System.out.println(super.name);//输出的事父类的东西
        System.out.println("=========2=========");
    }
}
打印结果:
Person无参执行了
Student无参构造执行了
=======1=======
杨
yangchenchen
ren
=========2=========
Student
Student
Person
=========3=========

Process finished with exit code 0

(3) private、default、projected、public的优先级

public>projected>default>private
**public:**所有类均可见
**projected:**同一个包下的类,以及所有子类都可见
**default:**只有同一个包下的类可见
private只对本类可见

(4)方法的重写

重写:非静态条件下是前提,需要有继承关系,子类重写父类的方法!
1、方法名必须相同
2、参数列表必须相同
3、修饰符:范围可以扩大,但不能缩小。
4、抛出的异常:范围,可以被缩小,但不能扩大:ClassNotFoundException–>Exception(大)
口诀:方法看左边,实现看右边!
意思是:先看左边的类名,是Animal,找到Animal的类中是否有bark方法、sleep属性,有的话说明该bark函数、sleep函数可以被调用;再看右边,是Cat类,所以最后实现的结果是Cat中的bark函数里的值,和sleep函数的值,由于Cat类里面没有特殊的sleep函数,Cat是Animal的子类,Cat继承Animal类的所有方法,所以对于sleep函数也可以调用父类的值。代码如下:

    //方法看左边,实现看右边!
        Animal a1=new Cat();//子类重写了父类的方法
        a1.bark();//结果:喵喵喵~
        a1.sleep();//结果:Animal is sleeping

完整代码如下:

public class Application {
    public static void main(String[] args) {
        //方法看左边,实现看右边!
        Animal a = new Animal();
        a.bark();
        Cat b = new Cat();
        b.sleep();
        //方法看左边,实现看右边!
        Animal a1=new Cat();
        a1.bark();
        a1.sleep();
//        Cat c=new Animal();//错误!!!这句话的意思是:动物是猫?所以是错误的
//        c.bark();

    }
}
public class Animal {
    public void bark() {
        System.out.println("Animal is barking");
    }
    public  void sleep(){
        System.out.println("animals is sleeping");
    }
}
public class Cat extends Animal{
    @Override
    public void bark() {
        System.out.println("喵喵喵~");
    }
    public void eating(){
    	System.out.println("吃鱼!");
    }
}
打印结果:
Animal is barking
animals is sleeping
喵喵喵~
animals is sleeping

Process finished with exit code 0

静态方法与非静态方法的区别很大
重写的前提是在非静态的条件下,如下程序,想要实现cat的bark方法喵喵喵,在非静态的条件下,重写父类方法,达到效果;但是在静态Static条件下,
不能起到重写的效果,所以结果还是父类的bark函数里的结果。代码如下:

public class Animal {
    public static void S_bark() {
        System.out.println("静态Animal is barking");
    }
    public void bark() {
        System.out.println("非静态Animal is barking");
    }
}
public class Cat extends Animal{
    public static void S_bark() {
        System.out.println("静态喵喵喵~");
    }
    @Override
    public void bark() {
        System.out.println("非静态喵喵喵~");
    }
}
public class Application {
    public static void main(String[] args) {
        Animal a1=new Cat();
        a1.barking();
        a1.bark();
    }
}
打印结果:
静态Animal is barking
非静态喵喵喵~

Process finished with exit code 0

7.3多态

动态编译:类型:可扩展性
即同一方法可以根据发送对象的不同而采用多种不同的行为方式。
一个对象的实际类型是确定的,但可以指向对象的引用的类型有很多。
多态存在的条件
有继承关系
子类重写父类的方法
父类引用指向子类对象
注意:多态是方法的多态,属性没有多态性
强转类型:父类和子类之间是有的关系的前提下才可以转换。
类型转换异常:ClassCastException!
强转类型举例代码如下:

        Animal a = new Cat();
        //由于a是Animal类型的,父类没有eating函数,想要调用子类的eating函数
        //可以采用强转类型
        ((Cat) a).eating();

多态总结:
1、多态是方法的多态,属性没有多态
2、类型转换的前提是:父类和子类,没有关系的类型之间不可以转换
3、当父类和子类的方法名字重复时,需要override进行方法重写
4、以下情况不能进行方法重写:
(1)Static 状态下的方法,它属于类不属于实例
(2)final 常量
(3)private 定义的方法

(1)instanceof关键字类型转换

可以判断两个类之间是否存在父子关系,通过bool类型返回结果如下:

public class Application {
    public static void main(String[] args) {
        //判断下面是否可以编译通过,就看下面这句话X与y是否为父子类关系,如果没有父子关系,编译就会报错
        //X x=new m();
        //System.out.println(x instanceof y);
        //判断True or false 就看x所指向的类型是不是y的子类型。
        //Object>String
        //Object > Person > Teacher
        //Object > Person > Student
        Object object = new Student();
        System.out.println(object instanceof Object);//true
        System.out.println(object instanceof String);//false
        System.out.println(object instanceof Person);//true
        System.out.println(object instanceof Teacher);//false Object和Teacher是父子关系,但是Student与teacher无关
        System.out.println(object instanceof Student);//true
        System.out.println("========================");

        Person person = new Student();
        System.out.println(person instanceof Object);//true
        //System.out.println(person instanceof String);//报错!!Person与String不是父子关系
        System.out.println(person instanceof Person);//true
        System.out.println(person instanceof Student);//true
        System.out.println(person instanceof Teacher);//false
		System.out.println("========================");
        Student student = new Student();
        System.out.println(student instanceof Object);//true
        //System.out.println(student instanceof String);//报错!!Student与String不是父子关系
        System.out.println(student instanceof Person);//true
        System.out.println(student instanceof Student);//true
        //System.out.println(student instanceof Teacher);//报错!!Student与String不是父子关系
    }
}
(2)Static 总结

(1)静态属性:
(2)静态方法:
静态属性:

public class Student {
    private static int age;//静态变量 多线程!
    private double score;//非静态变量

    public static void main(String[] args) {
        Student s1 = new Student();
        
        System.out.println(Student.age);
        //System.out.println(Student.score);报错
        System.out.println(s1.score);
        System.out.println(s1.age);
    }
}

静态方法
被final修饰的类,不能被继承——断子绝孙
例如:public final class Person
静态方法举例

public class Student {
    public static void go(){
    }
    public void run(){
    }

    public static void main(String[] args) {
        Student.go();
        //Student.run();//报错!!!
        go();
        //run();//报错!!!
    }
}

代码块

public class Student{
    {
        //代码块(匿名代码块)
        //创建对象的时候就出现了,而且是在构造器之前
        System.out.println("2匿名代码块");
    }
    static {
        //静态代码块,类一加载就执行,永久执行
        System.out.println("1静态代码块");
    }
    public Student() {
        System.out.println("3构造器");
    }
    public static void main(String[] args) {
        Student student = new Student();
        System.out.println("======================");
        Student student1 = new Student();
    }
}
打印结果:
1静态代码块
2匿名代码块
3构造器
======================
2匿名代码块
3构造器

Process finished with exit code 0
(3)抽象类——abstract*

抽象类的所有方法,继承了它的子类,都必须要实现它的方法~

public abstract class Action {
    //自己不想实现,找人帮我们实现
    //abstract,抽象方法,只有方法名字,没有方法的实现
    public abstract void doSomething();
    //1、抽象类不能new,只能靠子类去实现它;约束!
    //2、抽象类可以写普通方法
    //3、抽象方法必须在抽象类中
    //抽象的抽象:约束~
}
//抽象类的所有方法,继承了它的子类都必须要实现它的方法
public class A extends Action {
    @Override
    public void doSomething() {
    }
}
(4)接口

普通类:只有具体实现
抽象类:具体实现和规范(抽象方法)都有!
接口:只有规范!自己无法写方法专业的约束!约束和实现分类:面向接口编程~
接口就是规范,定义的是一组规则,体现了现实世界中“如果你是…则必须能…"的思想。如果你是天使,则必须能飞。如果你是汽车,则必须能跑。如果你是好人,则必须干掉坏人。
接口的本质是契约,就像我们人间的法律一样。制定好后大家都遵守。
接口的精髓,是对对象的抽象,最能体现这一点的就是接口,为什么我们讨论设计模式都只针对具备了抽象能力的语言(比如C++、java、c#等),就是因为设计模式所研究的,实际上就是如何合理的去抽象。
声明类的关键字是class,声明接口的关键字是interface。
接口和类的区别:类有方法的实现,接口没有,接口只有方法的定义。

接口中所有定义的方法其实都是抽象的public abstract
接口中所有定义的属性都是常量,是public static final

//接口定义:
public interface UserService {
	//常量 public static final
    int AGE=99;
    
    //接口中的所有定义其实都是抽象的public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}
//接口定义:
public interface TimeService {
    void timer();
}

实现多继承-不同的接口不同方法继承

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、接口可以实现多个,用implements可以实现多个接口
4、实现接口必须要重写接口中的方法

(5)内部类

内部类就是一个类的内部在定义一个类,比如,A类中定义一个B类,那么B类相对A类来说就称为内部类,而A类相对B类来说就是外部类了。
1、成员内部类
2、静态内部类
3、局部内部类
4、匿名内部类

public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
        //通过外部类实例化对象内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getID();
    }
}
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);
        }
    }
}

局部内部类、内部类
一个java类中可以有多个class类,但只能有一个public class

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

            }
        }
    }
}
//一个java类中可以有多个class类,但只能有一个public class
class A{

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

      //没有名字去初始化类
        new Apple();
        //类同样可以调用方法,不用将实例保存到变量中
        new Apple().eat();
        new UserService(){
            
        };
    }

}
class Apple {
    public void eat(){
        System.out.println("1");
    }
}
interface UserService{

}

8、异常

异常处理机制
·抛出异常
·捕获异常
异常处理五个关键字
try catch finally throw throws
在程序中使用自定义异常类,大体可以分为以下几个步骤:
1、创建自定义异常类
2、在方法中通过throw关键字抛出异常
3、如果在当前抛出异常的方法中处理异常,使用

public class Test {
    public static void main(String[] args) {
        int a=1;
        int b=0;
        try {//try监控区域
            System.out.println(a/b);
        }catch (ArithmeticException e){//catch 捕获异常
            System.out.println("程序出现异常,变量b不能为0");
        }finally {//处理善后工作
            System.out.println("finally");
        }
    }
}

主动抛出异常:
在方法里面抛出异常是throw
在方法上抛出异常是throws

public class Test {
    public static void main(String[] args) {
        new Test().test(1,0);
    }
    public void test(int a,int b){
        if (b==0){
            throw new ArithmeticException();//主动抛出异常,一般在方法中使用
        }
    }
}

你可能感兴趣的:(java,java-ee)