java99:java 基础备忘

2024-09-03 22:32
文章标签 java 基础 99 备忘

本文主要是介绍java99:java 基础备忘,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

程序 = 算法+数据结构

    算法:解决问题的步骤

     数据结构:将数据按照某种结构来保存

    好的数据结构 => 好的算法


char 可以存储一个中文字符(1个char是两个字节,一个中文字符也是两个字节)


&& 短路 常用


三目运算

int a = 1;

int b = 2;

int c = a > b ? c =0101 : c = 1010

boolean ? 1:2




-- ++ 单独使用在前在后没有差别

    使用时在前在后有差别

        ++ 在前 先自增在使用

        ++ 在后 线使用在自增


关系运算  < > <= >= ==  != 返回结果是boolean


逻辑 建立在关系运算的基础之上 结果也是boolean 有短路 和不短路,&则是会把两边的表达式都执行完

    && 与 

     || 或

        !非


 + 号 两边都是数字做加法运算

    一边是字符串做连接


switch case 常常和 break 一起用 

    清晰,效率高

    java7.0以上 switch case 可以使用 字符串




变量的作用域 从声明开始到包含它最近的大括号



三要素:

    1/循环变量的初始化

    2/循环的条件(以循环变量为基础)

    3/循环变量的改变(向着循环的结束变)


for(int i = 1; i<10;i++){System.out.println("good");
}
int i = 1;
while(i < 10){System.out.println("good");i++;
}
int i =1;
do{System.out.println(i+"good");i++;
}while(i<10);


第一要素和第三要素一样的时候用do while 


循环中使用break 或者 continue


循环能用一层就不用两层

能用两层就不用三层

需要4层-设计是不是有问题

循环的层数越少越好


嵌套循环执行:

    外层一次,内层所有


Math.random()  生成一个0-1之间的数 包含0不包含1

    把它*8或者 *100 就是 0-8之间的数 0-100之间的数

    再次使用强转 : 除去小数位 (int)(Math.random()*10)



数组就是最基本的数据结构

    相同数据类型的元素

    数组按线性顺寻一个跟一个

    数组也是一种数据类型

    

    声明   

    int[] arr;

     

    初始化

    arr = new int[4];

    

    声明+初始化:

    int[] a = new int[4];

     声明了一个整形数组a,可以存储4个整数,默认值是 0

    

    int[] arr = {1,2,3,4,5,6};

    int[] arr = new int[]{1,2,3,4};


    访问数组

        int[] arr = {1,2,3,4,5,6};

        arr[1]

    数组的遍历

        for(int i = 0;i<arr.length;i++){

            System.out.println(arr[i]);

        }

     数组的复制

    System.arraycopy(源数组,开始复制的下标位置,目标数组,目标数组的下标位置,复制的个数)

    复制 扩容(copy的灵活性差一点)

     int[] arr = {1,2,3,4,5,6,7,8,9};

    int[] arr_1 = Arrays.copyOf(arr,6);

    

    int[] arr = {1,2,3,4,5,6,7,8,9};

    a = Arrays.copyOf(a,a.length+1);


    数组的排序

    Arrays.sort()

         

    冒泡排序,两个for 循环 控制 一个 if 比大小

//冒泡算法(从小到大)System.out.println();int[] arr_6 = new int[100];for(i = 0;i<arr_6.length;i++){arr_6[i] = (int)(Math.random()*1000);}for(i = 0;i < arr_6.length-1;i++){//轮数 循环, 总轮数为 数组个数-1(从0 开始)for(int j = 0; j< arr_6.length-1-i;j++){//每一轮比多少次,循环,为总轮数 - 第几轮(从0 开始)if(arr_6[j] > arr_6[j+1]){//判断 从小到大 还是从大到小int t = arr_6[j];arr_6[j] = arr_6[j+1];arr_6[j+1] = t;}}}for(i = 0; i< arr_6.length;i++){System.out.print(arr_6[i]+" ");}//冒泡算法(从大到小)Random randOne = new Random();System.out.println();int[] arr_7 = new int[100];for(i = 0;i<arr_7.length;i++){//arr_7[i] = (int)(Math.random()*1000);arr_7[i] = randOne.nextInt(1000);}for(i = 0;i < arr_7.length-1;i++){for(int j = 0; j< arr_7.length-1-i;j++){if(arr_7[j] < arr_7[j+1]){int t = arr_7[j];arr_7[j] = arr_7[j+1];arr_7[j+1] = t;}}}for(i = 0; i< arr_7.length;i++){System.out.print(arr_7[i]+" ");}}



方法 函数 过程

    方法是用于封装一段特定的逻辑功能

    方法尽可能的独立也就是只干一件事情.

        修饰词,返回值类型,方法名,参数列表,方法体

        

        public static void set(String name,int age){

        

        }

        public static int get(){

            

        }

public class MathDemo {public static void main(String[] args){say();say("lmdtx");say("hi","xx");int n = add(1,2);System.out.println(n);System.out.println(plus(1,2));int x = 2;int y = 3;int sum = plus(x,y);System.out.println(sum);}  public static void say(){System.out.println("Hello World!");}public static void say(String name){System.out.println("Hello " +name+"!" );}public static void say(String whatAreYouSay ,String name){System.out.println(whatAreYouSay+" "+name+"!");}public static int add(int a,int b){int c = a+b;return c;}public static int plus(int a, int b){return  a+b;}}


1设计数据结构-变量

2设计程序结构-方法

3设计实现-方法的实现



面向对象:以对象为核心,对着对象操作

 先找对象,再找类

    在代码中是 先创建类,在创建对象 

        创建对象:

            类名 引用名 = new 类名()

        创建类:

            class 类名{}

    一个类可以创建多个对象,结构相同,数据不同.

    类就是一中数据类型

    不创建对象,类就没有意义了

    包含 

        对象所共有的特征

        对象所共有的行为

      

       成员变量

        方法

    

    对象创建后,其成员变量可以按照默认的方式来初始化

    初始化对象成员成员变量时,其默认值的规则:

        数值类型: 0

        boolean:false

        char: /u0000

        引用类型:null

    如何 设计:

        1:找对象

         2:抽类

          3:设计类

           3.1:成员变量

           3.2:方法


    类定义后,使用new 创建对象,创建对象的过程通常称为实例化

    

    在内存中:

        栈:局部变量在栈中 

            基本类型 是值

            引用类型是 堆中的地址

        堆:对象都在堆中


    引用类型变量之间的复制不会创建新的对象,但是可能会使两个以上的引用指向同一个对象 

     引用类型 可赋值 null,表示还没有指向对象 这个时候访问对象的成员变量或者调用方法的时候会有空指针异常(NullPointerExcrption)  



    方法的签名

        方法名;参数列表

        一个类中,不可以有两个方法的签名完全相同

    方法的重载

        方法的名称相同,但参数列表不同.(方法的签名不同)

    java 建议:

        1个文件1个类

    java 规定:

        1个文件可以有多个类

        但是只能有一个public 类

    编译时根据签名绑定调用方法


    构造方法

        构造方法还是方法,是方法就可以重载,也可以互相调用

        对成员变量初始化

        与类同名,没有返回值类型(不写void)

        构造方法是在创建对象时被自动调用的

        不写,编译器默认给一个无参构造

        写了,就不提供无参构造


            调用构造器

             |

    Cell cell = new Cell();


    this: 

      this 指代当前对象, 谁调指的就是谁

        用法:

            this.成员变量

            this.方法()

            this() 调构造方法


    引用类型数组:

        Student[] s = new Student[4];

        s[0] = new Student();

        s[1] = new Student();

        s[2] = new Student();

        s[3] = new Student();


        Student[] s = {new Student(),new Student(),new Student(),new Student()};

        

 声明int[] 类型的数组,名为arrs,包含4个元素,每一个元素默认值为null

        int[][] arrs = new int[4][];

        

        int[][] arrs = new int[3][4]

        3行,4列

    数组是引用类型,对象存在堆中

    引用类型数组 new 之后 每一个元素的初始值是null



JVM 内存管理:

    堆 存贮 new 出来的对象(包括成员变量)  

        成员变量的生命周期:创建对象时存在,对象回收时消失

            访问对象需要依靠引用变量

            当一个对象没有任何引用时,九江市废弃的对象,属于被回收的范围,这个对象中的所有成员变量也被回收

            成员变量的生命周期为:从对象在堆中创建开始到对象从堆中被回收结束

    垃圾回收机制

        垃圾回收器(GC) 是jvm 自带的一个线程,用于回收没有任何引用指向的对象

    内存泄漏:不再使用的对象,未被及时回收。

        一些对象不用了,但是还没有被及时的回收

        严重的内存泄漏会因过多的内存占用而导致程序的崩溃

        因此 当确定对象不再使用时,应该及时将其引用设置为null

         垃圾回收器:垃圾回收器不定时回收没有引用指向的对象

        System.gc()方法.

            GC的回收是透明的 , 并不一定是一发现垃圾 就立刻回收,

            一般 当我们需要GC 立刻回收无用  对象,可以调用System.gc()方法

            System.gc()用于建议jvm 马上调度gc 回收 但是具体的实现还是取决不同的Jvm

    

     栈(堆栈) 用于存贮 所有 局部变量

        在java中,调一个方法,栈中给该方法分配一个“栈桢”(空间)

        栈桢 中存 局部变量

        方法调用结束,栈桢消失,局部变量也消失


    方法区 用于存放类的信息(.class 和 方法)

        java 程序运行时 首先通过类装载器载入类文件的字节码信息,经过解析后 装入方法区 类的各种信息(包括方法都在方法区存贮)

        方法只有一份,通过this区分对象

        


继承

    父类 共有的 成员变量和方法 

    子类 特有的 成员变量和方法

    

    关键字:extends    

    

    泛化 先写 子类 再写父类 

    特化 先写 父类 再写子类

    

    一个类只能继承一个父类

    但是一个父类可有多个子类

    继承有传递性


    构造子类之前必须先构造父类:

    子类的构造器中第一行有一句super()  不写默认添加 用于调用父类的无参构造方法,如果父类没有无参构造器 就需要自己写super(参数),  必须在子类构造器的第一句。

    

    父类类型引用指向子类的对象 向上造型,但是通过父类的引用,只能访问父类所定义的成员,不能访问子类扩展的部分,类型决定 方法和成员变量 不看对象

    让子类公用一中类型  -  父类型

     

方法重写

    两个类 子类父类

    子类和父类方法签名相同

    子类重写了父类的方法 

    当方法被重写时,调用那个方法 看对象 

    在子类中 使用super.xx() 调用父类的xx方法

    子类的权限必须大于等于父类


    overload 重载 编译

        在一个类里面 方法名相同,参数列表不同

        重载的时候看类型 决定 方法和成员变量

    override 重写 运行

        重写看对象 决定方法和成员变量

        在两个类中,子类父类 方法签名相同 子类重写了父类的方法 可以用super 访问父类的方法



package 关键字

用包 解决命名冲突 一般是域名到写 所有字母小写


域名反写.项目名.模块名.类名


在开发大型的工程的时候,需要“数据字典”——常用的字符串、常量等等全部都定义在数据字典中。


import 

    import 全局限定名

        包名+类名


    import java.util.*; 不建议...影响性能

    访问不同包的时候需要import

    不用也是可以得,就是要用全局限定名


封装

    对外提供可调用的稳定的功能;

    封装容易变化的


    public 修饰的成员变量和方法可以在任何地方调用 

    private 修饰的成员变量和方法 只能在本类中调用。


    protected 子类和同包中的类 通常用于保护数据只被子类使用

    默认 同包类

    类中的成员变量一般用private 

    方法用public


    类 的修饰 pubilc 和默认 

    protected 和private 内部类

    

    局部变量不需要访问修饰符


   

    static  关键字


        修饰成员变量 不属于对象的数据结构

            static 变量是类的变量,使用 类名来引用(一般,用对象.也对但是不用) 放在方法区 方法区里面的东西只有一份        

            某个数据被所有对象公用的时候就用static                                                                     

        成员变量

            实例变量 对象 堆中 一个对象一份  不用static 修饰的

            静态变量 类 方法区中 所有对象公有一个 static 修饰的                              

        修饰方法:

            类的方法中,需要对 对象的实例变量进行操作

            类的普通方法中,有this

、            类的静态方法没有this 只能访问static变量    


        static 块    属于类的代码块

            在类加载期间执行的代码块,在创建对象之前

            只执行一次,可以用来在软件中加载静态资源(图片 音频 视频)

             类只加载一次  到方法区

    

    final 关键字

        修饰的就是不可改变的

        

    修饰变量:    不可改变

        有两种方法初始化

            声明同时初始化

            构造器重初始化

        findl 关键字也可以修饰局部变量,使用之前初始化即可

    

    修饰方法:

            方法不能被重写

            防止子类在定义新方法时造成 意外修改 父类的方法



    修饰 类

            不能被继承

            但是可以继承别人

            可以保护类不被继承修改,可以控制滥用继承对系统造成的危害




    static final 

        

        常量,必须声明同时初始化,不可改变

        常量 名 全大写

        类名.NUM 访问

        public static final in NUM = 10;

        编译时,直接替换为值

            效率高



抽象

    abstract

        抽象类

        抽象方法


    抽象方法没有方法体(方法不完整)

    abstact void print();

    包括这个方法的类 也就不完整了

    abstact Print{}

    都不完整了,就不能创建对象了(实例化)

    一般需要被继承

    

    包含抽象方法的类,必须是抽象类


    子类继承 抽象类 的时候 要重写 抽象类中的抽象方法


    abstract 和final 不能同时修饰一个类

    

    一个类没有抽象方法,也可以定义为抽象类

    同样也不可以实例化


    抽象类的意义:


       为子类提供一个公共的类型

       封装子类的重复内容

       定义抽象方法,子类不同的实现



接口:    

    标准 规范

    interface 接口名{}

    

    接口中只能包含常量和抽象方法


    接口不能实例化-他里面的方法全是抽象的

    只能被实现(也就是子类来继承)

    implements

    子类实现接口,需要将所有抽象方法都实现

    一个类可以实现多个接口 用 逗号分隔

    

    一个类有想继承一个类 有想实现一个接口

    就要先继承类 在实现类

  

    接口类型的变量可以引用实现了该接口的类的对象, 通过该变量可以调用该接口中定义的方法

        也就是 向上造型

    interface Inter{

        public static final int NUM = 5;

        int NUM2 = 5;//默认添加public static final

        public abstract void show();

        void show2();//默认有public abstract

    }


    class Aoo implements Inter{//Aoo 这个类实现了Inter 这个接口,就是Aoo 这个类遵守Inter这个接口的规范

        public void show(){

        

        }

        public void show2(){


        }

    

    }

    class Boo{

    

    }

    class Coo extends Boo implements Inter{

        //先继承,在实现

    }




多态

    同一类型的引用 指向不同的对象有不通的实现

    

    同一个对象那个,造型不同的类型时,会有不同的功能

    

向上造型

    一个类的对象可以向上造型的类型:

        父类的类型

        他实现的接口类型


强制转型

    强转: 看对象的类型   ===》 new 类名()

        父到子:前提 对象是子

        变量 指向的对象 是该子类的类型

        转为接口:前提 对象 实现了该接口

        变量 指向的对象 实现了这个接口

    强壮失败 会有异常 ClassCastException

    通过instanceof 解决

    语法: 引用 instanceof 数据类型 返回boolean类型

    

    

   


内部类

    一个类定义另外一个类的里面,定义在类内部的类 Inner  请所在的类为 Outer


    一个类只被一个类使用个,对外部可见,就可以做成内部类

    

    内部类对象通常只在外部类中被创建


    内部类中可以直接访问外部类的所有成员



匿名内部类

    如果在一段程序中需要创建一个类的对象 (通常这个类需要实现某个接口或者继承某个类)而且对象创建后 这个类的价值也就不存在了,这个类可以不给名字,就是匿名内部类


    SuperType  obj = new SuperType(){

    

    };


面向对象:

    3大特征

            封装:保证安全

                类    数据 和行为的封装 作为一个整体操作

                方法        功能的实现的封装 隐藏实现的细节

                访问修饰符        控制访问权限 保证数据的安全

            继承:实现代码的重用

                extends

            多态:提高可维护性,可扩展

                多种形态,在继承的基础之上

                一个类型指向不同对象,有不同的实现

                同一个对象操行成不同类型时,有不同的功能

这篇关于java99:java 基础备忘的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/1134226

相关文章

JVM 的类初始化机制

前言 当你在 Java 程序中new对象时,有没有考虑过 JVM 是如何把静态的字节码(byte code)转化为运行时对象的呢,这个问题看似简单,但清楚的同学相信也不会太多,这篇文章首先介绍 JVM 类初始化的机制,然后给出几个易出错的实例来分析,帮助大家更好理解这个知识点。 JVM 将字节码转化为运行时对象分为三个阶段,分别是:loading 、Linking、initialization

Spring Security 基于表达式的权限控制

前言 spring security 3.0已经可以使用spring el表达式来控制授权,允许在表达式中使用复杂的布尔逻辑来控制访问的权限。 常见的表达式 Spring Security可用表达式对象的基类是SecurityExpressionRoot。 表达式描述hasRole([role])用户拥有制定的角色时返回true (Spring security默认会带有ROLE_前缀),去

浅析Spring Security认证过程

类图 为了方便理解Spring Security认证流程,特意画了如下的类图,包含相关的核心认证类 概述 核心验证器 AuthenticationManager 该对象提供了认证方法的入口,接收一个Authentiaton对象作为参数; public interface AuthenticationManager {Authentication authenticate(Authenti

Spring Security--Architecture Overview

1 核心组件 这一节主要介绍一些在Spring Security中常见且核心的Java类,它们之间的依赖,构建起了整个框架。想要理解整个架构,最起码得对这些类眼熟。 1.1 SecurityContextHolder SecurityContextHolder用于存储安全上下文(security context)的信息。当前操作的用户是谁,该用户是否已经被认证,他拥有哪些角色权限…这些都被保

Spring Security基于数据库验证流程详解

Spring Security 校验流程图 相关解释说明(认真看哦) AbstractAuthenticationProcessingFilter 抽象类 /*** 调用 #requiresAuthentication(HttpServletRequest, HttpServletResponse) 决定是否需要进行验证操作。* 如果需要验证,则会调用 #attemptAuthentica

Spring Security 从入门到进阶系列教程

Spring Security 入门系列 《保护 Web 应用的安全》 《Spring-Security-入门(一):登录与退出》 《Spring-Security-入门(二):基于数据库验证》 《Spring-Security-入门(三):密码加密》 《Spring-Security-入门(四):自定义-Filter》 《Spring-Security-入门(五):在 Sprin

Java架构师知识体认识

源码分析 常用设计模式 Proxy代理模式Factory工厂模式Singleton单例模式Delegate委派模式Strategy策略模式Prototype原型模式Template模板模式 Spring5 beans 接口实例化代理Bean操作 Context Ioc容器设计原理及高级特性Aop设计原理Factorybean与Beanfactory Transaction 声明式事物

Java进阶13讲__第12讲_1/2

多线程、线程池 1.  线程概念 1.1  什么是线程 1.2  线程的好处 2.   创建线程的三种方式 注意事项 2.1  继承Thread类 2.1.1 认识  2.1.2  编码实现  package cn.hdc.oop10.Thread;import org.slf4j.Logger;import org.slf4j.LoggerFactory

JAVA智听未来一站式有声阅读平台听书系统小程序源码

智听未来,一站式有声阅读平台听书系统 🌟&nbsp;开篇:遇见未来,从“智听”开始 在这个快节奏的时代,你是否渴望在忙碌的间隙,找到一片属于自己的宁静角落?是否梦想着能随时随地,沉浸在知识的海洋,或是故事的奇幻世界里?今天,就让我带你一起探索“智听未来”——这一站式有声阅读平台听书系统,它正悄悄改变着我们的阅读方式,让未来触手可及! 📚&nbsp;第一站:海量资源,应有尽有 走进“智听

零基础学习Redis(10) -- zset类型命令使用

zset是有序集合,内部除了存储元素外,还会存储一个score,存储在zset中的元素会按照score的大小升序排列,不同元素的score可以重复,score相同的元素会按照元素的字典序排列。 1. zset常用命令 1.1 zadd  zadd key [NX | XX] [GT | LT]   [CH] [INCR] score member [score member ...]