2021-03-23

最新推荐文章于 2024-08-12 16:47:32 发布

weikejoe

最新推荐文章于 2024-08-12 16:47:32 发布

阅读量202

点赞数 1

文章标签： java

本文链接：https://blog.csdn.net/weikejoe/article/details/115110124

版权

java命名规范

类名：首字母大写，如果出现第二个单词首字母大写； //ClassStudent
变量名/方法名：首字母小写如果出现第二个单词首字母大写； //newNum
常量：全大写字母； //Math.PI final int NUM = 55
不能以数字开头

关键词

在这里插入图片描述

标识符（标识符是什么？就是给变量，方法，类等命名的符号。标识符的命名要参照以下几条规则。）

标识符可以由字母、数字、下划线组成。但是标识符不能以数字开头：123num这就是非法标识符；
标识符不可由关键字命名；
Java中是严格区分大小写，所以Program和program是代表不同的标识符；
标识符最好能表示明确的含义。

Java中的数据类型

在这里插入图片描述

在Java中基本数据类型直接存储数据本身，而引用类型存储的是数据的空间地址**。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EVWc78fP-1616463475736)(数据类型例子.png)]

方法

static：静态方法（假如没有static实例化这个类）

非静态方法

Student student=new Student())

1.方法是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集。

1.方法必须先创建才能使用，该过程称为方法定义

2.方法创建后并不是直接能运行的，需要手动使用后才执行，该过程称为方法调用。

形参与实参

blic static void main(String[] args) {
        ui(5);//常量值的调用
        int jk=8;//变量值的调用，jk为实参
        ui(jk);
    }
    public static void ui(int jk){//jk为形参
        if (jk%2==0){
            System.out.println(true);
        }else{
            System.out.println(false);
        }

    }

待返回值方法的定义与调用

package method;

public class Demo05 {
    public static void main(String[] args) {
        boolean q=num(8);//用变量保存num的类型
        System.out.println(q);
        boolean c=qq(5,6);
        System.out.println(c);

    }
    public static boolean num(int a){
        if (a%2==0){
            return true;
        }
        else{
            return false;
        }
    }
    public static boolean qq(int a,int b){
        if (a>b){
            return true;
        }else{
            return false;
        }
    }
}

方法重载

方法重载指的是一个类定义的多个方法之间的关系，满足下列条件的多个方法构成重载

（重载是指在同一个类中允许方法名相同但是参数的类型，顺序，个数不能完全一样）

1.多个方法在同一个类中

2.多个方法具有相同的方法名

3.多个方法的参数不同，类型或者数量不同。

方法重载的特点

1.重载仅对应方法的定义，与方法的调用无关调用方式参照标准格式

2.重载仅对应一个类中方法的名称与参数进行识别，与返回值无关，不能通过返回值来判断两个方法是否构成重载。

package method;
//利用不同的数据类型应用对应的重载方法
public class Demo08 {
    public static void main(String[] args) {

        System.out.println(qwq((int) 10,(int) 15));
        System.out.println(qwq((short) 10,(short) 15));
    }
    public static boolean qwq(int a,int b){
        if(a==b){
            System.out.println("int");
            return false;
        }
        System.out.println("int");
return false;
    }
    public static boolean qwq(short a,short b){
        if(a==b){
            System.out.println("short");

            return false;

        }
        System.out.println("short");
        return false;
    }
}

方法的参数传递：

package method;
//形参的改变不影响实参的值
public class Demo09 {
    public static void main(String[] args) {
        int number=100;
        System.out.println("number的值为"+number);
        add(number);
        System.out.println("number的值为"+number);
    }
    public static void add(int number){
        number=200;
    }
}   100
    100

方法的参数传递：（引用类型）

int[] arr={1,2,3};
        System.out.println(arr[1]);1
        add(arr);2
        System.out.println(arr[1]);

    }
    public static void add(int[] arr ){3 //该方法时传递的为数组的地址
        arr[1]=100;//4.该步骤将arr[1]的值赋值为100

方法参数传递

实例将一个数组在一行输出

public class  Demo11
public static void main(String[] args){
    
}
public static void add(int[] arr){
    for(int i=0;i<arr.length;i++){
        System.out.print(arr[i]);
    }
    if(i==arr.length){
        System.out.print("arr[i]")
    }else{
        System.out.print("arr[i],")
    }
}

数组遍历
public class  Demo11 {
    public static void main(String[] args) {
int[] arr={1,5,6,8,8};
add(arr);
    }

    public static void add(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                System.out.print(arr[i]);
            } else {
                System.out.print(arr[i] + ",");
            }
        }
            System.out.println("]");
        }
    }

https://blog.csdn.net/qq_45893999 （）

String 密码比较的输入；

package String;

import java.util.Scanner;

public class Demo03 {
    public static void main(String[] args) {
        int a=123;
        String b="abc";
        for (int i = 0; i <3 ; i++) {//当中定义的为最大的次数，此中为二


        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个数字");
        String s = sc.nextLine();//利用s来接收sc实例化的对象
            for (int j = 0; j <3 ; j++) {
                if(s.equals(b)){//将输入的s与b进行比较
            System.out.println("密码输入正确");
            break;
        }else{
            System.out.println("你还有"+(2-i)+"次机会");
            break;
        }
    }}}
}

String按顺序输出

package String;

import java.util.Scanner;

public class Demo04 {
    public static void main(String[] args) {
        Scanner ss = new Scanner(System.in);
        System.out.println("将字符串按顺序输出");
        String s = ss.nextLine();
        for (int i = 0; i <s.length() ; i++) {

            System.out.println(s.charAt(i));//读取字符串的第i个字符
           
        }
    }
}

查找数字是否存在于数组中

 int [] arr={12,35,55,66,23,32};
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个数字");
        int s = sc.nextInt();
        search(arr,s);
    }
    public static int search(int [] arr,int a){

        for (int i = 0; i <arr.length ; i++) {
            if (arr[i]==a){
                System.out.println("该数据在此数组中");
                break;
            }else{
                System.out.println("该数字不在此数组中");
 break;
            }

        }

    return a;}
}

super关键字

super访问的是父类的方法与变量

数组

数组的概念：

数组是相同类型的有序集合。

数组描述的是相同类型的若干个数据，按照一定的先后顺序组合

每一个数据称为一个数据元素，每一个元素可以通过下标来访问。

数组操作

使用时应先声明数组 int[] nmus=new int[10];定义了一个10个数据的数组。
array.length 获取数组的长度

数组创建方式

静态初始化int[] a={1,3,5,7}
动态初始化int [] m=new int[];m[0]=1 进行初始化不进行赋值则为0

数组的基本特点

长度是确定的，确定后不能改变
元素为相同的类型不能混淆
数组中可以是任何类型，包括引用类型
数组变量属于引用类型，数组也可以是变量保存在堆中

冒泡排序

Arraylist的具体扩展：

在这里插入图片描述

面向对象编程（oop）

了解一个对象的详细信息，并关注他，这个过程就叫面向对象，面向一个具体的事物的操作，叫做面向对象编程

以类的方式组织代码，以对象的组织（封装）数据

抽象

封装
继承
多态

继承：

关键字extends，可以有多个子类继承一个父类，提高了代码的复用性，节约了空间，但是也使得了代码之间存在了耦合的可能性。

继承提高了代码的复用性。
继承提高了代码的维护性。

弊端
1. 继承让类与类之间产生了关系当父类关系发生了改变子类也不可以产生变化

ex：当内部方法中需要一个变量时，首先在方法中寻找然后再去方法外成员范围找，然后再去父亲成员范围找，若找不到就会报错。

在这里插入图片描述

package com.catdog;

public class Animal {
    private String name;
    private int age;
//无参构造方法
    public Animal() {
    }
//有参构造方法
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
//创建set get方法
    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

}


package com.catdog;

public class Cat extends Animal {
    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }
    public void LookDoor(){
        System.out.println("看门史努比");
    }
}

package com.catdog;

public class Dog extends Animal{
    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }
    public void CatchMouse(){
        System.out.println("抓住大老鼠");
    }
}

test测试类
    public class AnimalDemo {
    //引入main方法
    public static void main(String[] args) {


    //创建一个实例猫
    Cat c=new Cat();
    c.setAge(2);
    c.setName("luu");
    c.LookDoor();
        System.out.println(c.getName()+","+c.getAge());
    Dog d=new Dog();
    d.setAge(45);
    d.setName("WeiKeJoe");
        System.out.println(d.getName()+","+d.getAge());
    d.CatchMouse();
}
}

多态

多态能节约方法调用的空间当多种类调用童一种方法时可以节约代码提高可扩展性，但是不能访问子类中所特有的方法，因为方法进行了重写但子类中的方法并没有进行重写。

//这是父类
public class xuanfei {
    public void zhenFei(){
        System.out.println("选中的是甄妃");
    }
}
//这是子类
public class xuanfei01 extends xuanfei {
    //注解功能是检测是否与父类的方法一致
    @Override
    public void zhenFei() {
        System.out.println("选中的是荷花");
    }
    public void mingfei(){
        System.out.println("今夜无人");
    }
}
//子类
public class xuanfei02 extends xuanfei{
    @Override
    public void zhenFei() {
        System.out.println("荷紫");
    }
}
//操作类
public class XuanFeiOperator {
    public void XuanFeiOperator(xuanfei s){//相当于zhenFei s=new ZhenFei();创建父多态对象用来参数传输子对象
        s.zhenFei();

    }
}
//测试类
public class XuanFeiDemo {
    //测试类
    public static void main(String[] args) {
        //将侧试类实例化，提供了通道访问父类的方法
        XuanFeiOperator s=new XuanFeiOperator();
        //利用对象实例化来调用方法，将方法实例化，用实例来调用方法
        xuanfei qq=new xuanfei();
        s.XuanFeiOperator(qq);
        xuanfei01 ee=new xuanfei01();
        s.XuanFeiOperator(ee);
        xuanfei02 rr=new xuanfei02();
        s.XuanFeiOperator(rr);
    }
}

当需要调用子类特有方法时采用向下转型

//父类
public class Animal {
    public void eat(){
        System.out.println("动物吃食物");
    }
}
//子类
public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
    public void catchMouse(){
        System.out.println("猫抓老鼠");

    }
}
//测试类
public class AnimalDemo  {
    public static void main(String[] args) {
        //创建多态对象
        Animal A=new Cat();//向上转型
        A.eat();//运行看左边，执行看右边
        //A.catchMouse();
        //向下转型解决了不能访问子类特有属性的问题
        Cat c=(Cat)A;//这里相当于Cat c=（Animal）A
        c.catchMouse();

    }
}

多态：猫与狗实例

//编写父类
ublic class Animal {
    public String name="Tom";
    public int age=13;

    public Animal() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    public void eat(){
        System.out.println("动物会吃蛋");
    }
}

//编写猫与狗子类
public class Cat extends Animal {
    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("喵吃小鱼干");//执行看左边，运行看右边
    }
    public void qq(){
        System.out.println("喵喵吃QQ糖");
    }
}
public class Dog extends Animal {
    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("小狗吃骨头");
    }
}
//测试类
public class DemoAnimal  {
    public static void main(String[] args) {
        //多态形式创建对象
        Animal s=new Cat();
        //无参构造函数
        s.setName("加肥");
        s.setAge(12);
        System.out.println(s.getName()+","+s.getAge());
        s.eat();
        s=new Cat("加菲",5);
        System.out.println(s.getName()+","+s.getAge());
        Animal d=new Dog();
        d.eat();
        //向下转型将向上转型的s赋值给新创建的c
        Cat c=(Cat)s;
        c.qq();
    }
}

抽象类

抽象类中不一定有抽象方法，有抽象方法的一定是抽象类。
抽象方法不能实例化，但是可以通过子类用多态的形式进行实例化，这叫做抽象类多态。
抽象类以及子类用abstract修饰，
子类如果没有抽象类修饰，则要重写父类的方法，

//父类是抽象类
public abstract  class Animal {
    public abstract void sleep();//抽象类
    public  void eat(){
        System.out.println("猫吃小饼干");
    }

}
//子类则要重写父类中所有的抽像方法或者为抽像类
public  class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("汪汪汪汪汪");
    }

    @Override
    public void sleep() {
        System.out.println("miiaomm");
    }
}
public class Cat extends Animal {
    @Override
    public void sleep() {
        System.out.println("嗷呜");
    }

    @Override
    public void eat() {
        System.out.println("猫jjj");
    }
}
//测试类
public class AnimalDemo {
    public static void main(String[] args) {
        //利用抽象类多态将子类实例化对象
        Animal s=new Cat();
        s.eat();
        s.sleep();
        Animal b=new Dog();
        s.eat();
        s.sleep();
    }
}

猫和狗（抽象类版）

//创建抽象类
public abstract class Animal {
    private String name;
    private int age;
//无参构造函数与有参构造函数
    public Animal() {
    }

    public Animal(String name,int age) {
        this.name = name;
        this.age=age;
    }
//创建get与set方法
    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
//抽象类此处作用是并不将其具体化而是根据具体的实现方法去进行
    public abstract void eat();
    
}
//创建猫和狗的子抽象类
 public class Cat extends Animal{
    //重写方法
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }
}
public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }
    public void wang(){
        System.out.println("汪汪汪");
    }
}
//测试类
public class AnimalDemo {
    public static void main(String[] args) {
        //创建对象
        Animal a=new Cat();
        a.setAge(1);
        a.setName("aa");
        System.out.println(a.getName()+","+a.getAge());
        a.eat();
        System.out.println("-----------");
        Animal b=new Dog();
        b=new Dog("旺财",3);
        System.out.println(b.getName()+","+b.getAge());
        b.eat();
        //向下转型使用子类方法中特定的方法
        Dog s=(Dog)b;
        s.wang();
    }
}

接口

接口的定义

接口就是一种公共的规范标准，只要符合规范就可以使用

java中的接口更多的体现在对行为的抽象上

接口的特点

接口用interface修饰

public interface 接口名{}
- 类实现用implements表示
  
  public class 类名 implements 接口名{}
  - 接口不能实例化？参照多态的形式父类变量=new 子类（）；
    
    多态的形式：具体类多态，抽象类多态，接口多态
  - 多态的前提是1.有继承关系2.有方法重写3.有父引用指向子引用
  - 接口的实现类1.重写接口的所有抽象方法2.要么是抽象类

//接口  
public interface jumping {
    public abstract void jump();
}
//接口实现类
public class Cat implements jumping {
    @Override
    public void jump() {
        System.out.println("猫要吃鱼了");
    }
}
public  class Tiger implements jumping{

    @Override
    public void jump() {
        System.out.println("狗咬叫了");
    }

    public void go(){
        System.out.println("狗可以跳高了");
    }
}
//接口测试类
public class jumpDemo {
    public static void main(String[] args) {
        jumping j=new Cat();
        j.jump();
        jumping s=new Tiger();
        s.jump();
        Tiger o=(Tiger)s;
        o.go();//向下转 型调用Tiger的方法
    }
}

设计设计一个锁来锁应用

进程与线程

进程的概念

程序执行时的一个实例
每个进程队友独立的内存空间
系统进行资源调度和分配的基本单位
进程当中的堆是进程中最大的一块内存，所有的线程都是共享的，进程创建时分配，堆中存放创建的new的实例
进程中的方法去是共享的，线程都可以访问
在多线程OS当中进程是不可执行的，即每一个进程至少创建一个线程去执行代码

引入进程的原因

每一个进程都有自己的空间，有自己的进程空间。一个服务器要接收大量的请求，这么多请求就创建大量的进程空间太过于低效（系统开销大、请求响应效率低），因此引入线程。

线程的概念

一个系统在运行中有多个进程执行，一个进程执行时有多个线程线程，与进程不同的是同类线程共享进程的堆和方法资源，但是每个线程都有自己的程序计算器，虚拟机栈，系统在产生一个线程，或是在各个线程切换工作时，负担要比进程小的多，所以线程又叫做轻量级进程。

线程的特点

进程中的一个实体
进程的一个执行路径
CPU 调度和分派的基本单位
线程本身是不会独立存在
当前线程 CPU 时间片用完后，会让出 CPU 等下次轮到自己时候在执行
系统不会为线程分配内存，线程组之间只能共享所属进程的资源
线程只拥有在运行中必不可少的资源(如程序计数器、栈)
线程里的程序计数器就是为了记录该线程让出 CPU 时候的执行地址，待再次分配到时间片时候就可以从自己私有的计数器指定地址继续执行
每个线程有自己的栈资源，用于存储该线程的局部变量和调用栈帧，其它线程无权访问

进程与线程的区别

1.一个进程由多个线程组成，一个进程中至少有一个线程

2.一个类中值少有一个main函数，启动一个main时就启动了一个JVM进程，而main函数所在的线程就是这个进程中的一个也称为主线程。

weikejoe

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
2021-03-23

java命名规范类名：首字母大写，如果出现第二个单词首字母大写； //ClassStudent变量名/方法名：首字母小写如果出现第二个单词首字母大写； //newNum常量：全大写字母； //Math.PI final int NUM = 55不能以数字开头关键词标识符（标识符是什么？就是给变量，方法，类等命名的符号。标识符的命名要参照以下几条规则。）标识符可以由字母、数字、下划线组成。但是标识符不能以数字开头：123num这就是非法标识符；标识符不可由关键字命名；
复制链接

扫一扫