JavaSE框架

目录

1、Java程序的运行

2、数据类型与变量

3、运算符

4、流程控制

5、方法

重载

重写

6、数组

7、类和对象

9、抽象类和接口

10、String类

总结

---

Java是一门面向对象的编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程 。

——百度百科

 1、Java程序的运行

1、通过记事本或者IDEA（集成开发环境）编写java程序；

2、通过javac.exe编译器编译java程序，生成.class的字节码文件；

（javac ___ .java）

3、使用java运行.class字节码文件。

  (java ___ )

举例，我们通过记事本写一个java程序：

 运行过程：

JDK（Java Development Kit）:java开发工具包，包括JRE、javac编译器以及java自带的调试的工具包；

JRE（Java Runtime Enviroment）:java运行时环境，是基于java语言编写程序运行的所需环境。包括JVM和一些基础类库；

JVM:Java虚拟机，运行java程序。

 2、数据类型与变量

java的数据类型包括基本数据类型与引用数据类型。

• 基本数据类型

java有8大数据类型：

数值类型：

       整数型：byte(1字节）、short（2字节）、int（4字节）

       浮点型：float（4字节）、long（8字节）、double（8字节）

       字符型：char(2字节）

boolean类型：boolean(占1位，其值只有true和false)

java采用Unicode，2个字节（16位）表示一个字符。

它们的包装类分别为：

Byte、Character、Short、Integer、Float、Long、Double、Boolean

• 引用数据类型

数组、类、抽象类、接口以及自定义类型

• 常量

常量就是在程序执行过程中不会变化的量，在java中提供的常量有两种，一种是字面量，例如‘A’等；另一种是通过final关键字修饰的有名称的常量，例如：public static final double PI=3.14,此时的PI就是一个常量。

• 变量

变量就是指在执行过程中值可以发生变化的量。在java中，一般通过基本数据类型来定义基本变量，例如int a=18;更多的会通过类或者数组定义引用变量，例如“String str”,"int[] array",此时在变量中存放的是一个内存地址。

 

局部变量：定义在方法内，必须声明和初始化；

成员变量：定义在类的内部，方法的外部。成员变量又被分为类变量和实例变量，类变量被static修饰，属于这个类，实例对象从属于对象。

3、运算符

算术运算符，关系运算符，逻辑运算符，位运算符以及其他运算符。

优先级：算数运算符>关系运算符>逻辑运算符>赋值运算符

4、流程控制

• 顺序结构

从程序开始到结束顺序执行程序指令；

• 分支结构

二分支：if-else/if

多分支：嵌套的if-else、switch语句

switch(表达式){

      case  常量1：

                   break;

     ...

     default:

                   break;

}

注：变量类型不能是boolean、float、double、long类型。

• 循环结构

while（）、do-while()、for（）

5、方法

Java中函数被称作方法，方法是完成功能，模块化的组织代码。

举例：

public class Wx{
    //求两个整数的和
	public static int sum(int x,int y ) {
		return x+y;
	}
	public static void main(String[] args) {
		System.out.println(sum(2,3);//5
	}
}

 main方法也是方法！！！

 提到方法就不得不提及重载和重写咯：

重载

方法名相同、参数列表不同、返回值类型不做要求

public static int sum(int x,int y ) {
		return x+y;
	}
public static int sum(int x,int y，int z) {
		return x+y+z;
	}

重载不一定在同一个类中，子类也可以重载父类的方法。

重写

方法名相同、参数列表相同、返回值类型相同

注意：

1、被static修饰的方法不能重写；

2、被private修饰的不能重写；

3、被final修饰的不能重写；

4、子类重写父类的方法，访问权限一定要大于等于父类。

6、数组

数组在java中是引用类型，数组分为一维数组和二维数组。

遍历数组

public class Wx{
	public static void main(String[] args) {
		int[] array=new int[]{1,8,2,3};
        for (int i=0;i<array.length;i++) {
			System.out.print(array[i]+" ");//1 8 2 3
		}
        for(int x:array){
			System.out.print(x+" ");//1 8 2 3
		}
		System.out.print(Arrays.toString(array);//[1,8,2,3]
	}
}

二维数组

数据类型[][] 数组名称 = new 数据类型 [行数][列数] { 初始化数据 };

二维数组也可以看做一维数组 ，在java中，行不能省略，但列可以，每一行的数量可以不同。

7、类和对象

类能产生对象（实例化），在java中，一切皆为对象[实体].，那我们该如何去描述一个类?通过属性和行为。如何定义对象的一些属性和行为呢？这就要涉及到成员变量和成员方法了。

• 成员变量：

普通变量：属于对象（通过引用访问）；静态变量：属于类（存放于方法区，仅此一份）。

• 成员方法：

普通方法，静态方法。

注意：不能在静态方法中使用非静态成员变量

• 构造方法：

方法名和类名一样，没有返回值。

实例化时一定会调用，所以可以通过它来初始化成员变量。

public class Student{
    public String name;
    Public int age;
    public Student(String name,int age){
       this.name=name;
       this.age=age;
  }
    public static void main(String[] args){
       Student student=new Student("bxg",5);
  }
}

当我们没有添加构造方法时，编译器会帮我们默认提供一个不带参数的构造方法；当我们提供了构造方法，编译器就不会再提供构造方法了；构造方法是可以重载的。

• this 关键字

this表示对当前对象的引用。

1、this引用访问当前成员变量

2、this引用调用成员方法

3、this调用构造方法

• 封装

将类内部的实现细节隐藏起来。

例如：我们定义了一个学生类，将学生姓名封装了起来，通过公开的Getter和Setter方法修改和获得信息。

class Student{
    private String name;
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
public class Test{
    public static void main(String[] args) {
        Student student1=new Student();
        student1.setName("bxg");
        System.out.print(student1.getName());
    }
}

•  代码块

静态代码块，非静态代码块、局部代码块、同步代码块。

执行顺序：静态代码快>非静态代码块>构造方法

 8、继承和多态

• 继承

A(子类） extends B（父类）

继承：对共性的抽取，从而达到了对代码的复用

•  多态

一个引用所指向的对象不同，所表现出的行为也不同

 多态中有一个重点：向上转型

 向上转型有三种方法：

1、直接赋值：

Flower flower=new Rose();

2、通过方法传参：

Public static void fun(Flower flower){

}

Rose rose =new Rose();

fun(rose);

3、通过方法返回值

Public static Flower fun(){

     Rose rose =new Rose();

     return rose;

}

 可以通过父类引用访问父类和子类重写的方法；

class Flower{
     public void plant(){
         System.out.println("种了一朵花");
     }
}
class Rose extends Flower{
    @Override
    public void plant() {
        System.out.println("种了一朵玫瑰花");
    }
}
class Tulip extends Flower{
    @Override
    public void plant() {
        System.out.println("种了一朵郁金香");
    }
}
class Lily extends Flower{
    @Override
    public void plant() {
        System.out.println("种了一朵百合花");
    }
}
public class Test2 {
    public static void main(String[] args) {
        Rose rose = new Rose();
        Tulip tulip = new Tulip();
        Lily lily = new Lily();
        Flower[] flowers={rose,tulip,lily};
        for(Flower flower:flowers){
            flower.plant();
        }
    }
}

运行结果：

种了一朵玫瑰花
种了一朵郁金香
种了一朵百合花

这里就很好的体现了多态的思想。

9、抽象类和接口

抽象类当中，我们引入了一个关键字abstract；它表示抽象的修饰符，可以修饰类和方法，分别称为抽象类和抽象方法比如花就是一个很抽象的概念，具体到某种花的实例时，总是归类于某种花类。所以说，在需要某个抽象类的对象实例时，只能够用某个具体类的实例来代替。抽象类不能实例化！！！不能生成抽象类的对象，但可以定义一个引用。

Flower flower=new Rose();

抽象类相当于一个类的半成品，需要子类继承并覆盖其中的抽象方法，当子类(非抽象类）继承一个抽象类时，必须重写父类的抽象方法，否则这个子类也是抽象类。

abstract class Flower{
     public abstract void plant();
}
class Rose extends Flower{
    @Override
    public void plant() {
        System.out.println("种了一朵玫瑰花");
    }
}

abstract修饰的方法没有具体实现。

abstract class Flower{
     public abstract void plant();
}

 接口：

接口是对行为的规范，接口的定义和类很相似：

interface 接口名{

//只包含公有抽象方法和常量（public abstract、public static final）

}

定义一个接口A：

public interface A {
    double p=3.14;
    public abstract int sum(int x,int y);
}

定义一个类实现A接口：

public class Test3 implements A {
    @Override
    public int sum(int x, int y) {
        return x+y;
    }
     public void show(){
        //p=3;错误，常量不可以被修改
        System.out.println(p);
    }

    public static void main(String[] args) {
        Test3 test3=new Test3();
        System.out.println(test3.sum(2,3));//5
        test3.show();//3.14
    }
}

实现一个接口时，必须重写接口中的方法。

10、String类

String是引用类型，内部并不存储字符串本身，String是一种不可变对象. 字符串中的内容是不可改变，字符串不可被修改。

构造一个String类：

public class TestDemo {
    public static void main(String[] args) {
        //直接构造一个字符串
        String str1="yibosean";
        //通过new一个对象
        String str2=new String("bxg");
        //使用字符数组进行构造
        char[] arr=new char[]{'b','j','y','x'};
        String str3=new String(arr);

        System.out.println(str1);//yibosean
        System.out.println(str2);//bxg
        System.out.println(str3);//bjyx
    }
}

总结

祝大家健健康康，顺顺利利，下次见！！！