Java基础学习笔记（上）

目录

第一章   环境

第二章 Java基础语法

1、开发工具

2、注释、标识符命名规则和Java关键字

3、数据类型

4、数据类型转换

5、运算符与表达式

6、Java选择与循环语句

7、数组

第三章 Java面向对象

1、面向对象

2、类与对象的关系：人与张三，沙发与特指的这张沙发

3、方法

4、构造方法与this关键字

5、访问控制权限以及package import关键字

6、内部类

7、代码块

8、String类

9、Java类的继承

10、final关键字

11、抽象类

12、接口：

13、对象多态性

14、Object类：所有类的父类

15、instanceof关键字  判断对象是否属于某个类

16、匿名内部类：某个类只使用一次：直接new一个接口或抽象类

17、包装类：每个基本类型都对应一个包装类

18、设计模式：

---

跟得是索南杰夕的Java从入门到精通

第一章   环境

1、运行环境：配环境变量后知道jdk的路径信息，程序运行时知道去系统的哪个地方找jdk

2、编写一个HelloWorld.java

public class HelloWorld{
    public static void main(String args[]){
    System.out.println("hello Java")；
    }
}

cmd回车      输入javac HelloWorld    //编译（.java-->.class）

                    输入java HelloWorld    //运行

3、查询jdk的版本的命令java -version

 

第二章 Java基础语法

 

1、开发工具

 

2、注释、标识符命名规则和Java关键字

 

    1）注释：单行注释：//

                    多行注释：/*.....*/

                    文档注释：/**.....*/

    2）标识符：数字、字母、下划线、美元符号     （首位不能是数字，关键字不能做标识符）

    3）关键字：class、void、static、for等等

 

3、数据类型

//定义一个float变量
//小数默认是double，表示float要加f
//float f=1.1错误
float f=1.1f;
system.out.println("f");//快捷方式：打出syso  art+/

//获取float的最大值
float max_f=Float.MAX_VALUE;//查看方法  Ctrl+鼠标

4、数据类型转换

 

    自动转换条件：1）转换前后数据类型相容

                            2）转换后的数据类型范围更大

 

    强制类型转换：

//强制类型转换,不安全，没事儿别用
double d=3.141;
float f;
f=(float)d;

5、运算符与表达式

 

++a与a++的区别

 

6、Java选择与循环语句

 

1)选择结构

    if

    if...else

    if...else if...else

    switch

package com.java.chap02;
import java.util.Scanner;//Ctrl+shift+o自动导包

public class demo1 {
	public static void main(String args[]){
		System.out.println("请输入一个数字");
		Scanner scanner=new Scanner(System.in);//定义一个系统输入对象
		int n=scanner.nextInt();//控制台输入
        
        switch(n){
			case 1:{
				System.out.println("用户输入的是1");
				break;
			}
			case 2:{
				System.out.println("用户输入的是2");
				break;
			}
	}
}

2）循环

    while（先判断后执行）

    do...while（先执行后判断，故必定执行一次或以上）

    for

    嵌套for循环

/**
 * for循环
 */
public class demo2 {
	public static void main(String args[]){
		for(int k=0;k<10;k++)
			System.out.print(k+" ");
	}
}


/**
 * 水仙花数:一个三位数，其各位数的立方等于本身
 */
public class demo3 {
	public static void main(String args[]){
	for(int a=1;a<=9;a++)
		for(int b=0;b<=9;b++)
			for(int c=0;c<=9;c++){
				int m=a*a*a+b*b*b+c*c*c;
				int n=a*100+b*10+c;
				if(m==n)
					System.out.print(m+" ");
			}
	}					
}//也可设100<=n<=999

3)循环结构的控制

  break  结束本层循环    break+标签：跳到标签

  continue  结束本次循环

  return  结束方法

main(){ //return跳到这里
    while(){ //break跳到这里
          while(){  //continue跳到这里
                
          }
    }
}

 

7、数组

 

1）定义：type[ ]  arryMame

           type ayyrName[ ]

2）初始化：

        静态初始化：arryName[ ]=new type[ ] {element1,element2......}

        动态初始化：arryName[ ]=new type[ len ]

//定义一个数组并静态初始化
int arr1[]=new int[]{1,2,3};
//遍历
for(int i = 0;i<arr1.length;i++){
    system.out.println(arr1[i]);
}
//foreach方法遍历数组
for(int j:arry){
     system.out.println(j);//把arry的每个值赋给j输出来
}
//定义并动态初始化
int arr2[] = new int[3];//默认每个值为0

对比String的内存分析

数组是一个指针地址

 

3）二维数组及多维数组

//定义及其静态初始化
int[][] arr = new int[][]{{1,2,3},{4,5,6},{7,8,9}};

//遍历
for(int i=0;i<arr.length;i++){//arr.length获取行
    for(int j=0;j<arr[0].length;j++){//获取列
        system.out.print(arr[i][j]+" ");
    }
    system.out.println();
}
    
//定义及其动态初始化
int[][] arr2 = new int[3][3];

第三章 Java面向对象

1、面向对象

三大特性：封装、继承、多态

2、类与对象的关系：人与张三，沙发与特指的这张沙发

public class Person {
	
	//属性
	String name;
	int age;
	
	//方法
	public void speak(){
		System.out.println("我叫"+name+"  年龄"+age);
	}
	
	public static void main(String[] args) {
		//定义一个person类的张三
		Person zhangsan;
		//实例化
		zhangsan = new Person();
		//给对象赋值
		zhangsan.name = "张三";
		zhangsan.age = 22;
		zhangsan.speak();
	}
}

3、方法

1）定义与使用

public class People {
    /**
     * 最简单的一个方法定义
     * */
    
    void speak(){
        System.out.println("我叫张三");
    }
    
    public static void main(String[] args) {
        //要使用类的普通方法先得new一个对象
        People zhangsan = new People();
        zhangsan.speak();
    }
}

2）方法的值传递和引用传递（重点）

    首先明白形参与实参，main方法中调用speak时，传入参数“张三”，此为实参；speak方法中定义一个String类型的name参数，表示我得接受一个String类型参数才能工作，name为形参，可以理解为形式上的参数，这个参数就相当于占了一个位置。

        //形参
	void speak(String name){
		System.out.println("我叫"+name);
	}
	
	public static void main(String[] args) {
		People zhangsan = new People();
		zhangsan.speak("张三");
	}

       //形参
	int speak(String name,int age,String ...hobbles){//...hobbles代表无数个
		System.out.println("我叫"+name+"年龄");
		System.out.print("我的爱好：");
		
		for(String hobby:hobbles){
			System.out.print(hobby+" ");
		}
		
		int totalhobbles = hobbles.length;
		return totalhobbles;
	}
	
	public static void main(String[] args) {
		People zhangsan = new People();
		//zhangsan.speak("张三",22);可以为0
		int n = zhangsan.speak("张三",22,"游泳","唱歌","阅读");
		System.out.print("\n我有"+n+"个爱好");
	}

值传递：如下例，main方法调用speak方法时传入一个参数22，speak得到参数并执行，当speak执行时会重新开辟自己的工作空间，并把收到参数复制到工作区间里赋值，故speak方法中的age其实是复制的，并非与main中的age在一块存储空间。

/*
 * 值传递
 * **/
public class People2 {
	
	static void speak(int age){
		System.out.println("我今年"+age+"岁了");
		age = 55;//这个只在speak方法内有效
	}
	
	public static void main(String[] args) {
		People2 zhangsan = new People2();
		int age = 22;
		zhangsan.speak(age);
		System.out.println(age);
		
	}

}


我今年22岁了
22

引用传递：传入的是地址，所以参数保持一致。

public class SanWei{
    public int b;
    public int w;
    public int h;
}

public class People2 {
	/**
	 * 报三围
	 * @param age
	 * @param sanWei
	 */
	static void speak(int age,SanWei sanWei){//传一个对象进去
		System.out.println("我今年"+age+"岁了,"+"我的三围是 "+sanWei.b+","+sanWei.w+","+sanWei.h);
		age = 55;
		sanWei.b=100;
	}
	
	public static void main(String[] args) {
		People2 zhangsan = new People2();
		int age = 22;
		SanWei sanWei = new SanWei();
		sanWei.b = 90;
		sanWei.w = 60;
		sanWei.h = 90;
		//age是值传递，sanWei是引用传递（地址）
		zhangsan.speak(age,sanWei);
		System.out.println(age);
		System.out.println(sanWei.b);
		
	}
}
我今年22岁了,我的三围是 90,60,90
22
100

3）方法的重载（Java多态的体现之一）

定义：方法名相同，但参数的类型或数量不同

int add(int a,int b){
		System.out.println("方法一");
		return a+b;
	}
	
	int add(int a,int b,int c){
		System.out.println("方法二");
		return a+b+c;
	}
	
	double add(double a,double b){
		System.out.println("方法三");
		return a+b;
	}
public static void main(String[] args) {
		Demo demo = new Demo();
		System.out.println(demo.add(1,2));
		System.out.println(demo.add(1.0,2.0));
	}

方法一:3
方法三:3.0

4）static静态方法与普通方法

static静态方法：方法属于类本身；调用方式：类名.方法，（对象.方法：也行，会有警告）

普通方法：方法属于类的对象；调用方式：对象.方法

（static方法使用前不必要new一个对象）

5）递归方法：方法通过直接间接的方式调用自己。

 

4、构造方法与this关键字

 

1）构造方法：创建实例（对象）时执行初始化，没有构造方法，系统会自动生成一个默认的无参构造方法。

/**
 * 构造方法
 * @author xiaoqing
 *
 */
public class People {
	//String默认为null
	//int默认为0
	private String name;
	private int age;
	//构造方法名与类名相同
	People(){
		System.out.println("无参构造方法");
	}
    
	void say(){
		System.out.println("我叫"+name+"  年龄"+age);
	}
	public static void main(String[] args) {
		People people = new People();
		people.say();
	}
}
无参构造方法
我叫null  年龄0

/**
 * 构造方法
 * @author xiaoqing
 *
 */
public class People {
	//String默认为null
	//int默认为0
	private String name;
	private int age;
	
	People(String name2,int age2){
		System.out.println("有参构造方法");
		name = name2;
		age = age2;
	}
	void say(){
		System.out.println("我叫"+name+"  年龄"+age);
	}
    
	public static void main(String[] args) {
		People people = new People("张三",22);
		people.say();
	}
}
有参构造方法
我叫张三  年龄22

2）this表示当前对象

调用本类中的属性

调用构造方法

public class People2 {
	
	private String name;
	private int age;
	
    //构造方法可重载
    
	People2(){
		System.out.println("无参构造方法");
	}
	People2(String name,int age){
		this();   //执行无参构造方法
		System.out.println("有参构造方法");
		this.name = name;
		this.age = age;
	}
	void say(){
		System.out.println("我叫"+name+"  年龄"+age);
	}
	public static void main(String[] args) {
		People2 people2 = new People2("张三",22);
		people2.say();
	}

}
无参构造方法
有参构造方法
我叫张三  年龄22

5、访问控制权限以及package import关键字

1）访问控制权限（默认是包）

private(私有)  get、set方法调用

package（包访问权限）

protected（子类访问权限）

public（公共）

/**
 * 私有属性get、set、调用
 * @author xiaoqing
 *
 */
package com.java.chap03.quanxian;

public class Demo {
	//定义一个私有属性
	private int a;
	
	public int getA(){
		return a;
	}
	public void setA(int a){
		this.a = a;
	}
}



package com.java.chap03.quanxian;

public class TestDemo {
	public static void main(String[] args) {
		Demo demo = new Demo();
		demo.setA(2);
		int a = demo.getA();
		System.out.println(a);
	}
}


2

6、内部类

定义：在类的内部定义类，可以使用外部类属性，但破坏类的结构，慎用

/**
 * 定义内部类
 * @author xiaoqing
 *
 */
public class Outer {
	private int a = 1;
	
	class Inner{
		public void show(){
			System.out.println(a);
		}
	}
	public void show(){
		Inner inner = new Inner();
		inner.show();
	}
	
	public static void main(String[] args) {
		Outer outer = new Outer();
		outer.show();
	}
}

/**
* 定义内部类
* 直接使用
* @author xiaoqing
*
*/
public class Outer1 {
	private int a = 1;
	
	class Inner{
		public void show(){
			System.out.println(a);
		}
	}
	
	public static void main(String[] args) {
		Outer1 outer1 = new Outer1();//实例化外部类似对象
		Outer1.Inner inner = outer1.new Inner();//实例化内部类对象
        inner.show();
	}
}

7、代码块

1）普通代码块

public class Demo1 {

	public static void main(String[] args) {
		int a = 1;
		/**
		 * 普通代码块
		 */
		{
			a = 2;
			System.out.println("普通代码块");
		}
		System.out.println("a="+a);
	}
}


2

2）构造块：写在构造方法之前

/**
 * 构造块
 * @author xiaoqing
 *
 */
public class Demo2 {

	//构造块
	{
		System.out.println("通用构造块");
	}
	
	public Demo2(){
		System.out.println("构造方法一");
	}
	public Demo2(int a){
		System.out.println("构造方法二");
	}
	
	public static void main(String[] args) {
		new Demo2();
		new Demo2(2);		
	}
}
通用构造块
构造方法一
通用构造块
构造方法二

3）静态代码块

/**
 * 静态代码块
 * @author xiaoqing
 *
 */
public class Demo3 {

	//构造块
	{
		System.out.println("通用构造块");
	}
	
	 // 静态代码块，最先执行，只执行一次
	static{
		System.out.println("静态代码块");
	}
	
	public Demo3(){
		System.out.println("构造方法一");
	}
	public Demo3(int a){
		System.out.println("构造方法二");
	}
	
	public static void main(String[] args) {
		new Demo3();
		new Demo3(2);
	}
}
静态代码块
通用构造块
构造方法一
通用构造块
构造方法二

8、String类（是一个final类）

1）实例化String对象

//法一 直接赋值
String name = "amy";
//法二 new一个
String name = new String("lisa");

直接赋值：创建的对象放在字符串对象池里，假如存在的就不会在创建

new对象方式：每次都创建一个新的对象

public class Demo2 {
	public static void main(String[] args) {
		
		String name1 = "张三";//直接赋值
		String name2 = "张三";
		String name3 = new String("张三");//new一个
		String name4 = new String("张三");
		
		System.out.println("name1==name2:"+(name1==name2));
		System.out.println("name3==name4:"+(name3==name4));
		System.out.println("name1==name3:"+(name1==name3));
	}
}
name1==name2:true
name3==name4:false
name1==name3:false

2）“==”与“equals方法”(重点)

==比较的是引用，equal方法比较的是具体内容

public class Demo1 {
	
	public static void main(String[] args) {
		
		String name1 = "张三";  //直接赋值
		String name2 = new String("张三");  //new一个
		String name3 = name2;  //传递引用
		
		//==比较的是引用
		System.out.println("name1==name2:"+(name1==name2));
		System.out.println("name1==name2:"+(name2==name3));
		System.out.println("name1.equal(name2):"+name1.equals(name2));
	}
}
name1==name2:false
name2==name3:true
name1.equal(name2):true

3）字符串内容不可变性（重要）：不能改变字符串内容，只能指向一个新的地址

String name1 = "张";
name2 += "三";

4）String类的常用方法及基本使用

public class Test1 {

	public static void main(String[] args) {
		String name = "张三";
		char ming =name.charAt(1);//获取字符串某一位置的字符
         System.out.println(ming); 
        /**
		 * charAt()遍历字符串
		 */
		String str = "我是中国人";
		for(int i=0;i<str.length();i++){
			System.out.println(str.charAt(i));
		}
        System.out.println(n);
	}
}
三
我
是
中
国
人

 String str = "abcdcda";
		System.out.println("c在字符串中第一次出现的位置："+str.indexOf("c"));
        System.out.println("c在字符串中第一次出现的位置,从后向前："+str.lastIndexOf("c"));
        System.out.println(str.substring(2));
        System.out.println(str.substring(2,5));//234
        System.out.println(str.toUpperCase());//但str不变,仍为小写
        
        String upStr = str.toUpperCase();
		System.out.println(upStr.toLowerCase());//转小写
c在字符串中第一次出现的位置：2
c在字符串中最后出现的位置：4  
cdcda
cdc
ABCDCDA
abcdcda

9、Java类的继承

 

1）定义：子类可以继承父类的属性和方法，但private不能继承

public class Animals {
	private String name ;
    
	public String get(){
		return name;
	}
	public void set(String name){
		this.name = name;
	}	
    public void say(){
		System.out.println("我是："+name);
	}
}

public class Dog extends Animals{
    //通过get、set访问private
public static void main(String[] args) {
		Dog dog = new Dog();
		dog.set("旺财");
		dog.say();
	}
}
我是：旺财

2）方法重写：子类把父类的方法进行重写

3）对象实例化过程及super关键字

         实例化对象

public class Animals {

	private String name ;
	
	public Animals(){
		System.out.println("父类构造方法");
	}
	public String get(){
		return name;
	}
	public void set(String name){
		this.name = name;
	}
	
	public void say(){
		System.out.println("我是："+name);
	}

public class Fish extends Animals{

	public Fish(){
		//子类的所有构造函数中的第一行，其实都有一条隐身的语句super();
		System.out.println("子类构造方法");
	}
	
	public static void main(String[] args) {
		Fish fish=new Fish();
		fish.set("Mini");
		fish.say();
	}
}
父类构造方法
子类构造方法
我是：Mini

 super关键字：调用父类

public class Cat extends Animals{
	
	public Cat(){
		super();//调用父类的构造方法
		System.out.println("子类构造方法");
	}//有参构造函数用super（  ，  ）调用private属性
	/**
	 * 方法重写
	 */
	public void say(){
		super.say();//调用父类say方法
		System.out.println("我是猫："+get());
	}
	
	public static void main(String[] args) {
		Cat cat = new Cat();
		cat.set("Mini");
		cat.say();
    }
}
父类构造方法
子类构造方法
我是动物：Mini
我是猫：Min

10、final关键字（终结的）

 

修饰类不能被调用（比如String类）

声明方法不能被覆盖（重写）

声明变量不能被修改，常量

 

11、抽象类

 

只要含有一个抽象方法的类就是抽象类，不能生成对象

声明方式abstract

抽象方法只需要声明不需要实现

子类（非抽象类）继承抽象类必须重写抽象类中的全部抽象方法

抽象类不能被实例化

 

12、接口：

1）一种特殊的抽象类，没有普通方法，由全局常量和公共的抽象方法所组成

2）实现接口

3）先继承类后实现接口

4）接口的继承（可实现多继承）

ackage com.java.chap03.sec12;
//定义接口
public interface A {
	/**
	 * 全局常量
	 */
	public static final String TITLE="java.com";
	
	public abstract void a();//只能声明，不能实现
}

/**
 * 接口的实现
 */
//public class Test extends C implements A
public class Test implements A{//可以实现多个接口，加逗号
	public void a() {
		System.out.println("a方法");	
	}
	public static void main(String[] args) {
		Test t = new Test();
		t.a();
		System.out.println(TITLE);
	}
}
a方法
java.com

13、对象多态性

 

  1）体现：方法的重载与重写；

                  可以用父类的引用指向子类的具体实现，而且可以更换为其他子类的具体实现

public class Animals {
	public void say(){
		System.out.println("我是一个动物");
	}
}

public class Dog extends Animals{
	public void say(){
		System.out.println("我是一只狗");
	}
}

public class Cat extends Animals{
	public void say(){
		System.out.println("我是一只猫");
	}
}

public class Test {
	public static void main(String[] args) {
        //父类引用指向Dog类的具体实现
		Animals animals = new Dog();
		animals.say();
		//更换
		animals = new Cat();
		animals.say();
	}
}
我是一只狗
我是一只猫

2）对象的转型

        向上转型   子类->父类，安全（如上）Animals animals = new Dog();

        向下转型   父类->子类，不安全（用接口）

 

14、Object类：所有类的父类

 

常用方法   public String toString()返回该对象的字符串表示

                 public boolean equals(Object obj)指示其他某个对象是否与此对象“相等”：指向同一地址时返回true

                     https://zhuanlan.zhihu.com/p/50206657

                    重写equals方法必须重写hashCode方法，为了保证equals认定的同一对象具有相同hash值）

package com.java.chap03.sec14;

public class People {

	private String name;

	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
   //构造方法
	public People(String name) {
		this.name = name;
	}
	public static void main(String[] args) {
		People p1 = new People("张三");  //new时调用构造方法
		System.out.println(p1);  //默认调用toString方法，
		System.out.println(p1.toString());
	}	
}
com.java.chap03.sec14.People@de6ced
com.java.chap03.sec14.People@de6ced

重写toString

package com.java.chap03.sec14;

public class People {

	private String name;

	public String getName() {
		return name;
	}

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

	public People(String name) {
		this.name = name;
	}
	//重写toString
	@Override
	/*public String toString() {
		return super.toString();
	}*/
	public String toString() {
		return this.getName();
	}
	public static void main(String[] args) {
		People p1 = new People("张三");
		System.out.println(p1);
		System.out.println(p1.toString());
	}
张三
张三

15、instanceof关键字  判断对象是否属于某个类

 

16、匿名内部类：某个类只使用一次：直接new一个接口或抽象类

 

17、包装类：每个基本类型都对应一个包装类

1）装箱和拆箱

 int a;
	Integer i = new Integer(a);//装箱过程，把基本变量变成对象变量
	int b = i.intValue();//拆箱，把对象变量变成基本变量

    Integer j =1;//自动装箱,自动把基本变量变成对象变量
	int k = j;//自动拆箱

2）自动拆箱和装箱

3）包装类的作用：Integer有很多等方法来专门处理int型相关的数据；在Java中绝大部分方法或类都是用来处理类类型对象的，如ArrayList集合类就只能以类作为他的存储对象，而这时如果想把一个int型的数据存入list是不可能的，必须把它包装成类，也就是Integer才能被List所接受。

public static void main(String[] args) {
		String a = "1";
		String b = "3";
		int m = Integer.parseInt(a);
		int n = Integer.parseInt(b);
		System.out.println(m+n);
	}

18、设计模式：

        单例模式：Java应用中，单例对象能保证在一个JVM中，该对象只有一个实例存在