java学习方向和基础知识

以下是本人学习Java的一些笔记 比较乱 但是我觉得知识点还算挺到位的
里面大部分是从基础开始的 如果你也是刚刚开始初学Java 推荐使用IDEA编译器 或者从使用源码开始 及下载jdk 从官网下载即可 但是需要配置环境变量 Java这个语言 还是推荐你们学的 毕竟一般公司大部分使用的都是Java代码
Java这个东西要比c语言好学点 毕竟有现成的类和一些方法 都不需要你自己去写 会用即可

/* 方法的一些关系和使用
 *
 *  public static 返回值类型  方法名{
 *  }
 *  public 返回值类型  方法名{
 *  }
 *  public 方法名{
 *  }
 *
 *  带有static的方法  使用是 例如：类名.方法名   如果在同一个类中 “类名” 可以省略//不需要创建对象
 *
 *  不带static 但有返回值的  需要创建对象如  类名 ka=new 类();  ka.方法名()
 *  此方法如果在同类中有多个 如在同类方法中有c1、c2都是不带static且有返回值的 可以直接在c1中 类名.c2 或者c2
 *  不需要在创建对象    如果不在同一个类中使用的话 必须创建对象
 *
 *  不带static 没有返回值的就是构造方法 必须要创建对象 才能使用 无论什么情况都是一样的
 */
public class student {
    int zz;

    public static void main(String[] args){

        student mm=new student();
        mm.s4();
        student ww=new student();


    }
    String s;

    {
        System.out.println("333333333333");//这个东西会在建立对象的时候才能输出运行
    }
    static{   //这个东西放在程序的哪个部分都是第一个执行
        System.out.println("2222222222222");
    }
    public student(){
        System.out.println("do-->s1");
    }
    public void s2(){
        System.out.println("do-->s2");
    }
    public static void s3(){
        System.out.println("do-->s3");
    }
    public void s4(){
        s2();
        System.out.println("do-->s4");
    }
}
/*

 * 重载  就是一个类中可以设置多个方法名相同的方法 括号内的参数要不同才可以 这样在调用的时候就会自动选择到你想用的那个方法
 *
 * this关键字 就是在使用一个方法没结束前 所使用的this都是所指向的该方法的地址
 *        例如 创建一个对象为A 那么在使用A的属性的时候 可以A.stu  或者this.stu
 *            即A和this都是表示新建对象的地址  如果新建了对象B  那么this就是和B一样了
 *
 * 封装
 *  在一个类中创建成员变量的时候在前面加上private  如  private int a;
 *   封装是为了在其他类中访问设置一些权限  可以在原来的类中加一些方法  然后在其他的类中使用
 *   这个方法 达到访问数据的效果
 * 继承  extends   私有方法不能继承·  构造方法不能继承   不能继承就不能覆盖  静态方法不支持覆盖
 *         虽然构造方法不能继承但是 每次调子类的时候都会“自动运行”它父类的构造方法
 * 多态
 *  在多态中进行向上转型或者向下转型的过程中 必须要有直接的继承关系
 *  在向下转型的过程中有强制转换类型 这个容易出现空指针异常
 *  if( a instanceof  studnt)  其中a是一个对象名称  student是类型名
 *  如果 a这个对象是student类型的 结果就是真true  否则为假false
 *  此处有个好的例子 就是 有一只狗 一只猫 都是动物  一个人想要养一只动物
 *  让动物当父类 猫和狗当子类 继承动物 这样就可以让人和动物建立关系
 *  多态例子代码如下：*/
/**class dong{     //动物类
    public void s1(){
        System.out.println("这是动物");}
}
class mao extends dong{ //猫继承动物
    public void s1(){
        System.out.println("猫");  }//此处的方法名要一样 要不然无法覆盖
}
class gou extends dong{  //狗继承动物
    public void s1(){
        System.out.println("狗"); } //此处的方法名要一样 要不然无法覆盖
}
class ren{
    public void a1(dong w){
        w.s1();
    }
}
//这样写 可以降低耦合度 提升独立性 让人这个类再养动物的时候 不直接与这些猫狗等接触
// 而是与动物这个类接触  这样就会每次养其他宠物时 直接让猫狗猪 直接继承动物 就可以了
public class we{
    public static void main(String[] args){
        mao m1=new mao();
        ren lisi=new ren();
        lisi.a1(m1);
        gou g1=new gou();
        lisi.a1(g1);
    }
}
 */
/*
 * final  这个东西修饰的方法 数据 等等一旦赋值都不能在进行赋值或者覆盖  但是方法可以重载
 *
 * import 就是引入源代码的位置 引用后 就可以直接写引用的方法 不需要每次都写文件所在地址了
 *       例如 在输入一个数据前需要 需要先写 java.util.Scanner w=new java,util.Scanner(System.in);即可
 *                  也可以  在代码第一行写上 import java.util.Scanner; 如果代码有package需要把该代码写在他的下面
 *                   在后面再用的时候 只需要写  Scanner w= new Scanner(System.in)
 *访问权限
 *    1、public：public表明该数据成员、成bai员函数du是对所有用户开放的，所有用户都可以直接进行调zhi用
 *    2、private：private表示私有，私dao有的意思就是除了class自己之外，任何人都不可以直接使用。
 *    3、protected：protected对于子女、朋友来说，就是public的，可以*使用，没有任何限制，
 *       而对于其他的外部class，protected就变成private。
 *
 */
 //      https://www.bilibili.com/video/BV1Rx411876f?from=search&seid=5528311515307616189
 //       上面的链接就是java学习地址  也可以在B站直接搜java播放量最高的就是

/*在继承的时候 如果a中有参数的构造方法
 *  b继承a了 如果运行则会报错 有两种方法
 * 第一种就是 在a中加入一个无参数的构造方法
 * 第二就是  在b中 添加一个构造方法且改方法必须为第一个
 *               在该构造方法中加入 super(与a中构造方法参数类型一致)  如果a中是int  那么随便填一个 1、23、34、2、.......
 * 虽然构造方法不能继承但是 每次调子类的时候都会“自动运行”它父类的构造方法
 *
class a{
    public a(){  //第一种改成对的方法

    }
    public a(int i){
        System.out.printf("dui");
    }
}
class b extends a{
    public void b(){
        super(2);  ////第二种改成对的方法
    }

}
public class we{
    public static void main(String[] args) {
        new b();

    }
}
*/
//选择技巧
/**
 * is a、has a、like a
 *      is a ：  cat is a Animal （猫是一个动物）
 *      凡是满足“is a”的表示“继承关系"
 *      例：a extends b
 *      has a:   i has a pen(我有一只笔）
 *      凡是满足”has a“的表示”关联关系“
 *      关联关系通常以属性的形式存在
 *      例：a{
 *          B b;
 *      }
 *      like a：cooker like a foodmenu(厨师像一个菜单）//功能上像
 *      凡是满足”like a“的表示”实现关系“
 *      实现关系通常是：类实现接口
 *      例：a implements b
 *
 *
 *
 *   接口 要比抽象类用的多
 *
 */

Java基础中 比较难理解的就是那个抽象类抽象方法和接口
比较这东西不是实体的东西 如果想了解更多的话 可以取多从网上搜索看看
我这里只是指明一下学习的方向

/** 抽象类  抽象类是无法创建对象的  只能被子类进行继承
 * [修饰符] abstaract class 类名{
 *
 * }
 *因此 abstract 无法跟 final组合 因为这样组合后 该类就无法使用 没有存在的意义  抽象类也可以被抽象类继承
 * 抽象类可以有构造方法
 * 抽象类中不一定有抽象方法  但是抽象方法必须在抽象类中
 * ***** 一个非抽象类继承抽象类 必须把抽象类中的抽象方法重写/覆盖为非抽象方法
 * public 就是表示访问权限
 *

 */
public abstract class student11 { //抽象类
    public abstract  void aa();
}
abstract class   rt{

}
class dos extends student11{
    public void aa() {

    }
}

/**-----------------------------------
 *
 */
//接口的abstract可以不写
abstract interface q{  //接口的abstract可以不写

}
interface w{
  void ff();
}
class r{

}
//这个表名一个类 可以在继承类的时候 也能同时实现接口
class e extends r implements w {
 public void ff(){
     System.out.printf("可以实现");
 }
}
class shixian{
    public static void main(String[] args) {
        e mk=new e();
        mk.ff();

    }
}
/**
 *接口语法 interface 在接口方法中只能存在常量和抽象方法 但是抽象方法中的public abstract这个标志可以省略不写
 *        ***接口可以继承同时继承多个类 中间用英文逗号,隔开，***
 *        其中的常量也可以省略掉 public abstract final
 *    接口跟抽象类一样无法直接创建对象
 *    但是可以向上转型 来创建对象
 *    例如 a时抽象类或者接口  b是继承/实现的a的类
 *    a w=new b();这样就可以创建一个名字为"w"的对象了
 *    在继承/实现时 一些方法的访问权限不能降低 只能提高
 *    a 中有一个public 的对象 那么在继承/实现中权限要等于或者大于public
 *   接口之间如果没有继承/实现关系的时候 也可以进行强制转换  编译不会错  但运行可能会出现错误
 */
interface a{
     public static final int i = 0;
     public abstract  void zz();//**此处灰色的东西都是可以省略不写的
     public void zz1();
     void zz3();
}

interface b{

}
interface c extends a,b{

}
/**
*接口与类之间的“实现”（此处的”实现“相当于“继承”只是把extends改为implements)
*因为接口中都是抽象方法 所以“实现”的类中必须对接口中的方法进行重写/覆盖 才能编译成功
* 一个类可以实现多个接口
 */

abstract class k implements a , b{
    public   void zz(){
        System.out.printf("实现一");
    }
    public void zz1(){
        System.out.printf("实现二");
    }
}

还有就是提醒你们要多看一下sun公司提供的源代码 可以让你的代码写的更有效率 还有就是要自己多看API也就是帮助文档 但是这个文档官方并没有中文的 网上有别人翻译的 但是翻译比较好的就是1.6的版本

package  song.day01;
public class a01
{
 public static void main(String[] args){
	 System.out.print(123);
 }
       
}

//javac -d . a01.java
//就会本目录下生成一个song文件夹 song文件夹内有个day01文件夹 day01内有个a01.class文件
//这就是包机制 如果有编译器则不要考虑此问题 如果自己用命令窗口编译要考虑


public > protected > 默认 > pritive   
public 哪里都能用
protect  子孙 同包 本类 可以使用
默认     同包 本类
pritive   本类

//使用内部类的代码 可读性很差·  能不用就不用
class  qq{
 
    static class  we{    //静态内部类
    }
    class   rt{            //实例内部类
    }
    public void  zx(){
         class   vb{       //局部内部类
         }
    }
}

最后提一点比较常用的方法

toString()   建议一般重写  返回字符串类型 简介明了
equals()     也要重写  比较是否相同
finalize()   在垃圾回收的时候 也就是gc  才会执行（非重点）
java深克隆浅克隆  （感兴趣了解）
hashCode 就是把内存地址用哈希算法 转换为一串数  

String
	charAt
	compareTo
	contains
	endsWith
	getBytes
	equalslgnoreCase
	isEmpty
	length
	lastIndexOf
	replace
	split
	startsWith
	substring
	toCharArray
	toLowerCase  
	toUpperCase 
	trim           //去除字符串头部和尾部的空格
	valueOf     //把基本数据类型的数据以及数组转换为字符串
StringBuffer
	append追加的意思
StringBuilder
	append
StringBuffer和StringBuilder的区别
	StringBuilder中的方法都没有synchronized修饰 表示StringBuilder在多线程环境下运行是不安全的
	StringBudder中的方法都有synchronized修饰    表示StringBuffer在多线程环境运行是安全的

下面的东西时可以让基本数据类型 直接转换为引用类型数据（类）
也可以让字符串这些东西转换为基本数据类型（自行查询使用方法）
基本数据类型            包装类型
byte		java.lang.Byte
short		java.lang.Short
int 		java.lang.Intrger
long		java.long.Long
float		java.long.Float
double		java.long.Double
boolean		java.long.Boolean
char		java.longCharacter
Integer.MAX_VALUE   Integer.MIN_VALUE   直接输出得出int的最大值和最小值
byte ........等等都同上一样可以输出
自动装箱和拆箱 在jdk1.5后自动支持

异常信息：
	空指针异常 NullPointerException
	类型转换异常 ClassCastException
	数组下标越界异常 ArrayIndexOutOfBoundsException
	数字格式化异常 NumberFormatException
SimpleDateFormat  
	format :String-->Date
	parse :Date-->String   

本文地址：https://blog.csdn.net/slalala123/article/details/107879946