【JAVA系列】_java

JAVA基础

文章目录

JAVA基础
前言
一、java基础
- 变量作用域
- 方法
二、数组
- 1.定义
- 2.稀疏数组
三、面向对象
- 面向对象基础概念
- 方法调用
- 类与对象的关系
- 封装
- 重载
- 继承(extends)
- 重写(override)
- 多态
- 抽象类
- 接口
- 内部类 & 外部类
- 异常

前言

为了自己学习记录，为了随时能够换工作，随时可以回老家！

一、java基础

java数据类型
- 基本类型：byte、short、int、long、float、dubbo、char、boolean
- 引用类型：类、接口、数组

变量作用域

类变量
实例变量
局部变量

方法

方法重载
1.1重载就是在一个类中，有相通的函数名称，但形参不同的函数
1.2 重载规则：
方法名称相同
参数列表必须不同(个数不同、或类型不同、参数排列顺序不同等)
方法的返回类型可以相同也可以不同
仅仅返回类型不同不足以成为成为方法重载

代码如下：

//        int max=max(10,20);
//        double max=max(10.10,20.0);
        double max=max(10.10,25.0,5.00);

        System.out.println("最大数值为："+max);
    }

    public static int max(int a,int b){
        int result;
        if (a==b){
            System.out.println("数值相等");
            return b;
        }
        if (a>b){
            result=a;
        }else {
            result=b;
        }
        return result;
    }

    public static double max(double a,double b){
        double result;
        if (a==b){
            System.out.println("数值相等");
            return b;
        }
        if (a>b){
            result=a;
        }else {
            result=b;
        }
        return result;
    }

    public static double max(double a,double b,double c) {
        double result;
        if (a > b) {
            if (a > c) {
                result = a;
            } else {
                result = c;
            }
        } else if (c > b) {
            result = c;
        } else {
            result = b;
        }
        return result;
    }

可变参数
在方法声明中，在制定参数类型后加一个省略号(…)
一个方法只能存在一个可变参数，且必须是方法的最后一个参数

代码如下：

    printMax(3,5,67,4,1);
        printMax(new double[]{30,30,50,90,10});
    }

    public static void printMax(double... numbers){
        double result=numbers[0];
        if (numbers.length==0){
            System.out.println("No argument passed");
            return;
        }

        for (int i=0;i<numbers.length;i++){
            if (numbers[i]>result){
                result=numbers[i];
            }
        }
        System.out.println("The max value is："+result);

二、数组 1.定义

静态初始化：
int[] = {1,2,3,4,5,6}
动态初始化：
int[] a=new int[10];

2.稀疏数组

什么是稀疏数组：
- 当一个数组中大部分元素是0，或者是一个相同的值时，可以使用稀疏数组来保存该数组
- 第一行（即：0行）比较特殊，row存储总行数，col存储总列数，value存储非零（不同值）元素的数量；其他行结构相同，每一行存储一条非零元素信息，row存储元素所在行，col存储元素所在列，value存储元素的值。

将下面的普通数组转为稀疏数组，再转为原始数组：

代码如下：

package com.beiguo.array;

//普通数组转为稀疏数组

public class ArrayTest06 {
    public static void main(String[] args) {
//        创建一个二维数组 0：没有棋  1：黑棋  2：白棋
        int arrInit[][]=new int[11][11];
        arrInit[1][2]=1;
        arrInit[2][3]= 2;
        System.out.println("输出原始数组：");
        for (int[] a:arrInit) {
            for (int init: a) {
                System.out.print(init+"\t");
            }
            System.out.println();
        }

        //转换为稀疏数组保存
        //获取有效值的个数
        int sum =0;
        for (int i = 0; i < arrInit.length; i++) {
            for (int j = 0; j < arrInit[i].length; j++) {
                if (arrInit[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("有效值的个数为："+sum+"个");
        System.out.println("=========================================");

        //创建一个稀疏数组
        int sparseArr[][] = new int[sum+1][3];
        sparseArr[0][0] =11;
        sparseArr[0][1] =11;
        sparseArr[0][2] =sum;

        //遍历二维数组，将非0的值放入稀疏数组中
        int count =0;
        for (int i = 0; i < arrInit.length; i++) {
            for (int j = 0; j < arrInit[i].length; j++) {
                if (arrInit[i][j] != 0) {
                    count++;
                    sparseArr[count][0] = i;
                    sparseArr[count][1] = j;
                    sparseArr[count][2] = arrInit[i][j];
                }
            }
        }

        //输出稀疏数组
        System.out.println("稀疏数组为：");
//        方式一：
//        for (int[] a:sparseArr) {
//            for (int init: a) {
//                System.out.print(init+"\t");
//            }
//            System.out.println();
//        }

//        方式二：
        for (int i = 0; i < sparseArr.length; i++) {
                System.out.println(sparseArr[i][0]+"\t"
                +sparseArr[i][1]+"\t"
                +sparseArr[i][2]+"\t");
        }
        System.out.println("=========================================");

        //还原稀疏数组
        //还原数组真是行和列
        int[][] array2 =new int[sparseArr[0][0]][sparseArr[0][1]];
//        遍历数组，拿到对应值
        for (int i = 1; i < sparseArr.length; i++) {
            for (int j = 1; j < sparseArr[i].length; j++) {
                if (sparseArr[i][j] !=0){
                    array2[sparseArr[i][0]][sparseArr[i][1]]=sparseArr[i][2];
                }
            }

        }
        //输出还原后的数组
        for (int[] a:array2) {
            for (int init: a) {
                System.out.print(init+"\t");
            }
            System.out.println();
        }

    }
}

三、面向对象面向对象基础概念

提示： Java编程的核心思想是OOP(Object-Oriented Programming)，即：面向对象编程

面向对象本质：以类的方式组织代码，以对象的组织(封装)数据
抽线
三大特性：
- 封装
- 继承
- 多态

方法调用

静态方法&非静态方法调用

package com.oop.demo1;

public class Demo1 {
    public static void main(String[] args) {
        //静态方法调用：直接对象.方法
        Students.say();

        //非静态方法调用：创建对象，仔通过对象调用方法
        new Students().cry();


        Demo1 d =new Demo1();
        d.a();
    }

    public void a(){
        b();

    }
    public static void b(){
        System.out.println("调用b");
    }
}

package com.oop.demo1;

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

    }
    //静态方法
    public static void say(){
        System.out.println("学生上课发言");
    }

    //非静态方法
    public void cry(){
        System.out.println("学生感动哭了");
    }
}

类与对象的关系

构造器：和类型名相同&无返回值
作用：new 本质在调用构造器&初始化对象的值
注意点：定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造
生成构造器快捷键：Alt Insert
this：代表当前类的参数

封装

高内聚低耦合
属性私有 get/set
封装的意义：
- 提高程序安全性，保护数据的完整性
- 隐藏代码的实现细节
- 统一接口，形成规范
- 提高系统可维护性

package com.oop.demo4;

public class Student {
    private int age;
    private String name;
    private int id;
    private char sexy;

    public Student() {
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age<0 || age>130) {
            System.out.println("非法的年纪");
        }else {
            this.age = age;
        }
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public char getSexy() {
        return sexy;
    }

    public void setSexy(char sexy) {
        this.sexy = sexy;
    }
}

package com.oop.demo4;

public class Test {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.setName("小明");
        stu.setAge(30);
        System.out.println(stu.getName()+"今年"+stu.getAge()+"岁了。");
    }
}

重载

方法名相同，参数不同

继承(extends)

继承的本质是对一批类的抽象
JAVA只有单继承，没有多继承
子类/派生类；父类/基类
super关键字：
- super调用父类的构造方法，必须在构造方法的第一个
- super必须只能出现在子类的方法活着构造方法中
- super 和 this 不能同时调用构造方法
this 和 super
- 代表的对象不同
  - this ：本身调用者这个对象
  - spuer：代表弗雷对象的应用
- 前提：
  - this：没有继承也可以使用
  - super：只能在继承条件下使用
- 构造方法：
  - this()：本垒的构造
  - super()：父类的构造

package com.oop.demo5;
public class Test {
    public static void main(String[] args) {
        Student stu =new Student();
        stu.say();
        Teacher tea =new Teacher();
        tea.say();
    }
}

package com.oop.demo5;
public class Person {
    protected String name="姑苏";
    public Person() {
        System.out.println("执行了父类无参构造");
    }
    public void say(){
        System.out.println("Person");
    }
}

package com.oop.demo5;
public class Student extends Person{
    private String name="江陵";
    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
}

package com.oop.demo5;
public class Teacher extends Person{
    private String name="欢颜";
    public Teacher() {
        System.out.println("执行了子类无参构造");
    }
    public void say(){
        System.out.println("Student");
    }
    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
    //方法调用
    say();
    this.say();
    super.say();
}

重写(override)

重写：
- 方法名必须相同
- 参数列表必须相同
- 修饰符：范围可以扩大，但不能缩小(public > Protected > Default > private)
- 抛出异常：范围可以被缩小，但不能放大(ClassNotFoundException > Exception(大))
针对方法重写，和属性无关
重写只和非静态相关，和静态方法无关
方法调用只和左边对象有关
为什么要重写
- 父类的功能不一定是子类都需要的
- Alt Inset

package com.oop.demo6;
public class test {
    public static void main(String[] args) {
        Son son = new Son();
        son.say();
        son.watch();
        Father father = new Son();
        father.say();
        father.watch();
    }
}

package com.oop.demo6;
public class Father {
    public static void say(){
        System.out.println("父亲发言！");
    }
    public void watch(){
        System.out.println("父亲看电视！");
    }
    public void read(){
        System.out.println("父亲读报纸！");
    }
}

package com.oop.demo6;
public class Son extends Father{
    public static void say(){
        System.out.println("女儿发言！");
    }
    @Override
    public void watch() {
        System.out.println("儿子看电视");
    }
    @Override
    public void read() {
        super.read();
    }
}

多态

动态编辑：类型：可扩展性
多态存在条件：
- 有继承关系
- 子类重写父类方法
- 父类引用指向子类对象
注意事项：
- 多态是方法的多态，属性没有多态性
- 父类和子类有关系，无关系报类型转换异常
instanceof：判断对象之间是不是存在父子关系
不能被重写
- static：属于类，不属于实例
- final：常量
- private：私有的

package com.oop.demo7;
public class Test {
    public static void main(String[] args) {
        Son son =new Son();//可以调用子类和父类的方法
        son.eat();//父亲喜欢吃辣！
        son.study();//儿子喜欢玩耍！
        System.out.println("-----------------");
        Father father = new Son();//可以指向子类，但不能调用子类独有的方法
        father.eat();//父亲喜欢吃辣！
        father.study();//父亲喜欢学习！
    }
}

package com.oop.demo7;
public class Father {
    public void eat(){
        System.out.println("父亲喜欢吃辣！");
    }
    public void study(){
        System.out.println("父亲喜欢学习！");
    }
}

package com.oop.demo7;
public class Son extends Father{
    @Override
    public void eat() {
        super.eat();
    }
    @Override
    public void study() {
        System.out.println("儿子喜欢玩耍！");
    }
}

转换

package com.oop.demo8;
public class Test {
    public static void main(String[] args) {
        //Object > String
        //Object > Person > Teacher
        //Object > Person > Student
        Object obj = new Student();
        System.out.println(obj instanceof Person); //true
        System.out.println(obj instanceof Student);//true
        System.out.println(obj instanceof Teacher);//true
        System.out.println(obj instanceof Object);//true
        System.out.println(obj instanceof String);//false
        System.out.println("---------------------------");
        Person person = new Student();
        System.out.println(person instanceof Person); //true
        System.out.println(person instanceof Student);//true
        System.out.println(person instanceof Teacher);//false
        System.out.println(person instanceof Object);//true
//        System.out.println(person instanceof String);//编译报错
        System.out.println("---------------------------");
        Student stu = new Student();
        System.out.println(stu instanceof Person); //true
        System.out.println(stu instanceof Student);//true
//        System.out.println(stu instanceof Teacher);//编译报错
        System.out.println(stu instanceof Object);//true
//        System.out.println(person instanceof String);//编译报错
    }
}

package com.oop.demo8;
public class Person {
}

package com.oop.demo8;
public class Teacher extends Person{
    public void run(){
        System.out.println("Run");
    }
}

package com.oop.demo8;
public class Student extends Person{
    public void go(){
        System.out.println("Go");
    }
}

强制转换
- 父类引用指向子类的对象
- 把子类转换为父类，向上转型
- 把父类转换为子类，向下转型；强制转换
- 方便方法的调用，减少重复的代码

package com.oop.demo8;
public class Test {
    public static void main(String[] args) {
        Object obj = new Student();
        Object obj2 = new Teacher();
        ((Student)obj).go();//Go
        ((Teacher)obj2).run();//Run
    }
}

package com.oop.demo8;
public class Person {
}

package com.oop.demo8;
public class Teacher extends Person{
    public void run(){
        System.out.println("Run");
    }
}

package com.oop.demo8;
public class Student extends Person{
    public void go(){
        System.out.println("Go");
    }
}

静态&非静态
- 变量

package com.oop.demo9;
public class Student {
    private static int age; //静态变量
    private Double score; //非静态变量
    public static void main(String[] args){
        Student stu = new Student();
        System.out.println(Student.age);
        System.out.println(stu.age);
        System.out.println(stu.score);
    }
}

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

package com.oop.demo9;
public class Student {
    private static int age; //静态变量
    private Double score; //非静态变量
    public static void main(String[] args){
        Student stu = new Student();
        walk();//散步
        stu.run();//跑步
    }
    public static void walk(){
        System.out.println("散步");
    }
    public void run(){
        System.out.println("跑步");
        walk();
    }
}

代码块

package com.oop.demo9;
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();
    }
}

抽象类

接口可以多继承
抽象类不能new 对象
abstract
抽象方法必须在抽象类中；抽象类中可以包含普通方法

接口

interface：接口不可以被实例化 & 接口中不存在构造方法
implements：可以实现多继承(多个接口)
多继承：重写接口中的方法
作用：
- 约束
- 定义方法，让不同的对象实现
- 方法：public abstract
- 常量：public static final

package com.oop.demo10;
public interface UserService {
    void add();
    void query();
    void update();
    void delete();
}

package com.oop.demo10;
public interface UserService {
    void add();
    void query();
    void update();
    void delete();
}

package com.oop.demo10;
//多继承
public class UserServiceImpl implements UserService,TimeService{
//实现抽象方法
    @Override
    public void add() {

    }
    @Override
    public void query() {

    }
    @Override
    public void update() {

    }
    @Override
    public void delete() {

    }
    @Override
    public void time() {

    }
}

内部类 & 外部类

成员内部类

package com.oop.demo11;
public class Test {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.out();
        Outer.Inner inner = outer.new Inner();
        inner.inn();
    }
}

package com.oop.demo11;
public class Outer {
    private int id=100;

    public void out(){
        System.out.println("外部类方法");
    }
    public class Inner{
        public void inn(){
            System.out.println("内部类方法"+id);
        }
    }
}

异常

异常处理关键字：
- try catch finally throw throws
- 自定义异常

package com.oop.demo13;
public class Test {
    static void test(int a) throws MyException{
        System.out.println("传递的参数为："+a);
        if (a>10){
            throw new MyException(a);
        }

        System.out.println("OK");
    }
    public static void main(String[] args){
        try {
            test(11);
        }catch (MyException e){
            System.out.println("MyException"+e);
        }
    }
}

package com.oop.demo13;
public class MyException extends Exception{
    private int index;

    public MyException(int index){
        this.index=index;
    }
    //toString异常的打印信息
    @Override
    public String toString() {
        return "MyException{" +
                "index=" + index +
                '}';
    }
}

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/langs/868145.html

【JAVA系列】

发表评论

评论列表（0条）