java语法笔记typora版

最新推荐文章于 2024-10-22 13:48:16 发布
最新推荐文章于 2024-10-22 13:48:16 发布
阅读量998 收藏 5
点赞数 1
文章标签： java 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/LY201704060320/article/details/115047841
版权

java语法学习

一、java基本语法

1.配置环境变量

  • java程序执行过程：编写txt记事本文档，后缀名改为java，注意文件夹显示是否有隐藏后缀名；然后win+R+cmd打开窗口，修改路径（添加了path和classpath则分别不需cd到javac和文件所在路径），先javac+文件名.java将.java文件编译成.class文件，再java+class名执行。

  • path与classpath区别

    path环境变量里面记录的是可执行文件，如.exe文件（没编译成.class文件前的文件），对可执行文件先在当前路径找，如果没有找到就去path环境变量中配置的路径中去找；

    classpath环境变量记录的是java类的运行文件所在目录

  • 通过JAVA_HOME配置环境变量：

    (1) 新建系统变量JAVA_HOME，变量值填bin地址如C:\Program Files\Java\jdk-11.0.6\bin；

    (2)在系统变量Path中添加%JAVA_HOME%\bin，则以后要更改、添加变量时便不需修改Path，直接修改JAVA_HOME中变量即可。若频繁修改Path，容易错改系统变量（system开头的变量）导致系统出问题！

2.标识符的命名规则

  • 包：包其实就是文件夹，用于对相同的类名进行区分

    全部小写

    单级：rex

    多级：rex.doc（用.分隔各级）

  • 类或者接口：

    一个单词：首字母大写 Student

    多个单词：每个单词的首字母必须大写 HelloWorld

    以下例外：DO/BO/DTO/VO/AO/PO/UID等，因本身就是首字母缩写，所以都大写；

  • 方法或变量

    一个单词：单词首字母小写

    多个单词：从第二个单词开始，每个单词的首字母大写；

    举例：studentAge,showAllNames

  • 常量

    一个单词：全部大写，如PI；

    多个单词：每个字母都大写，用_隔开

    举例：STUDENT_MAX_AGE；

  • 代码中严禁拼音与英文混合方式表达，如getPingfenByName等；

  • 代码中命名不能以下划线或美元符号开始或结束，如_name$。

3.接收用户输入

public static void main(String[] args){
    //先new一个Scanner input
    Scanner input= new Scanner(System.in);
    //input.nextInt()只能接收int类型输入，相应的还有只能接收float等的；
    System.out.println("请输入一段数字")；
    int i = input.nextInt();
    //input.next()和input.nextLine()可以接收字符串输入，数字字母都行
    System.out.println("请输入next接收的内容")；
    string str1 = input.next();
    System.out.println("请输入nextLine接收的内容")；
    string str2 = input.nextLine();
}

  • input.next()和input.nextLine()区别：

    input.next()空格、回车都可以结束输入，因此无法输入空格，若输入内容包括空格，则空格后内容都无法接收。若开头先输入空格，再输入字符，则前面的空格不会接收，接收字符。

    但input.nextLine()指输入一行内容，只有回车才可以结束输入，因此可以接收空格。

4.数组

可以使用数组来表示“一组”int类型。

  • 两种常用表示法：
int[] ages={10,11,12,13,14};
int[] ages2=new int[10];

代码如下：

public class Main {

  public static void main(String[] args) {

​    // 5位同学的成绩:
​    int[] ns = new int[5];
​    ns[0] = 68;
​    ns[1] = 79;
​    ns[2] = 91;
​    ns[3] = 85;
​    ns[4] = 62;
System.out.println(ns.length);//获取数组大小
  }
}

也可以在定义数组时直接指定初始化的元素，这样就不必写出数组大小，而是由编译器自动推算数组大小。

int[] ns = new int[] { 68, 79, 91, 85, 62 };

还可进一步简写为int[] ns = { 68, 79, 91, 85, 62 };

  • 注意：数组是引用类型，并且数组大小不可变。

例1：

public class Main {

  public static void main(String[] args) {
​    // 5位同学的成绩:
​    int[] ns;
​    ns = new int[] { 68, 79, 91, 85, 62 };
​    System.out.println(ns.length); // 5
​    ns = new int[] { 1, 2, 3 };
​    System.out.println(ns.length); // 3
  }

}

数组大小变了吗？看上去好像是变了，但其实根本没变。

对于数组ns来说，执行ns = new int[] { 68, 79, 91, 85, 62 };时，它指向一个5个元素的数组：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9s4lHkGW-1616302583389)(file:///C:\Users\jy\AppData\Local\Temp\ksohtml15336\wps6.jpg)]

执行ns = new int[] { 1, 2, 3 };时，它指向一个新的3个元素的数组：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7J8nswXU-1616302583395)(file:///C:\Users\jy\AppData\Local\Temp\ksohtml15336\wps7.jpg)]

但是，原有的5个元素的数组并没有改变，只是无法通过变量ns引用到它们而已。

例2：若数组元素不是基本类型，而是一个引用类型（string）

public class Main {

  public static void main(String[] args) {
​    String[] names = {"ABC", "XYZ", "zoo"};
​    String s = names[1];
​    names[1] = "cat";
​    System.out.println(s); // s是"XYZ"还是"cat"?答案是XYZ。
  }

}
  • 多维数组
int[][]nums=new int[10][];
//赋值
nums[0]=new int[]{1,2,3};
//访问
System.out.println(nums[0][2]);//访问到了刚赋值的3

5.for each循环

for循环经常用来遍历数组，因为通过计数器可以根据索引来访问数组的每个元素：

int[] ns = { 1, 4, 9, 16, 25 };
for (int i=0; i<ns.length; i++) {
    System.out.println(ns[i]);
}

但是，很多时候，我们实际上真正想要访问的是数组每个元素的值。Java还提供了另一种for each循环，它可以更简单地遍历数组：

public class Main {
    public static void main(String[] args) {
        int[] ns = { 1, 4, 9, 16, 25 };
        for (int n : ns) {
            System.out.println(n);
        }
    }
}

和for循环相比，for each循环的变量n不再是计数器，而是直接对应到数组的每个元素。for each循环的写法也更简洁。但是，for each循环无法指定遍历顺序，也无法获取数组的索引。

除了数组外，for each循环能够遍历所有“可迭代”的数据类型，包括后面会介绍的List、Map等。

6.循环嵌套打印图形

  • 注意若是双重循环来打印，外层循环控制行数，内层循环控制列数
  • 例题：

7.break与continue区别

  • break是终止本轮所有循环，之后所有循环终止；
  • continue则是终止本轮单次的循环，本次循环continue后代码不执行，进入下一循环

8.如何退出多重循环

  • 给想要结束的循环层次命名，break+循环名即可：

public class Demo10 {

	/**
	 * 如何退出多重循环
	 * @param args
	 */
	public static void main(String[] args) {
		haha:for(int i=0;i<10;i++) {//循环命名为haha
			for(int j=0;j<10;j++) {
				System.out.println("i="+i+" , j="+j);
				if(i==5 && j==5) {
					break haha;
				}
			}
		}
	}
}

二、面向对象

#初级

1.思想概述

  • 面向对象(Object Oriented)是软件开发方法。面向对象的概念和应用已超越了程序设计和软件开发，是一种对现

    实世界理解和抽象的方法，是计算机编程技术发展到一定阶段后的产物。

    面向对象是相对于面向过程来讲的，指的是把 相关的数据和方法组织为一个整体 来看待，从更高的层次来进行系

    统建模，更贴近事物的自然运行模式。

  • 面向过程关注的是执行的过程，面向对象关注的是具备功能的对象。

面向过程到面向对象，是程序员思想上 从执行者到指挥者的转变。

举例：
我们再描述一个生活的场景： 场景：当我们独自生活时， 我们经常纠结一日三餐怎么吃。
面向过程： 每天亲力亲为： 买菜 - 做饭 - 吃饭 - 洗碗 的过程。 
面向对象： 招聘一个保姆，每天等吃即可。 
场景升级： 假设你是一个富豪， 拥有一座占地3000亩地的庄园 ，不再是只关注吃饭问题 ， 还有花草树木修剪，泳池维 护清洗，卫生打扫，洗衣做饭。。。。。。 
面向过程： 此处省略看着就累的N字。 
面向对象： 招聘一个管家， 然后让管家招聘 园丁、泳池维护工、保姆等等。 
结论：从上述的栗子中， 我们发现面向过程，我们需要关注很繁琐的过程。 
而面向对象不用关注具体的细节，更关注的是统筹架构的问题。
其实我们进行大型应用开发时。就如上述的例子一样，如果我们写程序只关注过程的话，代码量达到一定层次以后，就很难再编写下去了。

  • 三大思想

    OOA：面向对象分析（Object Oriented Analysis）

    OOD：面向对象设计（Object Oriented Design）

    OOP：面向对象程序（Object Oriented Programming

  • 三大特征

    封装性：所有的内容对外部不可见

    继承性：将其他的功能继承下来继续发展

    多态性：方法的重载本身就是一个多态性的体现

2.创建对象

3.对象创建内存

java中需要关注的内存部分只要是栈和堆内存

  • 栈
栈存储的是: 基本数据类型的数据，以及引用数据类型的引用（即地址） 
例如: int a =10; Person p = new Person(); 
数据10存储在栈内存中 , 第二句代码创建的对象的引用(p)存在栈内存中

Java栈的区域很小,大概2m左右,
特点是存取的速度特别快 ,先进后出
堆存储速度快的原因: 栈内存, 通过'栈指针'来创建空间与释放空间!
指针向下移动,会创建新的内存,向上移动,会释放这些内存!
这种方式速度特别快,仅次于PC寄存器! 
但是这种移动的方式, 必须要明确移动的大小与范围,明确大小与范围是为了方便指针的移动,
这是一个对于数据存储的限制，存储的数据大小是固定的,影响了程序的灵活性
所以我们把更大部分的数据，存储到了堆内存中
  • 堆内存
堆内存存储的是：类的对象

.Java是一个纯面向对象语言, 限制了对象的创建方式: 所有类的对象都是通过new关键字创建 
new关键字,是指告诉JVM  需要明确的去创建一个新的对象,去开辟一块新的堆内存空间: 
堆内存与栈内存不同,优点在于我们创建对象时,不必关注堆内存中需要开辟多少存储空间,也不需要关注内存占用时长!
堆内存中内存的释放是由GC(垃圾回收器)完成的
垃圾回收器回收堆内存的规则: 当栈内存中不存在此对象的引用（即地址）时,则视其为垃圾,等待垃圾回收器回收!
例如:
Person p0 = new Person(); 
Person p1 = p0; 
Person p2 = new Person();

对象创建内存变化图解：

QQ截图20210304202130

对象内存释放图解：

QQ截图20210304202343

4.构造方法

Person p = new Person();
在右侧Person后面出现的小括号, 其实就是在调用构造方法
  • 特点：

在创建对象时，会自动调用，用于对象初始化。

所有的Java类中都会至少存在一个构造方法 如果一个类中没有明确的编写构造方法, 则编译器会自动生成一个无参的构造方法, 构造方法中没有任何的代码。

  • 注意
建议自定义无参构造方法，不要对编译器形成依赖，避免错误发生。 
当类中有非常量成员变量时，建议提供两个版本的构造方法，一个是无参构造方法，一个是全属性做参数的构造方法。 
当类中所有成员变量都是常量或者没有成员变量时，建议不提供任何版本的构造。

格式与例子：

public class Demo4 {
    
	public static void main(String[] args) {
        //new的时候传参，则调用的是全参构造方法
		Person2 p1 = new Person2("张三");
		//p1.name  = "张三";
		p1.age = 18;
		p1.say();
	}

}
class Person2{
	
	Person2(){//自己定义的 无参构造方法
        
	}	
    Person2(String n){//自己定义的 全参构造方法
		name = n;
	}	
	String name;
	int age;
	
	void say() {
		System.out.println("自我介绍。我是:"+name+" , 我的年龄:"+age);
	}
}

5.重载

  • 方法的重载

    方法名称相同, 参数类型或参数长度不同, 可以完成方法的重载。方法的重载与返回值无关!

    方法的重载 ,可以让我们在不同的需求下, 通过传递不同的参数调用方法来完成具体的功能。

  • 构造方法的重载

    一个类, 可以存在多个构造方法 :

    参数列表的长度或类型不同即可完成构造方法的重载 ~

    构造方法的重载 ,可以让我们在不同的创建对象的需求下, 调用不同的方法来完成对象的初始化!

6.匿名对象

public static void main(String[] args) {
		int num = new Math2().sum(100, 200);
    //若变量要使用第二次，必须使用非匿名：
    //Math2 m1 = new Math();
		System.out.println(num);

==========

#进阶

1.封装

对所有属性进行封装，就是定义成private，并为其提供setter及getter方法进行设置和取得操作。

好处是可以控制输入数值的合法性

创建Getters and Setter快捷键：用快捷键Alt+Shift+S,选择Generate Getters and Setter创建

class Person{ 
private String name ; // 表示姓名 
private int age ; // 表示年龄 
void tell(){ 
System.out.println("姓名：" + getName() + "；年龄：" + getAge()) ; 
}
public void setName(String str){ 
name = str ; 
}
public void setAge(int a){ //封装判断输入是否合法
if(a>0&&a<150) 
age = a ; 
}
public String getName(){ 
return name ; 
}
public int getAge(){ 
return age ; 
} 
};

public class OODemo10{ 
public static void main(String args[]){ 
Person per = new Person();
    per.setName("张三"); 
    per.setAge(-30); 
    per.tell();
} 
}

2.this用法

调用类中的方法时，若传的形参和类本身的属性名字相同，则给类自己的属性赋值时要加this，否则会形参自己传给自己

例：定义一个全参数构造方法

用this()调用构造方法，必须写在子类构造方法的第一行，与后文super()对比

//定义传全参数的构造方法
public Kkbstudent(String name,int age,String sex,String hobbies,String company,String subject) {
			this.name = name;
			this.age = age;
			this.sex = sex;
			this.hobbies = hobbies;
			this.company = company;
			this.subject = subject;

3.static静态

被static关键字修饰的方法或者变量，不需要依赖于对象来进行访问，在类加载时就加载并初始化了，可以通过类名去进行访问。

无论一个类存在多少个对象 , 静态的属性, 永远在内存中只有一份( 可以理解为所有对象公用 )

在访问时： 静态不能访问非静态 , 非静态可以访问静态 !

应用：当多个对象的同一个属性，有相同的值时

public class StudentTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//若多个对象有相同的属性值，则定义为静态属性，并在new对象之前先赋值
		Kkbstudent.company = "开课吧";
		Kkbstudent.subject = "java学科";
		Kkbstudent student1 = new Kkbstudent("张三",20,"男","打球");	
		Kkbstudent student2 = new Kkbstudent("李四",21,"女","打牌");
		student1.detail();
		student2.detail();
		//若要创建共同属性不同的人
		Kkbstudent student3 = new Kkbstudent("张三",20,"男","打牌","不开课了吧","打牌艺术");
		student3.detail();

	}

}
class Kkbstudent {
	private String name;
	private int age;
	private String sex;
	private String hobbies;
	static String company;//静态属性定义
	static String subject;
    //定义传部分参数的构造方法
	public Kkbstudent(String name,int age,String sex,String hobbies) {
		this.name = name;
		this.age = age;
		this.sex = sex;
		this.hobbies = hobbies;
	}
	//定义传全参数的构造方法
		public Kkbstudent(String name,int age,String sex,String hobbies,String company,String subject) {
			this.name = name;
			this.age = age;
			this.sex = sex;
			this.hobbies = hobbies;
			this.company = company;
			this.subject = subject;
		}
    //......

4.代码块

  • 普通代码块

    在执行的流程中出现的代码块，我们称其为普通代码块。

  • 构造代码块

    在类中的成员代码块，我们称其为构造代码块，在每次对象创建时执行，执行在构造方法之前。

  • 静态代码块

    在类中使用static修饰的成员代码块，我们称其为静态代码块，在类加载时执行。每次程序启动到关闭 ，只会

    执行一次的代码块。

  • 同步代码块

    在后续多线程技术中学习。

面试题：

构造方法与构造代码块以及静态代码块的执行顺序：

静态代码块 --> 构造代码块 --> 构造方法

public class ClothesTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Clothes.number=0;
		Clothes clo1 = new Clothes("red");
		clo1.detail();
		Clothes clo2 = new Clothes("black");
		clo2.detail();
		Clothes clo3 = new Clothes("pink");
		clo3.detail();

	}

}
class Clothes{//定义Clothes类
	private String color;
	static int number;
    //以下是静态代码块，随着类的加载执行（只第一次），因类只创建一次，故仅执行一次
    //一般用于类内部共同的设置
    static{
        
    }
    //以下为构造代码块，随着对象的每次创建执行一次，且执行在构造方法前，无论调用哪一个构造方法创建对象，都会执行！
    //此处用来记录创建对象的数量
	{
		number++;
	}
	public Clothes(String color) {//构造方法
		this.color = color;
	}
	void detail() {//定义detail方法显示衣服信息
		System.out.println("衣服颜色："+color+"，衣服序号："+number);
	}
	public String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	}
	public int getNumber() {
		return number;
	}
	public void setNumber(int number) {
		this.number = number;
	}
	
}

==========

#高级

1.继承及子例实例化内存分析

继承：

class Student extends Person{
    //......
}

子例实例化内存分析：image-20210311120325493

2.super

调用super，可以访问父类构造方法、属性、方法

调用super构造方法的代码，必须写在子类构造方法的第一行

this()与super()是不会同时出现在一个构造方法中。

例：

class Person{
    //......
    public Person(String name,int age){//父类的构造方法
        this.name = name;
        this.age = age;
    //......
}
class Student extends Person{
    public Student(){//子类构造方法
        super("张三"，20);//用super调用父类的构造方法
        super.sex = "男"；
    }
}

3.重写、重载

  • 重写应用场景：子继承父时，方法不适应子类，就把方法重写写一遍
  • 重写(override）规则:

（1）参数列表必须完全与被重写方法的相同;

（2）返回类型必须完全与被重写方法的返回类型相同;

（3）访问权限不能比父类中被重写的方法的访问权限更低。例如:如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected

（4）父类的成员方法只能被它的子类重写。

（5）声明为static和privete的方法不能被重写，但是能够被再次声明。

  • 重写(override)、重载（overload)区别：
重载重写
发生位置一个类中子父类中
参数列表限制必须不同必须相同
返回值类型与返回值无关返回值类型必须一致
访问权限与访问权限无关子方法的访问权限，必须不能小于父方法的权限
异常处理与异常无关异常范围可以更小，但是不能抛出新的异常

4.final

  • 修饰属性、变量：

    变量变成常量

    final修饰的局部变量，只能赋值一次（可先声明后赋值）

    final修饰的成员属性，必须在声明时赋值

    全局常量public static final

    • 常量的命名规范:
      由1个或多个单词组成，单词与单词之间必须使用下划线隔开，单词中所有字母大写例如: SoL INSERT
public class Demo1{
    final int a = 0;//final修饰属性，必须加初始值
    public static void main(String[] args){
        final int a;//final修饰局部变量
        a = 10;
        a = 20;//再次赋值，会报错
    }
}

  • 修饰类：

    不可被继承

  • 修饰方法：

    不能被子类重写

5.抽象类

public abstract Person{//抽象类
    public abstract void say();//抽象方法
}

public class Student extends Person{//实现类1
    
    public void say(){//实现类必须重写父类的抽象方法
        System.out.println("我是学生，我是嘴炮王")；
    }
}

public class Nurse extends Person{//实现类2
    @override//可通过右键创建类的时候，就选定父类，eclipse可自动重写父类的抽象方法
    public void say(){
        System.out.println("我是护士，我技术棒棒的")；
    }
}

抽象类相关问题：

  • 抽象类中也是可以写具体的方法的；

  • 抽象类不可直接用new来创建对象，但子类创建对象时，抽象父类也会被 JVM实例化；

  • 抽象类不能使用final声明；

    因为final属修饰的类是不能有子类的 ， 而抽象类必须有子类才有意义，所以不能；

  • 抽象类能有构造方法；

    而且子类对象实例化的时候的流程与普通类的继承是一样的，都是要先调用父类中的构造方法（默认是无参的），之后再调用子类自己的构造方法；

  • 抽象类只能用public或protected修饰(如果为private修饰，那么子类则无法继承，也就无法实现其抽象方法），默认缺省为 public；

  • 如果一个子类继承抽象类，那么必须实现其所有的抽象方法。如果有未实现的抽象方法，那么子类也必须定义为 abstract类。

6.接口

如果一个类中的全部方法都是抽象方法，全部属性都是全局常量，那么此时就可以将这个类定义成一个接口。

定义格式：

interface 接口名称{ 

//全局常量 
public static final int a = 0;
//接口类里前面几个词可省略，默认变量是全局变量，如下
int b = 0;
//抽象方法 ; 
public abstract void say();
//方法不能有大括号，前面几个词也可省略，是默认的，如下
void say2();
}
  • 接口和抽象类的区别

（1）抽象类要被子类继承，接口要被类实现。

（2）接口只能声明抽象方法，抽象类中可以声明抽象方法，也可以写非抽象方法。

（3）普通变量。

（4）抽象类使用继承来使用， 无法多继承。 接口使用实现来使用， 可以多实现

（5）抽象类中可以包含static方法 ，但是接口中不允许（静态方法不能被子类重写，因此接口中不能声明静态方法）

（6）接口不能有构造方法，但是抽象类可以有

7.多态

  • 概念

    多态：就是对象的多种表现形式，（多种体现形态）

  • 多态的体现

    对象的多态性，从概念上非常好理解，在类中有子类和父类之分，子类就是父类的一种形态 ，对象多态性就从此而来。

    ps: 方法的重载 和 重写 也是多态的一种， 不过是方法的多态（相同方法名的多种形态）。

    重载： 一个类中方法的多态性体现

    重写： 子父类中方法的多态性体现。

  • 多态的使用：对象的类型转换

    类似于基本数据类型的转换：

    · 向上转型：将子类实例变为父类实例

    |- 格式：父类 父类对象 = 子类实例 ；

    · 向下转型：将父类实例变为子类实例

    |- 格式：子类 子类对象 = **（子类）**父类实例 ；

类型转换例子：

public static void mian(String[] args){
    Student a = new Student();
    Nurse b = new Nurse();
    Person p1 = a;
    Person p2 = b;
    //以上是向上转型，若调用p1、p2的方法会调用子类a、b的方法，如下：
    
    p1.say();
    p2.say();
    
    Student a2 = (Student)p1;
    Student a3 = (Student)p2;
    //向下转型，需要加括号强制转型，类似变量类型转换；
    //此处将p2（实际上是Nurse）转为Student，后边调用方法时会报错
    a2.say();
    a3.say();
}
image-20210312205907763

疑问：上述的p.say()执行的是父类Person方法还是子类Student方法？

  • 多态应用场景：不需更改原代码（67行，1214行），新增一个类Nurse，便可让p.say()执行新的功能。
image-20210312210248697

8.instanceof使用

  • 作用：

    判断某个对象是否是指定类的实例，则可以使用instanceof关键字

  • 格式：

    实例化对象 instanceof 类 //此操作返回boolean类型的数据

  • 接多态的例子，可用于判断传入类型是否正确：

代码待补充

9.toString

  • 建议重写Object中的toString方法。

    此方法的作用：返回对象的字符串表示形式。

    Object的toString方法， 返回对象的内存地址

例：

代码待补充

快捷键构造toString方法：alt+shift+s

10.equals()

建议重写Object中的equals(Object obj)方法，此方法的作用：指示某个其他对象是否“等于”此对象。

也可快捷的创建alt+shitf+s

重写代码待补充

简化前代码：

image-20210312215308746

11.内部类

用得很少，不是重点，仅大概了解，面试可能会问问题。

  • 概念：将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。

  • 分类：

（1）成员内部类

（2）局部内部类

（3）匿名内部类

（4）静态内部类

  • 成员内部类

特点： 成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）。

当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问 的是成员内部类的成员。如果要访问外部类的同名成员，需要以下面的形式进行访问：

外部类.this.成员变量

外部类.this.成员方法

class Outer { 

 private double x = 0; 

 public Outer(double x) { 

   this.x = x; 

 }

 class Inner { //内部类 

   public void say() { 

     System.out.println("x="+x); 

   } 

 } 

}

外部使用成员内部类

Outter outter = new Outter(); 
Outter.Inner inner = outter.new Inner();
  • 局部内部类

局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或

者该作用域内。

注意:局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰符的。

class Person{ 

public Person() { 

} 

}

class Man{ 

public Man(){ 

}

public People getPerson(){ 

class Student extends People{ //局部内部类 

int age =0; 

}

return new Student(); 

} 

}
  • 匿名内部类

匿名内部类由于没有名字，所以它的创建方式有点儿奇怪。创建格式如下：

new 父类构造器（参数列表）|实现接口（）

{

//匿名内部类的类体部分

}

在这里我们看到使用匿名内部类我们必须要继承一个父类或者实现一个接口，当然也仅能只继承一个父类或者实现一

个接口。同时它也是没有class关键字，这是因为匿名内部类是直接使用new来生成一个对象的引用。当然这个引用是隐

式的。

在使用匿名内部类的过程中，我们需要注意如下几点：

（1）使用匿名内部类时，我们必须是继承一个类或者实现一个接口，但是两者不可兼得，同时也只能继承一个类或

者实现一个接口。

（2）匿名内部类中是不能定义构造函数的。

（3）匿名内部类中不能存在任何的静态成员变量和静态方法。

（4）匿名内部类为局部内部类，所以局部内部类的所有限制同样对匿名内部类生效。

（5）匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。

（6）只能访问final型的局部变量

  • 静态内部类

静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字static。

静态内部类是不需要依赖于外部类对象的，这点和类的静态成员属性有点类似，并且它不能使用外部类的非static成员

变量或者方法.

格式： 

public class Test { 

public static void main(String[] args) { 

Outter.Inner inner = new Outter.Inner(); 

} 

}

class Outter { 

public Outter() { 

}

static class Inner { 

public Inner() { 

} 

} 

}

12.包装类

在Java中有一个设计的原则“一切皆对象”，那么这样一来Java中的一些基本的数据类型，就完全不符合于这种设计思 想，因为Java中的八种基本数据类型并不是引用数据类型，所以Java中为了解决这样的问题，引入了八种基本数据类型的包装类。

image-20210313171036717

分类：

· Number：Integer、Short、Long、Double、Float、Byte都是Number的子类表示是一个数字。

· Object：Character、Boolean都是Object的直接子类。

  • 装箱和拆箱

    将一个基本数据类型变为包装类，那么这样的操作称为装箱操作。

    将一个包装类变为一个基本数据类型，这样的操作称为拆箱操作

装箱操作： 

在JDK1.4之前 ，如果要想装箱，直接使用各个包装类的构造方法即可，例如： 

int temp = 10 ; // 基本数据类型 

Integer x = new Integer(temp) ; // 将基本数据类型变为包装类 

在JDK1.5，Java新增了自动装箱和自动拆箱，而且可以直接通过包装类进行四则运算和自增自建操作。例如： 

Float f = 10.3f ; // 自动装箱 

float x = f ; // 自动拆箱 

System.out.println(f * f) ; // 直接利用包装类完成 

System.out.println(x * x) ; // 直接利用包装类完成
  • 字符串转换
使用包装类还有一个很优秀的地方在于：可以将一个字符串变为指定的基本数据类型，此点一般在接收输入数据上使用较多。 

在Integer类中提供了以下的操作方法： 

public static int parseInt(String s) ：将String变为int型数据 

在Float类中提供了以下的操作方法： 

public static float parseFloat(String s) ：将String变为Float 

在Boolean 类中提供了以下操作方法： 

public static boolean parseBoolean(String s) ：将String变为boolean 

.... 

....

13.可变参数

据需要自动传入任意个数的参数。

语法：

返回值类型 方法名称(数据类型…参数名称){

//参数在方法内部 ， 以数组的形式来接收

}

  • 注意：

可变参数只能出现在参数列表的最后。

例：

public static void main(String[] args){
    System.out.println(sum(1));
    System.out.println(sum(1,2));
    System.out.println(sum(1,2,3));
    System.out.println(sum(1,2,3,4));
}
//int...nums : 表示可变参数，调用时可传递0~n个数字
public static int sum(int...nums){
    int n = 0;
    for(int i=0;i<nums.length;i++){
        n+=nums[i];;
    }
    return n;
}

==========

#异常处理

  • 什么是异常：异常是在程序中导致程序中断运行的一种指令流。

  • IDEA中错误提示方法：在标红位置alt+回车，会显示解决方法，如try-catch、throw等

1.try-catch

  • 处理与不处理的区别

不处理程序会崩溃，出问题的那行代码以后的都不会再执行，机理如下：

图片

处理，则程序在执行try-catch后，继续执行后续指令，见例1：

package com.java.demo1;

import java.util.InputMismatchException;
import java.util.Scanner;

/**
 * 处理多异常的格式 1
 */
public class Demo2 {
    public static void main(String[] args){

        haha();
        System.out.println("程序执行完毕 , 正常结束");//haha()中有异常处理后，后续指令可继续完成
    }

    private static void haha() {
        try {
            Scanner input = new Scanner(System.in);
            System.out.println("请输入一个数字");
            int x = input.nextInt();
            System.out.println("请再输入一个数字");
            int y = input.nextInt();
            System.out.println(x / y);
            System.out.println("处理完毕");
        }catch(InputMismatchException e){
            System.out.println("必须输入数字啊, 帅哥");
        }catch(ArithmeticException e){
            System.out.println("除数不能为0啊 , 帅哥");
        }
    }
}

由上述例子，try-catch格式：

try{
	// 有可能发生异常的代码段 
}catch(异常类型1 对象名1){ 
	// 异常的处理操作 
}catch(异常类型2 对象名2){
	// 异常的处理操作 
} ... 
finally{ 
	// 异常的统一出口 
}

  • catch的异常处理类型，可根据运行报错时红字部分显示的类型获取，能进行try-catch的异常都是包含在Exception类中。

  • 异常体系结构

    异常指的是Exception ， Exception类， 在Java中存在一个父类Throwable（可能的抛出）

    Throwable存在两个子类：

    （1）Error：表示的是错误，是JVM发出的错误操作,只能尽量避免，无法用代码处理。

    （2）Exception：一般表示所有程序中的错误，所以一般在程序中将进行try…catch的处理。

图片2

  • RuntimeException即运行时异常，代码是不会标红线的；而受检异常代码会标红线，必须抛出或try-catch

  • 更常用的异常处理方式：

    上述例1，两种异常的父类都是RuntimeException，可用父类RuntimeException来代替，甚至是Exception父类，这也是多态的一种表现形式，如例2：

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

        haha();
        System.out.println("程序执行完毕 , 正常结束");
    }

    private static void haha() {
        try {
            Scanner input = new Scanner(System.in);
            System.out.println("请输入一个数字");
            int x = input.nextInt();
            System.out.println("请再输入一个数字");
            int y = input.nextInt();
            System.out.println(x / y);
            System.out.println("处理完毕");
        }catch(Exception e){//多态
            System.out.println("输入有误");
        }finally {
            //必然执行的异常统一处理出口
            //无论是否发生异常, finally必然执行.
            System.out.println("213123");
        }
    }
}

2.finally：

在进行异常的处理之后，在异常的处理格式中还有一个finally语句，那么此语句将作为异常的统一出口，不管是否产生 了异常，最终都要执行此段代码。

  • finally一般存放释放内存指令，因为放try或catch块不能确定是否发生异常，能不能执行。

  • finally——面试题高频题

    • finally什么时候执行：

      若程序被关闭了，程序结束（非正常情况，电脑停电、程序关闭等）finally才不执行

    • try-catch-finally 中哪个部分可以省略？

      答： catch和finally可以省略其中一个 ， catch和finally不能同时省略

      注意：格式上允许省略catch块, 但是发生异常时就不会捕获异常了,我们在开发中也不会这样去写代码

    • try-catch-finally 中，如果 catch 中 return 了，finally 还会执行吗？

      答：finally中的代码会执行

      详解：

      执行流程：

      （1）先计算返回值， 并将返回值存储起来， 等待返回

      （2） 执行finally代码块

      （3）将之前存储的返回值， 返回出去；

      需注意：

      （1）返回值是在finally运算之前就确定了，并且缓存了，不管finally对该值做任何的改变，返回的值都不会改变；

      （2）finally代码中不建议包含return，因为程序会在上述的流程中提前退出，也就是说返回的值不是try或 catch中的值，若finally中也包含赋值语句，是否改变返回值要看数据类型，见下一部分单独说明；

      （3）如果在try或catch中停止了JVM,则finally不会执行.例如停电- -, 或通过如下代码退出JVM：System.exit(0)。

  • 基本数据类型与引用数据类型

    基本数据类型：如语句int a = 10，栈中存储的是指本身，然后return拷贝了一份值，finally改变的是拷贝前的值，最后返回值是拷贝值，故finally改不了;

    image-20210317152837123

    引用数据类型：如Person p = new Person()，栈中存的是一个地址，return拷贝的也是地址，finally改变的是这个地址对应的堆内存里的值，也是拷贝的地址指向的值，故最后返回值被finally改变了；

    image-20210317152849356

3.throws

异常是否抛出去, 应该站在哪个角度思考?

如果是因为传参导致异常 , 应该通过throws将异常抛出去

import java.io.IOException;

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

    /**
     * 异常是否抛出去, 应该站在哪个角度思考?
     *
     *  如果是因为传参导致异常 , 应该通过throws将异常抛出去.
     *
     * @param text
     * @throws IOException : 因为传递的指令不对, 会导致此问题发生
     */
    public static void shutdown(String text) throws IOException {
        Runtime.getRuntime().exec(text);//指令只有这一条，不可能是程序的问题，是传入的内容的问题，所以throws出去
    }
    /**
     * 此方法用于求两个参数的和
     *  会将两个参数 转换为数字 求和
     * @param s1  字符串参数1
     * @param s2  字符串参数2
     */
    public static void sum(String s1,String s2){
        int sum = Integer.parseInt(s1)+Integer.parseInt(s2);
        System.out.println("和是:"+sum);
    }
}

4.throw

throw关键字表示在程序中人为的抛出一个异常，因为从异常处理机制来看，所有的异常一旦产生之后，实际上抛出

的就是一个异常类的实例化对象，那么此对象也可以由throw直接抛出。

应用：比如摄入不合法后，比起强制设定一个默认值，用throw抛出更合理些，提醒程序员这里有异常，必须处理（比如再次输入）。

image-20210317152837123

引用数据类型：如Person p = new Person()，栈中存的是一个地址，return拷贝的也是地址，finally改变的是这个地址对应的堆内存里的值，也是拷贝的地址指向的值，故最后返回值被finally改变了；

image-20210317152849356

3.throws

异常是否抛出去, 应该站在哪个角度思考?

如果是因为传参导致异常 , 应该通过throws将异常抛出去

import java.io.IOException;

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

    /**
     * 异常是否抛出去, 应该站在哪个角度思考?
     *
     *  如果是因为传参导致异常 , 应该通过throws将异常抛出去.
     *
     * @param text
     * @throws IOException : 因为传递的指令不对, 会导致此问题发生
     */
    public static void shutdown(String text) throws IOException {
        Runtime.getRuntime().exec(text);//指令只有这一条，不可能是程序的问题，是传入的内容的问题，所以throws出去
    }
    /**
     * 此方法用于求两个参数的和
     *  会将两个参数 转换为数字 求和
     * @param s1  字符串参数1
     * @param s2  字符串参数2
     */
    public static void sum(String s1,String s2){
        int sum = Integer.parseInt(s1)+Integer.parseInt(s2);
        System.out.println("和是:"+sum);
    }
}

4.throw

throw关键字表示在程序中人为的抛出一个异常，因为从异常处理机制来看，所有的异常一旦产生之后，实际上抛出

的就是一个异常类的实例化对象，那么此对象也可以由throw直接抛出。

应用：比如摄入不合法后，比起强制设定一个默认值，用throw抛出更合理些，提醒程序员这里有异常，必须处理（比如再次输入）。

代码： throw new Exception(“抛着玩的。”) ;

Rex_LeiDaDa
关注
Typora 学习笔记（Markdown基础学习）
Oscarzcz的博客
07-22 551
Typora 学习笔记（Markdown基础学习）----狂神说Java 标题： ​ #+空格+内容（#为1级标题，##为2级标题，###为3级标题，一次类推，最多为6级标题） 字体: ​ 斜体 ：星号+内容+星号（*） ​ 粗体: 内容前后各加两个星号（*） ​ 斜体加粗: 内容前后各加三个星号（*） ​ 内容删除线：内容前后各加两个波浪号（~，数字1旁边 shift+此键） 引用： 大于符号（>）加空格 书写内容 分割线： ​ 三个减号回车（-）或者三个星号回车（
typora java代码高亮,Typora的简单使用
weixin_42303795的博客
03-10 2784
Tyora的简单使用说明Typora使用教程Typora官方下载网站：https://typora.io/1.标题一个#号代表一级标题，两个##代表二级标题，依次类推，一共有六级标题。(注意：你的#要与后边写的内容之间留有空格) 2.字体加粗：在文本左右各添加两个星号 (加粗)斜体：在要变为斜体的文本左右各添加一个星号即可。(斜体) 斜体加粗：在要变为斜体的文本左右各添加三个星号即可。(斜体加粗)...
01、java基础语法笔记（需要安装软件包中的typora软件才可以打开这个文件）.md
12-30
01、java基础语法笔记（需要安装软件包中的typora软件才可以打开这个文件）.md
Java学习之Makedown软件学习(Typora)
qq_44969238的博客
09-27 364
Makedown软件学习(Typora) 前言 ​ 学习java前咱们的学会一个记笔记的文件吧，毕竟咱们代码不会，还不会一个做笔记的软件了？装逼一下还是可以的，计算机学生嘛，总不能拿笔头记吧，哈哈，废话不多说，直接来干Typora吧。 一、区块元素 #：标题级别（h1-h6） “>”:标记区块，敲击两下回车键可跳出区块。区块中可以插入表格或者代码 这是一个区块！ 插入一个表格3*4：ctrl+t 二、强调元素 1、*和_表示强调，斜体 我是一个斜
java基础18天Typora笔记
09-04
java初学者——魔乐科技
typora的写java代码_程序员文档编辑神器typora
weixin_29382667的博客
02-26 2162
今天锋哥推荐一款免费的文档编辑神器-typoraTypora 是一款支持实时预览的 Markdown 文本编辑器。它有 OS X、Windows、Linux 三个平台的版本，并且由于仍在测试中，是完全免费的。可读可写Typora给您既是读者又是作家的无缝体验。它删除了预览窗口，模式切换器，降价源代码的语法符号以及所有其他不必要的干扰。相反，它提供了真正的实时预览功能，可帮助您专注于内容本身。简单而...
【java笔记工具typora使用学习】
2301_79666615的博客
12-24 453
2、两边1个星号为斜体：hello word。
java学习（typora简单使用）
qq_34181921的博客
05-01 1017
Markdown学习（一级标题） Typora使用：https://www.typora.io/ 登录网站下载相应系统版本软件。 使用技巧：（二级标题） 标题 1.一级标题的使用 #+空格 +输入一级标题回车 2.二级标题的使用 ##+空格+输入二级标题回车 3.三级标题的使用（四五级标题同最多六级） ###+空格+输入三级标题回车 字体 Hello world！（粗体，字体两边加两星号） Hello world！（斜体，两边各一个星号） Hello world！（斜体..
typora - 程序员快速笔记
12-06
Typora工具可以帮助程序员快速记录笔记，和优快云博客中Markdown编辑器语法一模一样， 日常可以用Typora写博文，然后复制到优快云的Markdown编辑器中，非常方便。 使用详细文档请查看https://blog.youkuaiyun.com/Zjq2Zyh/article/details/80411863
Java基础 学习笔记 Markdownr版
06-27
通过阅读和理解这些笔记，你将能够掌握Java的基本语法、核心概念以及高级特性，为进一步学习Java的框架和技术打下坚实的基础。同时，笔记采用Markdown格式，方便转换为PDF、Word等其他格式，适应不同的阅读和学习...
Java学习笔记.zip
最新发布
11-25
Java学习笔记作为程序员学习和掌握Java技术的重要资料，对于初学者来说是一个宝贵的参考。 在Java学习笔记中，通常会包括以下几个方面的内容。首先，基础语法是学习的起点，它涵盖了变量、数据类型、运算符、控制...
java超强笔记
12-03
接着，笔记将深入讲解Java语法基础。这包括数据类型（如整型、浮点型、字符型和布尔型）、变量、常量、运算符，以及流程控制语句（如if-else、switch、for、while等）。你还将学习到如何使用类、对象和接口，理解...
Typora学习使用笔记
chunzhi5303的博客
02-06 391
Typora学习使用笔记 hello world name age sex 行内代码： //java 这里是行内代码的示例 这里是行内代码System.out.println("Hello world!");的示例。。。 行间代码： //java 这里是行间...
JAVA--Typora
weixin_44529105的博客
05-23 220
Markdown 二级标题 三级标题 四级标题 字体 hello，world hello，world hello，world hello，world 引用 参考xxxx 分割线 图片 超链接 B站 列表 A B C 表格 名字 性别 生日 gmt 男 1997 代码 public
Typora学习笔记
tianjingle
09-18 1268
Typora基本是程序员的日常工作的一种非常实用的工具了吧。其效果还是非常好的。这块我们也系统的学习一下吧。以上是typora相关的一些学习笔记截图。当然作为md文件，一些常见的的标记还是...
Java基础知识笔记
qq_46170664的博客
04-22 1137
之前刚开始学习Java的时候，记录的部分基础知识笔记，此处共享出来，也算是记录一下学习Java的历程。
学习JAVA开发总结01(Markdown，Typora语法操作)
lookfutur的博客
02-16 197
Markdown，Typora语法操作 语法标题 一级标题：#空格(内容) 二级标题：##空格(内容) 三级标题：###空格(内容) 四级标题：####空格(内容) 五级标题：#####空格(内容) 六级标题：######空格(内容) 最多可支持6级标题 字体语法 粗体：内容 两边两个*号 斜体：内容 两边一个*号 斜体加粗：内容 两边三个*号 删除线：内容 两边两个~~号 引用 文...
javaSE笔记
weixin_44478522的博客
07-22 417
视频链接：https://www.bilibili.com/video/BV1Yb411z7PG?spm_id_from=333.337.search-card.all.click
Java基础day01---一、Typora--markdown编辑器的使用以及java基础
weixin_62189092的博客
10-22 1165
1、发展历史1995由sun公司发布，后被甲骨文（oracle）收购，java之父：詹姆斯-高斯林2、版本变迁1.2（Applet[java小程序，开发网页动态效果]，swing[GUI桌面应用]）1.5（Java5）Java7（主流版本）java8（十个新系统）java8是当前最后一个开源免费的jdk版本，java的向下兼容性做的比较好。3、Java的技术结构JavaSE---------标准版 java基础 ***JavaEE---------企业版 ***
宋红康java笔记typora
06-23
### 回答1： 宋红康先生的Java笔记Typora是一份非常有价值的Java学习资料。Typora是一种Markdown编写工具，非常适合于码字和笔记整理。是一款非常支持运用Java的软件。宋红康先生的Java笔记，是以Typora为载体，对Java技术进行深度解析和介绍的学习资料。 宋红康先生的Java笔记Typora，内容丰富，涵盖了JavaSE、JavaEE、Java框架等多方面的知识点。除了传统的类和对象、继承和多态等Java基础语法外，Typora笔记还涉及了Java I/O、异常处理、集合框架、多线程、JDBC等重要的Java应用方面的知识，能够让读者更好地掌握Java编程的技巧。 此外，宋红康先生不仅将Java的技术点进行了详细讲解，还给出了很多实际的代码例子和实战项目，让读者能够更好地理解Java的应用场景和解决问题的方法。同时，宋红康先生的Java笔记Typora还提供了非常全面的Java学习资源，包括经典的Java书籍、Java论坛、Java常用工具等，可供读者深度学习和研究Java技术。 总之，宋红康Java笔记Typora是一份非常有价值的Java学习资料，无论是初学者还是有一定编程经验的程序员都可以从中获得很多启发和帮助。如果你想要快速入门Java编程，那么Typora笔记会是一个非常不错的选择。 ### 回答2： 宋红康java笔记typora是指宋红康在学习Java编程语言的过程中，记录笔记的工具为Typora的事情。Typora是一款轻量级的Markdown编辑器，可以帮助用户快速高效地编辑和排版文档。 宋红康是一位资深的Java程序员，对Java编程语言非常熟悉，他利用Typora这一工具来记录自己的学习笔记。Typora简单易用，支持常用的Markdown语法，让宋红康可以专注于记录自己对Java的理解和加深对Java编程语言的认识。 宋红康的Java笔记包括对Java语法、面向对象编程、Java开发工具、Java Web开发、Java框架、数据库编程等方面的知识点的记录和总结。这些知识点通过Typora的排版功能，呈现出来非常清晰，易于查看和理解。 总之，宋红康java笔记typora是一种高效的学习方式，它不仅可以帮助学习者快速记录和总结知识点，还可以提高学习效率，让学习更加轻松愉快。 ### 回答3： 宋红康Java笔记Typora是一本非常优秀的Java编程入门教材。Typora是一款兼容多种操作系统的软件,它极大地方便了笔记的编辑和共享传递。宋红康Java笔记中的内容相当全面，从Java程序开发的基础语法入手，依次阐述了Java高级程序开发中的各项难点，同时引导读者通过自主练习来深入理解与掌握Java编程技能。 宋红康Java笔记在内容上结构合理、连贯易懂，将Java程序设计的复杂知识点分解为逐步深入的章节内容，每个章节都有相关的练习题来帮助读者巩固所学的知识点。此外，该笔记还提供了详细的代码实例，让读者可以更加清晰的了解Java编程的执行过程，同时加深对程序设计思路的理解。 总之，宋红康Java笔记Typora是一本很好的Java编程入门教材，如果你对Java编程有困惑，又想全面系统地了解Java编程，那么这本笔记一定会给你带来很大的收获。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值