2021-10-10

最新推荐文章于 2024-07-20 23:55:03 发布

qq_46497675

最新推荐文章于 2024-07-20 23:55:03 发布

阅读量61

点赞数

文章标签： java

本文链接：https://blog.csdn.net/qq_46497675/article/details/120690441

版权

2021/10/10
狂神日记
坚持才能成功，只有像sb一样坚持，才能nb。
冰冻三尺非一日之寒，写博客也是，短期内可能看不到效果，但长期坚持，对自己的提升很有帮助。
提升文笔组织能力
提升学习总结能力
提升逻辑思维能力
帮助他人，结交朋友

常用的dos命令
cd change directory 改变目录
cd… 返回上一级
ping 一些网站
dir 当前全部内部目录
md创建文件夹
查看电脑ip ipconfig
创建文件：cd>
del文件名删除文件
盘符切换盘符名：

c++ 图形领域游戏领域强项

Java2se 占领桌面（标准版桌面程序）
Java2me 占领手机（嵌入式开发）
Java2ee 占领服务器（企业级开发 web端，服务器开发）
Hadooop （大数据领域）
Android（手机端）

Java的特性和优势
简单性
面向对象
可移植性
高性能
分布式
动态性
多线程
安全性
健壮性
write once run anywhere

Java
jdk： Java development kit
jre : Java runtime environment
jvm :Java virtual machine

编译型一次
解释型实时

类变量必须要 static 加了static就不用new了
局部变量必须要声明和初始化值
实例变量从属于对象
修饰符不存在前后顺序
常量值 final 名用大写中间用下划线
int a = 3;
int b = a++;执行完这行代码后，先给b赋值，再自增
//a = a+1;
System.out.println(a) // a=4
//a++ a= a+1;
int c = ++a;//执行完这行代码前，先自增，再给b赋值

凡是属于io流的类如果不关闭会一直占用资源，养成用完就关掉的习惯
next是以空白为结束符
nextline是以enter未结束符

case穿透 Switch可以支持String

do{代码语句
}
while（布尔表达式）

while先判断在执行
do while 先执行再判断
for循环
for(初始化；布尔值；更新)
//死循环
for（；；；）{

}

增强for循环：主要是遍历数组
for each
break强制退出循环
continue 用于终止某次循环过程

public class TestDemo {
    public static void main(String[] args) {
     //打印三角形 五行
        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();
        }
    }
}

方法：
System.out.println
System:类名 out：对象名 println：方法名
设计方法的原则保持方法的原子性，即一个方法只完成一个功能

return 可以终止方法

调用方法：对象名.方法名（实参列表）
Java支持两种调用方法的方式，根据方法是否返回值来选择
当方法返回一个值的时候，方法调用通常被当做一个值，列如：int larger = max(30,40);
如果方法返回值是void，方法调用一定是一条语句。

System.out.println("hello,world ");

可变参数即不定项参数：在方法声明中，在制定参数类型后加一个省略号（…）
一个方法中只能制定一个可变参数，他必须是方法的最后一个参数。任何普通的参数必须在他之前声明

递归：
阶乘

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

        System.out.println(f(5));
    }
    public static int f(int n){
        if(n==1){
            return 1;
        }else return n*f(n-1);
    }
}

边界条件、；边界否f（1）
前阶段
返回阶段n*( n-1）

能不用递归就不用递归，递归占用资源太多

静态初始化数组：创建＋赋值
动态初始化：new
数组是引用类型，他的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化
堆就是new之后栈就是array的名字
数组是引用类型
数组不允许出现混合类型
数组对象是保存在堆中的

Arrays类中的方法都是static修饰的静态类，在使用的时候可以直接使用类名进行调用，而不用使用对象来调用（是不用而不是不能用
）

冒泡的代码：两层循环，外层冒泡轮数，里层依次比较
嵌套循环，算法的时间复杂度为o（n2）

package method;

import java.util.Arrays;


public class Demo2 {
    public static void main(String[] args) {
    int[] b = {1,2,35,67,2,3,52,745};
    int[] sort =sort(b);
        System.out.println(Arrays.toString(sort));

    }
    public static  int[] sort(int[] array){
        int temp=0;
        for (int i = 0; i < array.length-1; i++) {
            for (int j =  0; j< array.length-1-i;j++){
                if(array[j+1]>array[j]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;

                }
            }

        }return array;


    }
}

改进版弄一个标志位flag=false；

package method;

import java.util.Arrays;


public class Demo2 {
    public static void main(String[] args) {
    int[] b = {1,2,35,67,2,3,52,745};
    int[] sort =sort(b);
        System.out.println(Arrays.toString(sort));

    }
    public static  int[] sort(int[] array){
        int temp=0;
        boolean flag = false;
        for (int i = 0; i < array.length-1; i++) {
            for (int j =  0; j< array.length-1-i;j++){
                if(array[j+1]>array[j]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    flag = true;

                }
            }if(flag ==false)
                break;


        }return array;


    }
}

对数组的理解加深：稀疏数组的还原与创建

package arrays;

public class ArraysDemo {
    public static void main(String[] args) {
        //0代表没有棋子，1代表白棋，2代表黑棋
        //创建一个数组存放原来的表

        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");

            }
            System.out.println();

        }
        System.out.println("==================");


        //创建一个数组 就是我们的简化版的数组
        //这个数组第一行记录总的行数列数还有有效数字的个数
        //剩下的记录有效数字的位置
        int sum = 0;

        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j] != 0) {
                    sum++;


                }

            }


        }
        System.out.println("有效值的个数"+sum);


        //创建一个稀疏数组
        int[][] array2 = new int[sum + 1][3];
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;

//遍历二维数组，吧非0的数字填入array2
        int count = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if(array1[i][j]!=0){
                    count++;
                    array2[count][0]=i;
                    array2[count][1]=j;
                    array2[count][2]=array1[i][j];


                }

            }

        }
        System.out.println("输出稀疏数组");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0]+"\t"+
                    array2[i][1]+"\t"+
                    array2[i][2]+"\t");

        }
        System.out.println("==========================");
        System.out.println("还原");
        //1.读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];

        //2.给其中的值还原出来
        for (int i = 1; i < array2.length ; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
            //3.打印


        }System.out.println("打印还原数组");
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");

            }
            System.out.println();
        }



    }
}

面向对象：
对于描述复杂的事物，为了宏观上把握、从整体上合理分析，我们需需要使用面向对象的的思路来分析，细致的地方认识面向过程。
面向对象的本质是：以类的方式组织代码，一对象的组织（封装）数据。
抽象
三大特性：
封装
继承
多态

先有对象后又类。对象，是具体的事物。类，是抽象的，是对对象的抽象。
从代码运行的角度考虑是先有类后有对象。类是对象的模板。

方法的定义：
修饰符
返回类型
break和return的区别
方法名
参数列表
异常抛出方法的调用
静态方法
非静态方法
形参和实参
值传递和引用传递
this关键字

静态方法 static 可以直接类名.方法名和类一起加载的
非静态方法无static 先new一个对象（就是实例一个对象）类实例化后才存在

//引用传递：对象：本质还是值传递

类是一种抽象的数据类型，他是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物
对象是抽象概念的具体实例

一个类包括：//属性：字段 //方法
类实例化后会返回一个自己的对象

一个类即使什么都不写也有默认的构造器（默认为无参构造）
类中的构造器也成为构造方法，实在进行创建对象的时候必须要调用的，并且构造器有以下两个特点：
1.必须和类的名字相同
2.必须没有返回类型，也不能写void
作用：使用new关键字必须要有构造器

有参构造：

public class Person{
String name;
//有参构造
public Person(String name){
this.name = name ;//this.name 的name是属性 String里的name
//name是参数String name的 name
}
}

一旦定义了有参构造，无参构造就必须显示定义
//alt + insert 快捷生成构造

内存图
在这里插入图片描述

对应的引用
引用类型：基本类型（8）
对象是通过引用来操作的：栈------>堆
属性：字段Field 或成员变量
默认初始化：
数字： 0 0.0
char：u0000
boolean：false
引用：null

修饰符属性类型属性名 = 属性值

对象的创建和使用
必须使用new 关键字创造对象，构造器 Person kuangshen = new Person()
对象的属性 kuangshen.name
对象的方法 kuangsehn.sleep()

类：静态的属性属性
动态的行为方法

封装：“高内聚，低耦合”高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅仅暴露少量的方法给外部使用
封装（数据的隐藏）通常，应禁止直接访问一个对象中数据的实际表示，而应该通过操作接口来访问，这成为信息隐藏。
记住这句话就够了：属性私有，get/set
封装是针对于属性的

属性私有：快捷键 alt + insert
属性私有封装后可以保护私有属性的更改
封装的意义：
1.提高程序的安全性，保护数据（可以判断不合法数据）
2.隐藏代码的实现细节）
3.统一接口（get/set）
4.系统可维护性增加
继承不是实现方法的唯一方法，组合也可以。继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等
子类和父类的关系是一种 “is a”

有四种等级：public protected default private
ctrl+h 可以看继承
Java中只有单继承，没有多继承 this，super，name字段
this，super，方法
私有的东西无法被继承
父类没有无参构造，有有参构造，子类就不能有无参构造，也无法调用无参构造，只能调用有参构造
子类默认先调用父类的无参构造，隐藏代码：super（）

this，super必须要放在子类构造器第一行
super，this笔记

重写都是方法的重写，和属性无关
在这里插入图片描述
上图父类的引用指向了子类，方法的调用只和左边，定义的数据类型有关。

上图显示静态方法和非静态方法区别很大，重写只和非静态方法有关，重写的方法只能是public
重写：需要有继承关系，子类重写父类的方法；
1.方法名必须相同
2.参数列表列表必须相同
3.修饰符：范围可以扩大打不能缩小：public>protected>default>private
4.抛出的异常：范围可以被缩小，但不能扩大 ClassNoteFoundException—>Exception

重写，子类的方法和父类必须要一直；方法体不同！
为什么需要重写：
1父类的功能，子类不一定需要，或者不一定能够满足！

多态：多态是方法多的多态，属性没有多态。
一个对象的实际类型是确定的
但是可以指向的引用类型就不确定了（这里主要是父类和有联系的类）：父类的引用指向子类在这里插入图片描述
对象能执行哪些方法，主要是看对象左边的类型，和右边关系不大。
助理类重写了父类的方法，执行子类的方法，否则执行父类的方法
高类型转换为低类型强制转换（就是父类型转换为子类型需要强制转换）
子类转换为父类可能会丢失一些方法在这里插入图片描述

多态的的注意事项：
1.对态势方法的多态，属性没有多态
2.父类和子类，有联系，否则类型转换异常
3.存在条件：继承关系，方法需要重写，父类引用指向子类对象！ Father f1 = new Son()
1.static 方法，属于类，他不属于实例
2.final 常量
3.private方法
以上不能重写
多态：即同一方法可以根据发送对象的不同二采用多种不同的行为方式
instanceof 关键字（类型转换）判断是否为继承关系
在这里插入图片描述
x instanceof y x和y是否有关系是编译能否通过的关键
类型转换总结：
1.父类引用指向子类的对象
2.吧子类转换为父类，向上转型
3.吧父类转换为子类，向下转型；强制转换
4.作用：方便方法的调用，减少代码的重复！简洁

封装、继承、多态抽象类

qq_46497675

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
2021-10-10

2021/10/10狂神日记坚持才能成功，只有像sb一样坚持，才能nb。冰冻三尺非一日之寒，写博客也是，短期内可能看不到效果，但长期坚持，对自己的提升很有帮助。提升文笔组织能力提升学习总结能力提升逻辑思维能力帮助他人，结交朋友常用的dos命令cd change directory 改变目录cd… 返回上一级ping 一些网站dir 当前全部内部目录md创建文件夹查看电脑ip ipconfig创建文件：cd>del文件名删除文件盘符切换盘符名：c++ 图形领域
复制链接

扫一扫