java笔记二java基础语法

最新推荐文章于 2023-08-09 22:08:25 发布

原创最新推荐文章于 2023-08-09 22:08:25 发布 · 464 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java

JAVA基础专栏收录该内容

19 篇文章

订阅专栏

package day02code;
/*面向对象，类与对象，三大特征--封装，构造方法*/
public class Demo01Class {
    /*什么是类？
    * 类：一组相关属性和行为的集合，一类事物的模板
    * 属性：事物的状态信息
    * 行为：事物能够做什么
    * 什么是对象？
    * 对象是类的一个实例，实例一定具备类的属性和行为
    * 类和对象有什么关系呢？
    * 类是事物的描述，抽象的。
    * 对象是事物的实例，具体的。
    * */
}

package day02code;

public class Student {
    String name;
    int age;
    //成员方法的定义就是把之前方法的static给去掉
    public void study(){
        System.out.println("我爱学习");
    }
    public void eat(){
        System.out.println("我爱吃饭");
    }
}

package day02code;

public class Test01_Student {
    /*如何使用定义好的对象呢？
    * 类名 对象名 = new 类名*/
    public static void main(String[] args) {
        Student s = new Student();
        /*给成员变量赋值*/
        s.name = "赵四";
        s.age = 18;
        /*如何调用成员方法呢？*/
        s.study();
        s.eat();
    }
}

package day02code_package;
/*封装的优化1：this关键字*/
public class Student {
    /*private 数据类型 变量名*/

    /*提供get方法、set方法，可以访问成员变量
     * 1.方法就是一个封装
     * 2.关键字private也是一种封装
     * this关键字：
     * this代表所在类的当前对象的引用（地址值），即对象自己的引用
     * 记住：方法被哪个对象调用，方法中的this就代表哪个对象，即谁在调用，this就代表谁*/
    /*JavaBean
    * 成员变量
    * 构造方法
    * 无参构造方法
    * 有参构造方法
    * 成员方法
    * getXxx()
    * setXxx()*/
    //成员变量
    private String name;
    private int age;
    //构造方法
    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }
    //成员方法
    public void setName(String name) {
        /*this.成员变量名*/
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

}

package day02code_package;

public class Test01Student {
    public static void main(String[] args) {
        //空参构造再赋值
        Student s = new Student();
        System.out.println(s);
        s.setName("柳岩");
        s.setAge(18);
        System.out.println(s.getName() + s.getAge());
        //带参构造
        Student s2 = new Student("赵丽颖", 19);
        System.out.println(s2.getName() + s2.getAge());
    }
}

day07【Scanner类、Random类、ArrayList
类】
Scanner类

package day02ScannerRandomArraylist;

import java.util.Scanner;

/*什么是API？
 * Application Programming Interface应用程序编程接口。
 * JAVA API就是一个字典*/
public class Demo01_Scanner {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();
        int sum = a + b;
        System.out.println("sum:" + sum);
    }
}

Random类

package day02ScannerRandomArraylist;

import java.util.Random;
import java.util.Scanner;

/*随机产生三个10以内的整数，并输出*/
public class Demo02_Random {
    public static void main(String[] args) {
        Random r = new Random();
        for (int i = 0; i < 3; i++) {
            int n = r.nextInt(10);
            System.out.println(n);
        }
        /*获取50之间的随机数，包含50*/
        Random r1 = new Random();
        int n = 50;
        int number = r1.nextInt(n) + 1;
        System.out.println(number);

        /*猜数字小游戏：
         * 游戏开始时，会随机生成一个1-100之间的整数number。
         * 玩家猜测一个数字guessNumber ，会与number作比较，系统提示大了或者小了，
         * 直到玩家猜中，游戏结束。*/
        int a = 100;
        Random r3 = new Random();
        int Sysnumber = r3.nextInt(a) + 1;
        while (true) {
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入你要猜的数字(1‐100)：");
            int guessNumber = sc.nextInt();

            if (guessNumber > number) {
                System.out.println("你猜的数据" + guessNumber + "大了");
            } else if (guessNumber < number) {
                System.out.println("你猜的数据" + guessNumber + "小了");
            } else {
                System.out.println("恭喜你,猜中了");
                break;
            }
        }
    }
}

ArrayList类

package day02ScannerRandomArraylist;

import java.util.ArrayList;

public class Demo03_ArrayList {
    /* 什么是ArrayList？
     * java.util.ArrayList是大小可变的数组的实现，存储在内的数据叫做元素
     * ArrayList类提供一些方法来操作存储在内部的一些元素，ArrayList中可以不断添加元素，大小也会自动增长
     * 怎么使用ArrayList呢？
     * <E>泛型，表示一种指定的数据类型，Element，出现E的地方，我们使用一种引用数据类型将其替换即可
     * ，表示我们要存储哪种引用类型的元素
     * ArrayList<String>,ArrayList<Student>*/
    public static void main(String[] args) {
        //创建学生数组
        ArrayList<String> list = new ArrayList<>();

        //创建学生对象
        String s1 = "曹操";
        String s2 = "张飞";
        String s3 = "关羽";

        //打印学生ArrayList集合
        System.out.println(list);

        //把学生对象作为元素添加到集合中去
        list.add(s1);
        list.add(s2);
        list.add(s3);

        //再次打印学生集合
        System.out.println(list);
    }
}

package day02ScannerRandomArraylist;

import java.util.ArrayList;

public class Demo04_ArrayListMethod {
    /*ArrayList是一个类
     * 那么它包含哪些常用的方法呢？
     * 对于元素的操作，基本体现在，add，delete，alter，select
     * public boolean add(E,e):将指定的元素添加到集合的尾部
     * public E remove(int index):移除此集合中指定位置上的元素.返回被删除的元素。
     * public E get(int index) ：返回此集合中指定位置上的元素。返回获取的元素
     * public int size() ：返回此集合中的元素数。遍历集合时，可以控制索引范围，防止越界。*/
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        //add(E,e):将指定的元素添加到集合的尾部
        list.add("hello");
        list.add("java");
        list.add("world");

        //返回0号索引位置的元素值
        String str = list.get((0));
        System.out.println(str);

        //返回集合中元素的个数
        int a = list.size();
        System.out.println(a);

        //删除指定索引出的元素，返回被删除的元素
        String str2 = list.remove(1);
        System.out.println(str2);

        //遍历ArrayList,首先要知道数组的大小，再去索引对应元素的内容即可
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

包装类

package day02ScannerRandomArraylist;

import java.util.ArrayList;
import java.util.Random;

public class Demo05PackageGroup {
    /*ArrayList对象不能存储基本类型的，只能存储引用类型
    *也就是说，没有<int>这种情况，那么怎么存储基本数据类型呢？
    * 包装类型：
    * 基本类型基本类型包装类
    byte Byte
    short Short
    int Integer
    long Long
    float Float
    double Double
    char Character
    boolean Boolean
    *Integer和Character需要特殊记忆，其他的都是把首字母大写即可*/
    public static void main(String[] args) {
        /*生成6个1~33之间的随机整数,添加到集合,并遍历*/
        //创建Random对象
        Random random = new Random();

        //创建ArrayList对象
        ArrayList<Integer> list = new ArrayList<>();

        //添加随机数到集合中去
        for (int i = 0; i < 6; i++) {
            int r = random.nextInt(33) + 1;
            list.add(r);
        }

        //遍历集合输出
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i));
        }
    }
}

继承

1.先写父类

package day02code_extends;

public class Employee {
    public void method() {
        System.out.println("方法执行！");
    }
}

2.再写子类

package day02code_extends;

/*先写父类，再写子类extends父类*/
public class Teacher extends Employee {
    public void printName() {
        System.out.println("尽心尽力的工作");
    }
}

3.定义一个测试类

package day02code_extends;
/*在继承的关系中，子类就是一个父类
* 父类是员工
* 子类是讲师*/
public class Demo01Extends {
    public static void main(String[] args) {
        Teacher tc = new Teacher();
        tc.method();
        /*先写了一个父类，又写了一个子类，不是复杂了么？
        * 不是，如果是多个子类，只需要写一个父类方法即可*/
    }
}

如果要是子类的成员变量和父类的成员变量重名了怎么办呢？
super关键字
1.定义父类

package day02code_extends;

public class Fu {
    int num = 5;
}

2.定义子类

package day02code_extends;

public class Zi extends Fu {

    int num = 6;

    public void show() {
        System.out.println("Fu num  = " + num);
        System.out.println("Zi num = " + num);
        System.out.println("Fu num = " + super.num);
        System.out.println("Zi num = " + this.num);
    }
}

3定义测试类

package day02code_extends;

public class Demo02Extends {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();
        /*父类的成员变量int num = 5
         * 子类的成员变量int num = 6
         * 此时访问的是子类的成员变量num = 6
         * 如果非要访问父类的非私有成员变量怎么办呢？
         * super关键字，用法如下*/
    }
}

4.结果

Fu num  = 6
Zi num = 6
Fu num = 5
Zi num = 6

上面讨论的是成员变量的重名问题，如果方法重名了怎么办呢？
方法的重写，子类会重写和父类同名的构造方法
子类可以根据需要，定义特定于自己的行为。既沿袭了父类的功能名称，又根据子类的需要重新实现父类方法，从
而进行扩展增强。
1.定义父类

package day03code_extends;

public class Fu {
    public void show(){
        System.out.println("我是爸爸");
    }
}

2.定义子类

package day03code_extends;

public class Zi extends Fu {
    public void show(){
        System.out.println("我是儿子");
    }
}

3.定义测试类

package day03code_extends;

public class Demo01Test {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();
    }
}

4结果（方法重写的体现）

我是儿子

抽象类：如果每一个子类都去重写父类的成员方法，那么还要父类的成员方法干啥呢？所以抽象类出现了
如何定义一个抽象类？
1.定义父类

package demo01;

/*到底是吃鱼还是吃骨头，吃是很抽象的*/
public abstract class Animal {
    //这是一个抽象方法，代表吃东西，具体吃啥不确定，抽象方法所在的方法一定是抽象类
    public abstract void eat();
}
//先把抽象方法的void前面加上abstract，再把{}去掉，最后在class前面加上abstract

2.定义子类
对方法进行了重写

package demo01;

public class Cat extends Animal {
    public void eat(){
        System.out.println("吃鱼");
    }
}

3.定义测试类

package demo01;

public class CatTest {
    public static void main(String[] args) {
        Cat c = new Cat();
        c.eat();
    }
}
/*1.抽象类不能创建对象，为什么？连方法体都没有
* 2.抽象类的子类，必须重写抽象父类中所有的抽象方法*/

接口就是把一大堆方法放到一起，想实现的时候用一个类去实现就可以了
什么是接口？

package demo02;

public interface Demo01Interface {
    /*什么是接口呢？
     * 引用类型，方法的集合
     * 之前学过的类，封装了成员变量，成员方法
     * 那么，接口的内部就是封装了方法，包含，抽象方法，默认方法，静态方法，私有方法
     *
     * 创建的时候发现和Class在同一个地方，所以接口和Class是十分相似的，也会被编译成.class文件
     * 但是Interface是另外一种引用类型
     * 怎么使用Interface呢？
     * 搞清楚接口是方法的集合，implements.
     * 一个实现接口的类（可以看做是接口的子类），需要实现接口中所有的抽象方法*/
}

接口中可以放入哪些方法呢？

package demo02;

public interface InterfaceName {
    /*定义了一个抽象方法*/
    public abstract void method1();
    /*定义了一个默认方法*/
    public default void method2(){

    }
    /*定义了一个静态方法*/
    public static void method3(){

    }
    /*定义了一个私有方法*/
    private void method4(){

    }
}

定义一个接口，里面有两个抽象方法

package demo02;

public interface LiveAble {
    public abstract void eat();
    public abstract void sleep();
}

定义一个Animal测试类去实现接口

package demo02;

public class Animal implements LiveAble {
    @Override
    public void eat() {
        System.out.println("吃东西");
    }

    @Override
    public void sleep() {
        System.out.println("晚上睡");
    }
}

第三大特性，多态，多态有两种体现方式，一种是通过子父类去实现，另一种是用接口去实现，这里用的是子父类去实现
1.定义一个父类

package demo05;

public abstract class Animal {
    public abstract void eat();
}

2.定义猫狗两个子类

package demo05;

public class Cat extends Animal {
    public void eat(){
        System.out.println("吃鱼");
    }
}

package demo05;

public class Dog extends Animal {
    public void eat(){
        System.out.println("吃骨头");
    }
}

3.实现多态

package demo05;

public class Test {
    /*多态的体现
    * 父类类型 变量名 = new 子类对象
    * 变量名.方法名（）
    * 什么是父类类型呢？
    * 继承的角度：子类继承父类对象
    * 实现的角度：类实现父接口类型*/
    public static void main(String[] args) {
        //从继承的角度去创建对象
        //父父new子
        Animal a1 = new Cat();
        //看到方法想到 调用 两个字，此处调用的是Cat的eat方法
        //子类和父类想到 继承 两个字
        //接口想到 实现 两个字
        a1.eat();

        Animal a2 = new Dog();
        //调用的是Dog中的eat
        a2.eat();
    }
}

4.多态的好处

package demo06;

public class Test01 {
    public static void main(String[] args) {
        Animal c = new Cat();
        Dog d = new Dog();
//        showCatEat(c);
        showDogEat(d);
        showAnimalEat(c);
        showAnimalEat(d);
    }
    /*不用多态的话要写两个方法才行*/
    public static void showCatEat(Cat c) {
        c.eat();
    }

    public static void showDogEat(Dog d) {
        d.eat();
    }
    /*用多态的话写一个方法就可以了*/
    public static void showAnimalEat(Animal a) {
        a.eat();
    }
  
}