java入门基础

最新推荐文章于 2023-04-22 14:23:32 发布

Msaerati

最新推荐文章于 2023-04-22 14:23:32 发布

阅读量195

点赞数 1

分类专栏： JAVA 文章标签： java 开发语言 jvm

本文链接：https://blog.csdn.net/qq_63928796/article/details/128192145

版权

JAVA 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

java基础语法

hello word

public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

注释，标记符，关键字

注释

单行注释

hello word   //这是单行注释

多行注释

/*这是
多行
注释*/

文档注释

/**
*文档注释
*
*/

关键字

java自带的，有一些特定的作用，例如

public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

class public System等等

起名字是不可以用关键字

标识符

1.由2个大小写的英文字母 0-9 $ _组成
2.数字不可以开头
3.不可以使用关键字和保留字，但可以包含关键字和保留字
4.Java严格区分大小写，长度没有限制
5.标识符不能包含空格

数据类型

java为强类型语言

要求变量的使用严格符合规定，所有变量都必须先定义后使用

public class Hello {
    public static void main(String[] args) {
        String a ="123";
        System.out.println(a);
    }
}

定义a输入123-

整型(4个)

byte（字节型）、short（短整型）、int（整型）、long（长整型）

byte a = 100; 
short s = 1000; 
int a = 100000; 
long a = 100000L;

浮点型(2个)

float（单精度型/浮点型）、double（双精度型）

float f1 = 1.1f;
double d1 = 1.2;

字符型(1个)

char（字符型

char name = 'a'

布尔类型(1个)

boolean(布尔类型）

一般用来做逻辑判断，一般用于流程控制，数据值只有true或false，适用于逻辑计算。

实例

public class Hello {
    public static void main(String[] args) {
        //整数
        int num1 = 10;
        byte num2 = 20;
        short num3 = 30;
        long num4 = 30L;

        //小数：浮点数
        float num5 = 50.1F;
        double num6 = 3.14343252345;

        //字符
        char name = '宏';
        //字符串String不是关键字

        //布尔值:是非
        boolean flag = true;
        //boolean flag = false;

    }
}

类型转换

低------------------------------->高

byte，short，char->int->long->float->double

强转

public class Hello {
    public static void main(String[] args) {
        System.out.println((int)1.1);
    }
}

相反的话不需要转

数值过大时会出现溢出

public class Hello {
    public static void main(String[] args) {
        int i = 128;
        byte b = (byte)i;
        System.out.println(i);
        System.out.println(b);
    }
}

变量，常量，作用域

public class Hello {
    public static void main(String[] args) {
        int a=1;   //常量
        String name= 'xxh';   //类型为sting名为name值为xxh的变量
    }
}

类变量

public class Hello {
    static double salary = 2500;
    int age = 20;
    public static void main(String[] args) {
        Hello hello = new Hello();
        System.out.println(hello.salary);
    }
}

实例变量

从属于对象

public class Hello {
    String name ;
    int age = 20;   //实例对象
    public static void main(String[] args) {
        Hello hello = new Hello();
        System.out.println(hello.age);
    }
}

局部变量

public class Hello {
    public static void main(String[] args) {
        //局部变量；必须声明和初始化值
        int i = 10;
    }
}

运算符

基本的四则运算

int a = 20;
int b = 10;
System.out.println(a + b); // 30
System.out.println(a - b); // 10
System.out.println(a * b); // 200
System.out.println(a / b); // 2
System.out.println(a % b); // 0 --->模运算相当于数学中除法的余数

增量运算符+= -= *= %=

int a = 1;
a += 2; // 相当于 a = a + 2
System.out.println(a); // 输出3,其他的运算符类似

自增/自减运算符 ++/–

int a = 1;
a++; // 后置++ 表示给a的值加1，此时a的值为2
System.out.println(a++); // 注意：后置++是先使用变量原来值，表示式结束时给变量+1，因此输出2
System.out.println(a); // 输出3
++a; // 前置++ 表示给a的值加1
System.out.println(++a); // 注意：前置++是先给变量+1，然后使用变量中的值，因此输出5
System.out.println(a); // 输出5

关系运算符

int a = 10;
int b = 20;
// 注意：在Java中 = 表示赋值，要与数学中的含义区分
// 在Java中 == 表示相等
System.out.println(a == b); // false
System.out.println(a != b); // true
System.out.println(a < b); // true
System.out.println(a > b); // false
System.out.println(a <= b); // true
System.out.println(a >= b); // false

逻辑运算符

逻辑运算符主要有三个: && || ! ，运算结果都是boolean类型。

包机制，javaDoc

包

为了更好的组织类，java提供了包机制，用于区别类名的命名空间
包语句的语法格式为:
```
package pkg1[. pkg[. pkg3...]]
```
一般用公司域名倒置作为包名；
为了能够使用摸一个包的成员，我们需要在java程序中明确导入该包。使用"import"语句可完成此功能
```
import package1[. package2...].(classname|*);
```

javaDoc

javadoc -encoding UTF-8 -charset UTF-8 Doc.java

用户交互Scanner

通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取前我们一般需要使hasNext() 与hasNextLine()判断是否还有输入的数据。

hasNext()

1、一定要读取到有权字符后才可以结束输入。

2、对输入有效字符之前遇到的空白，next()方法会自动将其去掉。

3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。

4、next()不能得到带有空格的字符串。

import java.util.Scanner;

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

        //创建一个扫描对象，用于接收键盘数据
        Scanner scanner = new Scanner(System.in);

        System.out.println("使用next方式接收:");
        //判断用户有没有输入字符串
        if(scanner.hasNext()){
            //使用next方式接收
            String str = scanner.next();
            System.out.println("输出的内容为:"+str);
        }
    }
}
//输入hello word
//输出hello

hasNextLine()

1、以Enter为结束符,也就是说nextLine()方法返回的是输入回车之前的所有字符。

2、可以获得空白。

import java.util.Scanner;

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

        //创建一个扫描对象，用于接收键盘数据
        Scanner scanner = new Scanner(System.in);

        System.out.println("使用next方式接收:");
        //判断用户有没有输入字符串
        if(scanner.hasNextLine()){
            //使用next方式接收
            String str = scanner.nextLine();
            System.out.println("输出的内容为:"+str);
        }
    }
}
//输入hello word
//输出hello word

顺序结构

JAVA的基本结构就是顺序结构，除非特别指明，否则就按照顺序一句一句执行。

顺序结构是最简单的算法结构。

public class demo03 {
    public static void main(String[] args) {
        System.out.println('1');
        System.out.println('2');

    }
}
//1 2

选择结构

if单选择结构

import java.util.Scanner;

public class demo03 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner((System.in));

        System.out.println("请输入内容");
        String s = scanner.nextLine();

        //equals:判断字符串是否相等
        if (s.equals("Hollo")){
            System.out.println(s);
        }
        System.out.println("End");
        scanner.close();

    }
}

if双选择结构

import java.util.Scanner;

public class demo03 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner((System.in));

        System.out.println("请输入成绩");
        int score = scanner.nextInt();

        if (score>60){
            System.out.println("及格");
        }else{
            System.out.println("不及格");
        }
        scanner.close();

    }
}

if多选择结构

import java.util.Scanner;

public class demo03 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner((System.in));

        System.out.println("请输入成绩");
        int score = scanner.nextInt();

        if (score==100){
            System.out.println("恭喜满分");
        }else if (score>60){
            System.out.println("及格");
        }else {
            System.out.println("不及格");
        }
        scanner.close();

    }
}

嵌套的if结构

import java.util.Scanner;

public class demo03 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner((System.in));

        System.out.println("请输入成绩");
        int score = scanner.nextInt();
        if (score>=100){
            if (score > 100) {
                System.out.println("你爆分了");
            }else {
                System.out.println("恭喜满分");
            }
        }
        scanner.close();

    }
}

switch多选择结构

public class demo03 {
    public static void main(String[] args) {
       char grde = 'A';

       switch (grde){
           case 'A':
               System.out.println("优秀");
               break; //可选
           case 'B':
               System.out.println("良好");
           default:
               System.out.println("你弄啥嘞");
       }
    }
}

循环结构

while循环

public class demo03 {
    public static void main(String[] args) {
       //输出1-100
        int i=0;
        int sum = 0;
        while(i<100){
            i++;
            sum = sum + i;
        }
        System.out.println(sum);
    }
}

do…while循环

public class demo03 {
    public static void main(String[] args) {
       //输出1-100
        int i=0;
        int sum = 0;
        do {
            sum = sum + i;
            i++;
        }while (i<100);
        System.out.println(sum);
    }
}

for循环

虽然所有循环结构都可以用while或者do…while表示，但Java提供了另一种语句——for循环，使一些循环结构变得更加简单
for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。

for循环执行的次数是在执行前就确定的。语法格式如下:

for(初始化；布尔表达式；更新) {
   //代码语句
 }

public class demo03 {
    public static void main(String[] args) {
        for(int i=1;i<=100;i++){
            System.out.println(i);
        }
    }
}

数组

public class demo03 {
    public static void main(String[] args) {
        int[] numbers = {10,20,30,40,50}; //定义了一个数组

        //遍历数组的元素
        for (int x:numbers){
            System.out.println(x);
        }

    }
}

break&continue

break在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句。(break语句也在switch语句中使用)
continue语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。

break

public class demo03 {
    public static void main(String[] args) {
       int i = 0;
       while (i<100) {
           i++;
           System.out.println(i);
           if (i==30){
               break;
           }
       }

    }
}

continue

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

        int i = 0;
        while (i<100){
            i++;
            if(i%10==0){
                System.out.println(i);
                continue;
            }
        }

    }
}

方法

何为方法

Java方法是语句的集合，它们在一起执行一个功能。
方法是解决一类问题的步骤的有序组合
方法包含于类或对象中
方法在程序中被创建，在其他地方被引用

设计方法的原则:方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成1个功能，这样利于我们后期的扩展。

public class demo03 {
    //main方法
    public static void main(String[] args) {
        int sum =add(1,2);
        System.out.println(sum);

        }

        //加法
        public static int add(int a,int b){
        return a+b;
        }

    }

方法的定义及调用

Java的方法类似于其它语言的函数，是一段用来完成特定功能的代码片段，一般情况下，定义一个方法包含以下语法:
- 方法包含一个方法头和一个方法体。下面是一个方法的所有部分:
- - 修饰符:修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
  - 返回值类型∶方法可能会返回值。returnValueType是方法返回值的数据类型。有些方法执行所需的操作，但没有
    返回值。在这种情况下，returnValueType是关键字void。
  - 方法名:是方法的实际名称。方法名和参数表共同构成方法签名。
  - 参数类型:参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
  - 方法体:方法体包含具体的语句，定义该方法的功能。

public class demo03 {

    public static void main(String[] args) {
        int max=max(10, 20);
        System.out.println(max);
    }

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

    }
}

方法重载

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

public class demo03 {

    public static void main(String[] args) {
        int max=max(10, 20);
        System.out.println(max);
    }

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

    }
    public static double max(double c,double d){
        int result = 0;
        if (c==d){
            System.out.println("c=d");
            return 0;
        }
        if (c > d){
            result = (int)c;
        }else {
            result  = (int)d;
        }
        return result;

    }
}

命令行传参

package scanner;


public class demo03 {

    public static void main(String[] args) {
        // args.length数组长度
        for (int i = 0; i < args.length; i++) {
            System.out.println("args[" + i +"]: " +args[i]);
        }
    }
}

在这里插入图片描述

可变参数

JDK 1.5开始，Java支持传递同类型的可变参数给一个方法。
在方法声明中，在指定参数类型后加一个省略号(.…)。

一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

public class demo03 {

    public static void main(String[] args) {
        demo03 Demo03 = new demo03();
        Demo03.test(1,2,3,4,5);
        }

    public void test(int... i){
        System.out.println(i[0]);
        System.out.println(i[1]);
        System.out.println(i[2]);
        System.out.println(i[3]);
    }

}
//输出
//1
//2
//3
//4

递归

A方法调用B方法，我们很容易理解!
递归就是:A方法调用A方法!就是自己调用自己
利用递归可以用简单的程序来解决一些复杂的问题。它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。
递归结构包括两个部分:
- 递归头:什么时候不调用自身方法。如果没有头，将陷
- 入死循环。递归体:什么时候需要调用自身方法。

~~自己调用自己~~

public class demo03 {

    public static void main(String[] args) {
        demo03 test = new demo03();
        test.test();
        }

    public void test(){
        test();
    }

}

递归实现阶乘

public class demo03 {
    //2!  2*1
    //3! 3*2*1
    //4! 4*3*2*1

    public static void main(String[] args) {
        System.out.println(test(5));
    }
    //test(1) = 1
    //test(2) = 2 * test(1)
    //test(3) = 3 * test(2) * test(1)

    public static int test(int n) {
        if (n == 1) {
            return 1;
        } else {
            return n * test(n - 1);
        }

    }
}

数组

数组概述

数组是相同类型数据的有序集合.
数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。
其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们.

特点

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

边界

下标的合法区间[0, length-1]，如果越界就会报错;
ArraylndexOutOfBoundsException :数组下标越界异常!
小结:
- 数组是相同数据类型(数据类型可以为任意类型)的有序集合数组也是对象。数组元素相当于对象的成员变量
- 数组长度的确定的，不可变的。如果越界，则报:ArraylndexOutofBounds

数组声明创建

public class demo03 {
    //变量的类型  变量的名字 = 变量的值
    //数组类型


    public static void main(String[] args) {
        int[] nums; //声明一个数组
        nums = new int[10];  //创建一个数组

        //给数组元素中赋值
        nums[0] = 1;
        nums[1] = 2;
        nums[2] = 3;
        System.out.println(nums[1]);
    }
}

数组使用

初始化

public class demo03 {


    public static void main(String[] args) {
        //静态初始化：创建 + 赋值
        int[] a = {1,2,3,4,5};
        System.out.println(a[0]);

        //动态初始化 ： 包含默认初始化
        int[] b = new int[10];
        b[0] = 10;
        System.out.println(b[0]);
    }
}

基本用法

public class demo03 {


    public static void main(String[] args) {
        //定义数组
        int[] a = {1,2,3,4,5};
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
        System.out.println("------------------");
        //计算所有数组的总和
        int sum =0;
        for (int i = 0; i < a.length; i++) {
            sum +=a [i];
        }
        System.out.println(sum);
        //查找最大元素
        int max = a[0];
        for (int i = 1; i < a.length; i++) {
            if (a[i]> max){
                max = a[i];
            }
            
        }
        System.out.println("max="+max);

    }
}

For-Each循环

public class demo03 {


    public static void main(String[] args) {
        //定义数组
        int[] a = {1,2,3,4,5};
        for (int i : a) {
            System.out.println(i);
            
        }
    }
}

数组作方法入参

public class demo03 {


    public static void main(String[] args) {
        //定义数组
        int[] a = {1,2,3,4,5};

            array(a);

    }
    //打印数组元素
    public static void array(int[] a) {
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]+"");

        }

    }
}

数组作返回值

数组翻转

public class demo03 {


    public static void main(String[] args) {
        //定义数组
        int[] a = {1,2,3,4,5};

        int[] array = array(a);
        print(array);

    }
    //打印数组元素
    public static int[] array(int[] a) {
        int [] result = new int[a.length];

        //翻转操作
        for (int i = 0,j=result.length-1; i < a.length;i++,j--) {
            result[j] = a[i];
        }
        return result;

    }

    public static void print(int[] a) {
        for (int i = 0; i <a.length; i++){
            System.out.println(a[i]+"");
        }

    }
}

多维数组

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。

public class demo03 {


    public static void main(String[] args) {
        //定义二维数组
        /*
             1,2   array[0]
             2,3   array[1]
             3,4   array[2]
         */
        int[][] array = {{1,2},{2,3},{3,4}};
        System.out.println(array[0][1]);
        System.out.println(array[1][1]);
    }
}

Arrays类

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

面向对象

初识面向对象

面向对象编程(Object-Oriented Programming, ooP)
面向对象编程的本质就是:以类的方式组织代码，以对象的组织(封装)数据。
抽象
三大特性:
- 封装
- 继承
- 多态
从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象
从代码运行角度考虑是先有类后有对象。类是对象的模板
面向过程思想
- 步骤清晰简单，第一步做什么，第二步做什么…
- 面对过程适合处理一些较为简单的问题
面向对象思想
- 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
- 面向对象适合处理复杂的问题，适合处理需要多人协作的问题!
对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。

方法回顾和加深

修饰符&返回值类型

public class Demo01 {

    //main方法
    public static void main(String[] args) {

    }

    /*
       修饰符 返回值类型 方法名(...) {
           //方法体
           return 返回值;
     */

    public String sayHello() {
        return "hello word" ;
    }

    public void hello(){
        return;
    }
    public int max(int a , int b) {
        return a>b ? a : b; //三元运算符
    }
}

break和return的区别

break跳出switch，结束循环
return表示方法结束

   //return 结束方法，返回一个结果！
    public String sayHello() {
        return "hello word" ;
    }

    public void hello(){
        return;
    }

方法调用

静态

Student类

public class Student {

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

main调用

public class Demo02 {

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

}

非静态

Student类

public class Student {

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

main调用

public class Demo02 {

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

}

实参&形参

public class Demo02 {

    //静态方法  static
    public static void main(String[] args) {
        int add = Demo02.add(5,6);
        System.out.println(add);
    }
    public static   int add (int a ,int b){
        return a+b;
    }

值传递&引用传递

值传递

public class Dome04 {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a);

        Dome04.change(a);

        System.out.println(a); //1
    }

    //返回值为空
    public static void change(int a){
        a= 10;
    }
}

//输出 1  1

引用传递

//引用传递：对象，本质还是值传递
public class Demo05 {
    public static void main(String[] args) {
        Person person = new Person();

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

        Demo05.change(person);

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

    public static void change(Person person) {
        person.name = "xxh";
    }

}
//定义一个peson类,有一个属性：name
class Person{
    String name;
}

对象的创建分析

类与对象的关系

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

创建与初始化对象

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

main

//唯一main方法
public class Application {
    public static void main(String[] args) {
        //类，抽象的，实例化
        //实例化后会返回一个自己的对象；
        //studet就是一个Student类的实例化
        Student student = new Student();
        //System.out.println(student.name);

        student.name = "xxh";
        student.age = 20;
        System.out.println(student.name);
        System.out.println(student.age);

    }
}

Student类

public class Student {
    //属性：字段
    String name ;//null
    int age;  //0


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

构造器必须要掌握
类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点:
- 1.必须和类的名字相同
- 2.必须没有返回类型,也不能写void

person类

public class Person {
    //一个类即使什么都不写，他也会存在一个方法

    String name;

    //实例化初始值
    //1. 使用new关键字，必须要有构造器，new对象时本质是调用构造器
    //2. 构造器一般用来初始化值
    public Person(){

    }

    //有参构造：一旦定义了有参构造，无参构造必须显示定义
    public Person(String name){
        this.name = name;
    }

}

主函数

//唯一main方法
public class Application {
    public static void main(String[] args) {
        Person person = new Person( "xxh");
        System.out.println(person.name);
    }
}

面向对象三大特征

封装

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

主函数

/*
1. 提高程序的安全性，保护数据
2. 隐藏代码的实现细节
3， 同意接口
4， 系统可维护性增加
 */
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();

        s1.setName("xxh");

        System.out.println(s1.getName());

        s1.setAge(999);
        System.out.println(s1.getName());

    }
}

Student

//类   private：私有
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 getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age > 120 || age < 0) {
            this.age =3;
        } else {
            this.age=age;
        }
    }
}

继承

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

object类

主函数

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

        Student student = new Student();
        student.say();
        System.out.println(student.money);

    }
}

person

//person 人：父类
//在java中所有的类都默认继承object
public class Person {

    //public
    //protected
    //default
    //private

    private int money = 10;
    public void say(){
        System.out.println("说了一句话");
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}

Student

//学生 is 人：派生类，子类
public class Student extends Person{

}

Teacher

//teacher is 人：派生类，子类
public class teacher extends Person{
}

Super

super和this类似输入父类的类

主函数

//唯一main方法

import java.util.Scanner;

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

        Student student = new Student();
        student.test("徐");
    }
}

person类

//person 人：父类
//在java中所有的类都默认继承object
public class Person {
    public String name = "Maserati";
}

Student类

//学生 is 人：派生类，子类
public class Student extends Person{
    private String name = "xxh";
    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name); //输出父类中的那么Maserati
    }

}

方法重写

重写:需要有继承关系，子类重写父类的方法!
- 1．方法名必须相同
- 2．参数列表列表必须相同
- 3．修饰符:范围可以扩大但不能缩小:public>Protected>Default>private
- 4．抛出的异常:范围，可以被缩小，但不能扩大; ClassNotFoundException --> Exception(大)
重写,子类的方法和父类必要一致;方法体不同!

main

public class Application {
    //静态的方法和非静态的方法区别很大！
      //静态方法：//方法的调用只和左边，定义的数据类型有关
    public static void main(String[] args) {

        //方法的调用只和左边，定义的数据类型有关
        A a = new A();
        a.test(); //A

        //父类的引用指向了子类
        B b =new A(); //子类重写了父类的方法
        b.test(); //B

    }
}

A类

//继承
public class A  extends B{
    public static void test(){
        System.out.println("A=>test");
    }
}

B类

//重写都是方法的重写。和属性无关
public class B {
    public static void test(){
        System.out.println("B=>test");
    }
}

多态注意事项:
- 1.多态是方法的多态，属性没有多态
- 2．父类和子类，有联系类型转换异常! classcastException !
- 3．存在条件:继承关系，方法需要重写，父类引用指向子类对象!Father f1 = new Son();

static方法，属于类，它不属于实例
final常量;
private方法;l

抽象类和接口

抽象类

abstract修饰符可以用来修饰方法也可以修饰类,如果修饰方法,那么该方法就是抽象方法;如果修饰类,那么该类就是抽象类。
抽象类中可以没有抽象方法,但是有抽象方法的类一定要声明为抽象类。
抽象类,不能使用new关键字来创建对象,它是用来让子类继承的。
抽象方法,只有方法的声明,没有方法的实现,它是用来让子类实现的。
子类继承抽象类,那么就必须要实现抽象类没有实现的抽象方法,否则该子类也要声明为抽象类。

Action

package demo02;

//abstract 抽象类：类 extends:  单继承~  （接口可以多继承）
public abstract class Action {

    //约束~有人帮我们实现~
    //abstract , 抽象方法，只有方法名字，没有方法的实现
    public abstract void doSomething();
}
       /*
        1。不能new这个抽象类，只能靠子类去实现它;约束!
        2．抽象类中可以写普通的方法~
        3．抽象方法必须在抽象类中~抽象的抽象:约束~
        */

A.java

package demo02;

//抽象类的所有方法，继承了他的子类，都必须要实现他的方法~
public class A  extends Action{
    @Override
    public boolean equals(Object obj) {
        return super.equals(obj);
    }
}

接口

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

UserService

//interface 接口定义的关键字 , 接口都需要有实现类
public interface UserService {
    //接口中的所有定义其实都是抽象的 public abstract

    void add(String name);
    void delete(String name);
    void updata(String name);
}

UserServiceImpl

//抽象类：extends~
//类 可以实现接口 implements 接口
//实现了接口的类，就需要重写接口中的方法
public class UserServiceImpl implements UserService {
    @Override
    public void add(String name) {

    }

    @Override
    public void updata(String name) {

    }

    @Override
    public void delete(String name) {

    }
}

abstract修饰符可以用来修饰方法也可以修饰类,如果修饰方法,那么该方法就是抽象方法;如果修饰类,那么该类就是抽象类。
抽象类中可以没有抽象方法,但是有抽象方法的类一定要声明为抽象类。
抽象类,不能使用new关键字来创建对象,它是用来让子类继承的。
抽象方法,只有方法的声明,没有方法的实现,它是用来让子类实现的。
子类继承抽象类,那么就必须要实现抽象类没有实现的抽象方法,否则该子类也要声明为抽象类。

Action

package demo02;

//abstract 抽象类：类 extends:  单继承~  （接口可以多继承）
public abstract class Action {

    //约束~有人帮我们实现~
    //abstract , 抽象方法，只有方法名字，没有方法的实现
    public abstract void doSomething();
}
       /*
        1。不能new这个抽象类，只能靠子类去实现它;约束!
        2．抽象类中可以写普通的方法~
        3．抽象方法必须在抽象类中~抽象的抽象:约束~
        */

A.java

package demo02;

//抽象类的所有方法，继承了他的子类，都必须要实现他的方法~
public class A  extends Action{
    @Override
    public boolean equals(Object obj) {
        return super.equals(obj);
    }
}

接口

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

UserService

//interface 接口定义的关键字 , 接口都需要有实现类
public interface UserService {
    //接口中的所有定义其实都是抽象的 public abstract

    void add(String name);
    void delete(String name);
    void updata(String name);
}

UserServiceImpl

//抽象类：extends~
//类 可以实现接口 implements 接口
//实现了接口的类，就需要重写接口中的方法
public class UserServiceImpl implements UserService {
    @Override
    public void add(String name) {

    }

    @Override
    public void updata(String name) {

    }

    @Override
    public void delete(String name) {

    }
}

Msaerati

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java入门基础

注释，标记符，关键字注释单行注释多行注释文档注释关键字java自带的，有一些特定的作用，例如class public System等等起名字是不可以用关键字定义a输入123-byte（字节型）、short（短整型）、int（整型）、long（长整型）浮点型(2个)float（单精度型/浮点型）、double（双精度型）字符型(1个)char（字符型布尔类型(1个)boolean(布尔类型）一般用来做逻辑判断，一般用于流程控制，数据值只有true或false，适用于逻辑计
复制链接

扫一扫

专栏目录