java基础02

最新推荐文章于 2024-07-31 19:38:21 发布

390396010

最新推荐文章于 2024-07-31 19:38:21 发布

阅读量118

点赞数

分类专栏： java基础文章标签： java

本文链接：https://blog.csdn.net/qq_48357019/article/details/107927928

版权

java基础专栏收录该内容

5 篇文章 0 订阅

订阅专栏

Scanner对象

next():

- 一定要读取到有效字符后才可以结束输入
- **对输入有效字符之前遇到的空白，next()方法会自动将其去掉**
- 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符
- **next()不能得到带空格的字符串**

nextLine();

- 以Enter为结束符  返回回车之前的所有字符
- 可以获得空白

hashNext()：是否有下一个 hashNextInt()：判断下一个是不是整数

if语句为真执行{ }，执行完{ },在执行{ }之后的为假{ }不执行，执行{ }之后的

打印三角形

		 for (int i = 1; i <=5 ; i++) {
            for (int j = 5; j >=i ; j--) {
                System.out.print(" ");  //输出空格
            }
            for (int j = 1; j <=i ; j++) {
                System.out.print("*");
            }
            for (int j = 1; j <i ; j++) {
                System.out.print("*");
            }
            System.out.println();
       	 }

重载

1、参数的类型不同

2、参数的顺序不同（两个不同类型的参数顺序不同可以）

3、参数的个数不同

4、与返回值无关

命令行传参

main方法也可以传递参数 String 类型

doc窗口

javac 文件名.java 编译

在命令行找到项目的src目录输入 java 包名.类名才能运行

可变参数

在方法声明中，在指定参数类型后加一个省略号(…) 本质是数组

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

	public static void main(String[] args) {
        test(1,2,3,4,5,6);
    }
    public static void test(double... i){
        for (int j = 0; j <i.length ; j++) {
            System.out.println(i[j]);
        }
    }

递归

递归结构包括两个部分

- 递归头:什么时候不调用自身方法。如果没有头，将陷入死循环。
- 递归他：什么时候需要调用自身方法。

数组

是相同数据类型的有序集合

定义 int[] ss=new int[] , int sss[] 不推荐这种;

三种初始化状态

1.静态初始化

除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。

例 int[] a={1,2,3};//静态初始化基本类型数组

Man[] mans={new Man(1,1),new Man(2,2)};//静态初始化引用类型数组

2.动态初始化

数组定义与为数组元素分配空间并赋值的操作分开进行

int[] a1=new int[2];//动态初始化元素，先分配空间

a1[0]=1;//给数组元素赋值

a1[2]=2;

3.数组的默认初始化

数组是引用类型，他的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化

实例：int a2[]=new int[2];//默认值0，0

boolean[] b=new boolean[2];//默认值 false，false

String[] s=new String[2];//默认值null

数组的基本特点

长度是声明数组对象的时候就确定的，数组一旦被创建，它的大小就不可以更改。
起元素必须是相同类型的，不能是混合型。
数组类型可以是任何数据类型，包括基本类型和引用类型。
数组对象本身是在堆中的。
数组也是对象，数组元素相当于对象的成员变量

java内存分析

在这里插入图片描述

Array类

数组的工具类

返回类型	方法	说明
String	toString（a[ ]）	将数组a转换成字符串
void	sort（a[ ]）	对数组进行升序排列
void	fill（arr，val）	将数组arr全部元素赋值为val
boolean	equals（arr1，arr2）	判断两个数组是否相等
与arr类型相同	copyOf（arr，length）	将数组arr复制成一个长度为length的新数组
int	binarySearch(arr, val)	查询元素val在arr中的下标值

面向对象编程

在这里插入图片描述
面向对象编程(oop)

面向对象编程的本质是：以类的方式组织代码，以对象的方式组织(封装)数据

三个特性

封装
继承
多态

从认识角度考虑是先有对象后有类。对象，是具体的事务。类，是抽象的，是对对象的抽象

从代码运行角度考虑是先有类后有对象。类是对象的模板

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

值传递

public static void main(String[] args) {
        int a=1;
        System.out.println(a);//1
        chang(a);   //并没有返回
        System.out.println(a);//1 
    }

    public static void chang(int a){
        a=10;
    }

引用传递

public class ArraysTest {

    public static void main(String[] args) {
        Person person=new Person();
        System.out.println(person.name);//null
        chang(person);
        System.out.println(person.name);//李

    }

    public static void chang(Person person){
        person.name="李";
    }
}

class Person{
    String name;
}

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

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

class Person{
    String name;  //默认为NULL
}

构造器

一个类及时什么都不写，也会存在一个空的构造方法

构造方法必须和类名相同
必须没有返回类型，也不能写void
一旦定义了有参构造，必须手动定义无参构造。
new本质在调用构造器
初始化对象的值

总结：

类与对象
- 类是一个模板：抽象，对象是一个具体的实例
对应的引用
- 引用类型：基本类型
- 对象是通过引用类型操作的
属性：字段field 成员变量
- 默认初始化
  - 数字： 0 0.0
  - cahr: u0000
  - boolean: false
  - 引用： null

封装

高内聚低耦合

属性私有set/get 属性为什么私有？可以在set方法中设置if语句判断不让随意给属性赋值

pubic void setAge(int age){
    if(age > 120 || age <0){
        System.out.println("年龄不合法")
    }
    //否存才能赋值成功
    this.age=age;
}

继承

java只有单继承，没有多继承

继承是类和类之间的关系，除此之外，类和类之间的关系还有，依赖，组合，聚合等。

关键句 extands

子类继承了父类，就会拥有父类的全部方法

所有的类，都默认直接或间接继承object

super

使用super关键字可以调用父类的方法

子类继承了父类 初始化了子类同时也会默认初始化父类在子类无参构造器的有一行隐藏代码 suer()

super()必须在第一行 //调用父类的构造器必须在子类构造器的第一行

父类如果没有无参子类的无参构造器就会报错，所以必须要有无参，除非写上super（有参）这样才能不报错。

必须手写调用，默认调用的是父类的无参

注意点：

super调用父类的构造方法，必须在构造方法的第一行。其他方法会报错
super必须只能出现在子类的方法或者构造方法的中！
super和this不能同时调用构造方法

this

代表的对象不同

this 本身调用者这个对象
super 代表父类对象的应用
this 没有继承也可以使用，super只能在继承条件下才可以使用

构造方法

this（）：本类的构造

super（）：父类的构造

方法重写

重写都是方法的重写，和属性无关。

静态方法和非静态方法区别很大！

静态方法：方法的调用只和左边，定义的数据类型有关

非静态方法：重写
在这里插入图片描述

多态

多态是同一个行为具有多个不同表现形式或形态的能力。

一个对象的实际类型是确定的

new Student();

可以指向的引用类型就不确定了：父类的引用指向子类

Student 能调用自己的方法和父类的方法

Student s1=new Student();

Person 父类型，可以指向子类，但是不能调用子类独有的方法。

Person s2=new Student();

对象能执行哪些方法，主要看对象左边的类型，和右边的关系不大。

注意事项：

多态是方法的多态，属性没有多态

父类子类相同方法，优先使用子类，子类没有使用父类。Person s2=new Student();

父类不能使用子类的独有方法需要强转 Person s2=new Student();

多态存在的三个必要条件

继承
重写
父类引用指向子类对象

类型之间的转换父子高转低需要强转

父类引用指向子类对象

把子类转换为父类，向上转型

把父类转换成子类，向下转型：强转

    {
        System.out.println("匿名代码块");
    }

    static{
        System.out.println("静态代码块");
    }

    public t(){
        System.out.println("构造方法");
    }
执行顺序
    静态代码块
    匿名代码块
    构造方法

接口

抽象类的所有方法必须由继承他的子类实现

接口可以多继承

抽象类不能new

抽象类可以写普通的方法

普通类：具体的实现

抽象：具体的实现和规范都有

接口：只有规范，约束和实现分离。

接口中所有定义都是抽象的

接口在 public abstract 是隐藏的不用写

总结：

1.约束

2.定义方法，让别人实现

3.方法都是 public abstract

4.所有属性都是常量自带 public static final

5.接口不能被实例化，没有构造方法，抽象类有构造方法

6.可以实现多个接口

内部类

内部类可以获得外部类的一切静态内部类除外

public class o{
    //内部类
    class u{
        
    }
    
    public void method(){
        //局部内部类
        class{
            
        }
    }
}
//一个java类中可以有多个class类型，但是只能有一个public class
class A{
    public void eat(){}
}

匿名内部类,不用将实例保存在变量中
new A().eat();