java基础自学笔记

Tomtutu

已于 2023-10-12 17:11:53 修改

阅读量254

点赞数

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

于 2022-03-01 23:01:21 首次发布

本文链接：https://blog.csdn.net/Tomtutu/article/details/123218676

版权

基础专栏收录该内容

8 篇文章 0 订阅

订阅专栏

命令行下： javadoc -encoding UFT-8 -charset UTF-8 +你要执行的.java文件

switch

public static void main(String[] args) {
    //case穿透 //switch匹配一个值
    char garde='B';
    switch(garde){
        case 'A':
            System.out.println("优秀");
            break;//可选
        case 'B':
            System.out.println("良好");
        case 'C'  :
            System.out.println("及格");
        default:
            System.out.println("未知等级");
    }
}

java反编译将生成的class文件在idea中打开

方法：

1.java支持两种调用方法的方式，一种是返回值

like：int add（int a ,int b）方法调用通常当做值来调用

另一种是没有返回值

like： System.out.println("helloword")

java 是值传递

面向对象：

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

三大特性：

封装：

继承：

多态：

从认识论的角度考虑是现有对象后有类。对象是类的实例，是具体的实物，类是抽象的，是对象的抽象

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

方法的内存分析：

类包含静态的属性：属性

动态的行为：方法

封装的意义：

1.提高程序的安全性

2.隐藏代码的实现细节

3.统一接口

4.增加系统的可维护性

继承：

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

2.继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。

3.子类和父类之间，从意义上来讲应该具有“is a”的关系

子类继承父类将拥有父类的除了私有的方法和属性，其他的所有方法和属性

父子类可以进行类型转换

子类转换为父类可能丢失本来的一些方法（向上转型）

父类转换成子类，向下转型（强转）

静态代码块和类同时产生只执行一次

匿名代码块在构造方法前执行

构造方法执行、

抽象类:

abstract关键字修饰

interface：是特殊的抽象类

接口中的属性是常量

哈希函数：

哈希函数的输入可以使任何大小的数据块

哈希函数是单向的，得到的哈希值是不可能计算出原始值的。

同时哈希函数必须运算高效

作为密码的哈希函数还需要一些特性，比如说不能有哈希碰撞。

哈希碰撞的意思是输入1和2，他们两个的哈希值相同。

哈希函数的输出集是固定的。

2的32次方是40亿

1.重写与重载

package com.hu.test7;

class Test{
    void print(int a){
        System.out.println(a+"");
    }
    void print(String name){
        System.out.println(name);
    }
}
public class extendsTest extends Test{
//    重写
    @Override
    void print(int b){
        System.out.println(b+"");
    }
//    重载机制依然起效
    void print(Boolean b){
        System.out.println(b+"");
    }
    public static void main(String[] args) {
        extendsTest extendsTest = new extendsTest();
        extendsTest.print("11");
        extendsTest.print(12);
        extendsTest.print(true);
        Test t = new Test();
        t.print(33);
    }
}

Java_子类定义一个方法，与父类的方法名、参数列表相同，但返回值类型不同，程序是否异常？

答：会出现异常，因为重写与返回值类型无关，即无法判断返回值的类型

2.私有属性和方法

这意味着任何扩展接口的类都不能使用该类的实例直接访问此方法

package com.hu.test7;

class Door{
    //只有改为public的时候才能在下面调用
    public  Winds winds =  new Winds();
    public void open(){

    }
    //私有属性，接口只能在当前代码段使用，这意味着任何扩展接口的类都不能使用该类的实例直接访问此方法
    private void close(){

    }
}
class Winds{
    public  void up(){

    }
    public void down(){

    }
}
public class Car {
    private Winds winds;
    private Door left = new Door() , right = new Door();

    public static void main(String[] args) {
        Car car = new Car();
        car.left.winds.down();
        Door door = new Door();
        door.winds.down();
    }
}

3.继承与组合

继承是父子关系，组合是包含关系(is-a;has-a)

4.final修饰的数据，方法，类

public class finally1 {
    //    finally修饰的三个地方 : 数据 方法 类
    //    1.一块数据是恒定不变的
    //    一个永不改变的编译时常量(必须是基本数据类型 ，并且用关键字finally修饰,对常量进行定义的时候必须进行赋值)
    //    修饰基本数据类型的时候是常量
    //    修饰引用数据类型的时候，引用无法更改，应用的对象里面的值可以更改
    enum1 e = enum1.ALL;
    public void geta(){
        switch (e){
            case ALL:
                System.out.println("ss");
            case ROLE_WISDOM_AUTH:
                System.out.println("11");
        }
        if("finallyInt.equals;".equals(finallyInt)){

        }
    }

    public final static String finallyInt="3";
}
//被final修饰的方法无法被覆盖
class final2_1{
    public final void getName(){

    }     
}
public class finally2 extends final2_1 {

    public final void getName(){

    }
    private String name;
    
}

5.多态、

多态需要满足的条件：

1:继承

2：覆盖（重写）

父类引用指向子类对象

多态只能是普通方法：

域，和静态方法是不能使用多态的，因为多态是运行时绑定，域和静态方法是编译时绑定。

super，关键字可以调用父类的域和属性，子类中带了父类的域和属性

6.super与this（子类在初始化的时候）

	1.覆盖不会删除父类中的方法，而是对子类的实例隐藏，暂时不使用，而super可以
	  调用这些隐藏的方法
	
	2.  
	 Java核心卷；有些人认为 super 与 this 引用是类似的概念， 实际上，这样比
	 较并不太恰当。这是因为 super 不是一个对象的引用， 不能将 super 赋给另一
	 个对象变量， 它只是一个指示编译器调用超类方法的特殊关键字。
	
	3.我为什么会觉得父类中的this应该是父类本身对象的this(这是错误的想法)，子
	  类实例化的过程会先去执行父类的构造函数，这个大家肯定都是知道，但我过去
	  错误的以为，执行了父类的构造函数意味着新建了父类的对象.......，所以我才
	  会觉得父类中的this指的应该是父类的对象引用，但其实调用父类构造器并不是
	  创建父类的对象，而是子类在创建对象的过程中，“借用” 父类构造器创建子类的
	  对象。由于子类继承了父类，内存中不但会划分子类的变量空间，也会将子类的所
	  有父类的成员变量也划分内存空间，所以可以使用super去访问他们。
	
	4.在国内查阅相关super关键字介绍，大多也都是说子对象里有父对象。但是这种说
	  法是错误的，有两个例子可以证明其错误：
				1. super不能赋给另一个对象变量
				2. 抽象类不能创建对象，但是如果一个类的父类是抽象类，仍然可以
				   通过super调用其父类的方法
				3.super.test()只是在说调用父类中的test方法，并不是说用父类对象
				  来调用父类的test方法。
				  
                 你此时是使用子对象来调用父类的test方法的，所以父类的test方法
                 里面的this指的是调用该方法的子对象。
               
	
	+++ 子类继承父类:
				1.如果父类只有有参的构造方法，
				  那么子类的构造方法必须调用父类的构造方法。
				
				2.创建子类对象时，
				  首先会调用父类的构造方法，然后在调用子类的构造方法。
				  	
				  调用父类的构造方法，并不是创建父类对象，而是借用父类的构造方
				  法，创建子类对象。
			    
			    3. 
			      由于子类继承了父类，内存中不但会划分子类的内存空间，也会给子类
                  继承的所有父类的成员变量也会划分内存空间。
                  
                  所以父类中的this关键字指的不是父类对象，而是指的的子类对象、
                  而在父类或子类中我们通过super关键字，来调用父类中成员。
                 
                4.覆盖不会删除父类中的方法，而是对子类的实例隐藏，暂时不使用，
                  而super可以调用这些隐藏的方法。
                  
	+++ this和super关键字
				1.this关键字代表的子类对象，父类中this关键字和子类中this关键字，指的都是子类对象。
				2.子类继承父类，会先调用父类的构造方法，然后调用子类的构造方法。
				  它并不是创建父类对象，而是调用了父类构造方法创建了子类对象。
					
				  所以super关键字不是对父类对象的引用，而是在子类或父类中，可以调用父类中的成员。