JAVA零基础入门第一阶段（10）

最新推荐文章于 2022-06-05 01:53:14 发布
最新推荐文章于 2022-06-05 01:53:14 发布
阅读量230 收藏
点赞数
分类专栏： JAVA基础 文章标签： java 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48479212/article/details/107027116
版权

1.static关键字

概念

static - 私有的

作用：
1.修饰属性：类属性/类变量/静态变量/静态属性，直接用类名调用
应用场景：状态码（静态常量），后续会碰到
2.修饰方法：类方法/静态方法，直接用类名调
应用场景：工具类，只需要使用类里的具体功能，那就把类视作工具类，类里的方法都是静态方法， 直接用类名调用即可
3.静态代码块：初始化数据
应用场景：初始化该类的静态属性

具体使用
具体使用 - 修饰属性

修饰属性：静态变量/类变量
含义：该类的每个对象都共享的，用类名调用
生命周期：
创建：类加载到方法区时，扫描该类的所有属性，把静态属性加载到静态区中
销毁：项目结束时销毁
应用场景：final + static

public class Test {

	public static void main(String[] args) {

		MyClass m1 = new MyClass();
		MyClass m2 = new MyClass();

		m1.str1 = "成员属性1";
		m2.str1 = "成员属性2";
		System.out.println(m1.str1);
		System.out.println(m2.str1);
		
		//静态属性是该类所有对象共享的，是类属性，所以应该用类名调用
//		m1.str2 = "静态属性1";
//		m2.str2 = "静态属性2";
//		System.out.println(m1.str2);
//		System.out.println(m2.str2);
		
		m1.str2 = "静态属性2";
		System.out.println(MyClass.str2);
	}
}
class MyClass{
	String str1;
	static String str2;
}
具体使用 - 修饰方法

修饰方法：静态方法/类方法
含义：用类名调用
应用场景：工具类

public class Test {

	public static void main(String[] args) {
		int[] is = {1,5,4,2,6};
		int max = MyArrays.getMax(is);
		System.out.println("获取数组中的最大值：" + max);
	}
}
//自定义数组工具类
class MyArrays{
	public static int getMax(int[] is) {
		int max = is[0];
		for (int i = 1; i < is.length; i++) {
			if(max < is[i]){
				max = is[i];
			}
		}
		return max;
	}
}
具体使用 - 静态代码块

调用时机：类（.class文件）加载到方法区时调用

public class Test {

	public static void main(String[] args) {
		for (String name : NameContainer.names) {
			System.out.println(name);
		}
	}
}
//姓名容器类
class NameContainer{
	static String[] names = new String[10];
	static{//初始化静态属性的数据
		names[0] = "吴彦祖";
		names[1] = "彭于晏";
		names[2] = "何翰宇";
	}
}
具体使用 -代码块调用法则
public class Test {

	public static void main(String[] args) {
		
		//输出：静态代码块 -> 代码 -> 构造方法
		MyClass m = new MyClass();
		
		//输出：静态代码块 -> 静态等待
		MyClass.method();
	}
}
class MyClass{
	
	String str1;
	static String str2;
	
	public MyClass() {
		System.out.println("构造方法");
	}
	
	{
		str1 = "aaa";
		System.out.println("代码块 - " + str1);
	}
	
	static{
		str2 = "bbb";
		System.out.println("静态代码 - " + str2);
	}
	
	public static void method() {
		System.out.println("静态方法");
	}
}

代码块调用法则总结：
1.代码块可以初始化属性
2.静态代码块可以初始化静态属性
3.使用该类就会把类的字节码文件(.class文件)加载到方法区中，此时就会调用静态代码块

2.静态变量和成员变量的区别

静态变量：类变量，该类的所有对象共享一份，（JDK1.7 - 存储在静态常量区中 ，JDK1.8 - 堆中）
成员变量：该变量每个对象独享一份，存储在堆内存的对象中

成员变量 与 静态变量 的区别：
1.成员变量该类的对象独享一份，静态变量该类的所有对象共享一份
2.在成员方法中：可以调用成员变量，也可以调用静态变量

3.继承

概念

子类继承父类所有属性和方法
私有化属性和方法不能直接被调用，但是可以间接调用，见 “具体使用”
使用关键字extends继承：class 子类 extends 父类{}

具体使用
public class Test {
	public static void main(String[] args) {
		
		Chinese c = new Chinese();
		c.setChineseId("123...");  //操作子类的属性并调用子类的方法
		c.setName("吴彦祖");		 //操作父类的属性并调用父类的方法
		c.setAge(18);			   //操作父类的属性并调用父类的方法
		System.out.println(c.getChineseId());//操作子类的属性并调用子类的方法
		System.out.println(c.getName()); 	 //操作父类的属性并调用父类的方法
		System.out.println(c.getAge());		 //操作父类的属性并调用父类的方法
		c.playTaiJi();//调用子类的方法
		
		Japanese j = new Japanese();
		j.setJapaneseId("xxx...");//操作子类的属性并调用子类的方法
		j.setName("水菜丽");		 //操作父类的属性并调用父类的方法
		j.setAge(26);			 //操作父类的属性并调用父类的方法
		System.out.println(j.getJapaneseId());//操作子类的属性并调用子类的方法
		System.out.println(j.getName()); 	 //操作父类的属性并调用父类的方法
		System.out.println(j.getAge());		 //操作父类的属性并调用父类的方法
		j.playVideo();//调用子类的方法
	}
}
//父类
class Person{
	private String name;
	private int age;
	
	public Person() {
	}

	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

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

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
}
//子类
class Chinese extends Person{
	
	private String chineseId;//中国人的身份证（子类独有的属性）
	
	//子类独有的方法
	
	public Chinese() {
	}

	public Chinese(String chineseId) {
		this.chineseId = chineseId;
	}

	public String getChineseId() {
		return chineseId;
	}

	public void setChineseId(String chineseId) {
		this.chineseId = chineseId;
	}
	
	public void playTaiJi(){
		System.out.println("中国人：打太极");
	}
	
}
//子类
class Japanese extends Person{
	
	private String japaneseId;//日本人的身份证（子类独有的属性）
	
	//子类独有的方法
	
	public Japanese() {
	}

	public Japanese(String JapaneseId) {
		this.japaneseId = JapaneseId;
	}

	public String getJapaneseId() {
		return japaneseId;
	}

	public void setJapaneseId(String japaneseId) {
		this.japaneseId = japaneseId;
	}
	
	public void playVideo(){
		System.out.println("日本人：拍电影");
	}
}
好处

多个类里有相同的属性和方法就可以抽取出，形成一个共同的父类，减少代码的冗余

继承中的构造方法
public class Test {
	public static void main(String[] args) {
		
		Son son = new Son();
	}
}
class Father{
	public Father() {
		System.out.println("父类无参构造");
	}
}
class Son extends Father{
	public Son() {
		//super();默认调用父类的无参构造
		System.out.println("子类无参构造");
	}
}

继承中的构造方法总结：
创建子类对象会不会调用父类构造方法？
会
创建子类对象调用父类构造方法的目的是什么？
创建子类对象会在堆里开辟空间，调用父类构造方法的目的是在将父类属性拷贝一份存入子类对象中
创建子类对象会创建父类对象吗？
不会
创建子类对象先调用父类构造方法还是子类构造方法？
先调用子类构造方法，子类构造方法中的第一句默认super()，意思是调用父类无参构造
创建子类对象先完成父类构造方法还是子类构造方法？
先完成父类构造方法

4.super关键字

super 父类的，与this的使用类似
作用：
super.属性：调用父类的属性
super.方法：调用父类的方法
super()：根据传参类型调用父类的构造方法

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

		Chinese c = new Chinese("吴彦祖",18,"123...");
		c.playTaiJi();//调用子类的方法

		Japanese j = new Japanese("水菜丽",26,"xxx...");
		j.playVideo();//调用子类的方法
	}
}
//父类
class Person{
	private String name;
	private int age;

	public Person() {
	}

	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

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

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
}
//子类
class Chinese extends Person{

	private String chineseId;

	public Chinese() {
	}

	public Chinese(String name, int age, String chineseId) {
		super(name, age);//调用父类的有参构造
		this.chineseId = chineseId;
	}

	public String getChineseId() {
		return chineseId;
	}

	public void setChineseId(String chineseId) {
		this.chineseId = chineseId;
	}

	public void playTaiJi(){
		//调用父类的方法（间接调用父类的私有化属性）
		System.out.println(super.getName() +  "：打太极");
	}

}
//子类
class Japanese extends Person{

	private String japaneseId;

	public Japanese() {
	}

	public Japanese(String name, int age, String japaneseId) {
		super(name, age);//调用父类的有参构造
		this.japaneseId = japaneseId;
	}

	public String getJapaneseId() {
		return japaneseId;
	}

	public void setJapaneseId(String japaneseId) {
		this.japaneseId = japaneseId;
	}


	public void playVideo(){
		//调用父类的方法（间接调用父类的私有化属性）
		System.out.println(super.getName() +  "：拍电影");
	}
}

5.方法的重写

概念

如果父类里的方法不满足子类需求时，就可以重写

规则

1.在继承关系中的子类里重写
2.返回值、方法名、参数类型必须和父类一致
3.访问修饰符不能比父类更严格

实际运用
public class Test {
	public static void main(String[] args) {

		Student stu1 = new Student("吴彦祖", "班级号6666", "学号001");
		Student stu2 = new Student("吴彦祖", "班级号6666", "学号002");
		
		//调用重写后的equals来比较两个对象是否一致
		System.out.println(stu1.equals(stu2));//false(学号不一样)
		
		//调用重写后的toString输出想要的对象信息
		System.out.println(stu1);//吴彦祖 -- 班级号6666 -- 学号001
		System.out.println(stu2);//吴彦祖 -- 班级号6666 -- 学号002
		
	}
}
class Student{
	
	private String name;
	private String classId;//班级号
	private String id;//学号
	
	public Student() {
	}

	public Student(String name, String classId, String id) {
		this.name = name;
		this.classId = classId;
		this.id = id;
	}

	public String getName() {
		return name;
	}

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

	public String getClassId() {
		return classId;
	}

	public void setClassId(String classId) {
		this.classId = classId;
	}

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}
	
	//重写父类的equals方法，好处：重写以后比较两个Student对象就是比较的是两个对象的班级号和学号
	@Override
	public boolean equals(Object obj) {
		Student stu = (Student) obj;//下转型
		if(this.classId.equals(stu.classId) 
				&& this.id.equals(stu.id)){
			return true;
		}
		return false;
	}
	
	//重写父类的toString方法，好处：输出Student对象，就可以获取该对象的属性信息
	@Override
	public String toString() {
		return name + " -- " + classId + " -- " + id;
	}
}

6.访问修饰符

访问修饰符：决定了属性和方法的权限

做实验证明访问权限

关键字访问权限
private本类
默认（什么都不写）本类、相同包下
protected本类、相同包下、子类同包
public全局

一锅老鸭汤
关注
专栏目录
java零基础从入门到精通（全）
码农研究僧的博客
07-18 4万+
目录前言1. 入门知识1.1 java体系1.2 JDK/JRE/JVM区别1.3 编译与运行理解1.4 类体函数细节2. 标识符 前言 java优势 健壮性（JVM（C++语言写的一个虚拟的计算机）、GC（垃圾回收机制）） 多线程并发 可移植性/跨平台 1. 入门知识 1.1 java体系 JavaSE：标准版 JavaEE：企业版 JavaME：微型版 1.2 JDK/JRE/JVM区别 JVM是不能独立安装的。 JRE和JDK都是可以独立安装的 层层嵌套，jvm包括jdk，jdk包括jre
JAVA零基础入门第一阶段（4）
一锅老鸭汤的博客
06-18 842
一．if分支 1.复杂if分支 ①案例 案例一： 人类的健康值在20-25的数值内为健康 （健康值算法为：体重（Kg） / 身高（米）的平方） 分析： 1.输入体重和身高 2.计算出健康值 3.判断 Scanner scan = new Scanner(System.in); System.out.println("请输入体重（Kg）："); double weight = scan.
传智播客Java就业班入学测试题答案解析【Java面试复习经典】
句柄在哪里
11-22 1万+
传智播客java就业班入学测试题解析（每天更新10道题。。。。） 共50道题，每道题2分，总分100分，80分为合格。 (很不幸，在追逐速度的时候，基础不牢实，分数很低啊76分错了13道，建议大家先去现在做一遍，你们可以独立的做一下检验一下se的基础的基础的基础的基础的水平： http://www.itcast.cn/news/e181c4f9/8ec4/4bba/9a1f/3f3097e9
Java中super关键字及super()的使用
m0_67401055的博客
06-05 6255
Java中super关键字及super()的使用：1、super的使用：（1）super是一个关键字。（2）super和this很类似，我们对比着学习。2、先复习一下this关键字的使用。（1）this能出现在实例方法和构造方法中； （2）this的语法是“this.”和“this()”； （3）this不能出现在静态方法中； （4）this大部分情况下是可以省略的； （5）this.什么时候不能省略呢？ 在区分局部变量和实例变量时不能省略。例如： （6）this()只能出现在构造方法的第一行，通过当前的构
super的实现 java_java中如何使用super
weixin_42577735的博客
03-02 955
在java编程中很多用户们都会不知道使用super的方法，那么今天我们就带着疑问一起去看看java中如何使用super的内容吧。昨天写this用法总结的时候，突然产生了一个问题，请教别人之后，有了自己的一点认识。还是把它写下来，为大家更好的认识提供一点思路。1)有人写了个很好的初始化属性的构造函数，而你仅仅想要在其中添加另一些自己新建属性的初始化，这样在一个构造函数中调用另外一个构造函数，可以避免...
Java中super详解
热门推荐
weixin_44722237的博客
05-13 1万+
目录 Java中super详解 super的作用： 1. 通过super可以访问父类的构造方法 2. 通过super可以访问父类的属性（非私有） 3. 通过super可以访问父类的方法（非私有的方法） Java中super详解 在说super之前先说一下Java中的继承，继承是Java中面向对象编程技术的重要基石，因为它允许创建分等级层次的类。继承就是子类继承父类的行为和特征，就是方法和属性。私有的属性和方法子类是能继承的，但是子类无法直接调用，调用父类的私有属性需...
super详解(java)
weixin_45842954的博客
03-31 2068
继承 继承的本质是对某一批类的抽象,从而实现对现实世界更好的建模。 extends的意思是“扩展”。子类是父类的扩展。 2.JAVA中类只有单继承,没有多继承! 继承是类和类之间的一种关系。除此之外类和类之间的关系还有依赖、组合、聚合等。 3.继承关系的俩个类,一个为子类(派生类)一个为父类(基类)。子类继承父类使用关键字 extends来表 4.子类和父类之间从意义上讲应该具有isa"的关系 object类 super this 创建父类、子类，子类中继承父类的所有方法 1.main函数 pu
JAVA零基础入门第一阶段（7）
一锅老鸭汤的博客
06-23 4357
一.数组的说明 1.数组含义 存储多个数据的集合 2.相关概念 元素：数组里的数据 下标/索引：每个数据对应的编号，从0开始 3.数组的声明 数据类型[] 数组名; 二.数组的初始化 1.静态初始化 ①静态初始化 初始化数组时，元素由程序员指定，长度由系统根据元素个数开辟内存空间 ②初始化类型 //静态初始化1 String[] names = new String[]{“麻生希”,“水野朝阳”,“爱田奈奈”,“京香Juila”,“明日花绮罗”}; //静态初始化2:先声明，再初始化 String[]
JAVA零基础入门第一阶段（11）
一锅老鸭汤的博客
06-29 203
1.Object类 概念及常用方法 所有类的祖先类/超类/基类，一个类没有明确继承某个父类，均自动继承Object Object作为祖先类，起着类的标杆的作用 方法 描述 equals(Object obj) 比较两个对象是否一致 hashCode() 返回该对象的hash值 getClass() 返回该类的字节码文件对象 toString() 返回该对象的字符串表示 方法演示 public class Test { public static void main(Stri
Java 基础 第1阶段：基本语法-尚硅谷学习笔记（含面试题） 2023年
最新发布
05-09
2023年的"Java 基础 第1阶段：基本语法——尚硅谷学习笔记（含面试题）"涵盖了从环境搭建到程序设计的基本要素，旨在帮助学习者系统地理解并应用Java语言。 一、Java环境搭建 在开始Java编程之前，你需要安装Java ...
Java桌面游戏巡礼——国外Java游戏合集（第一回）
【Java究竟怎么玩?】
05-21 1万+
<! /* Style Definitions */ table.MsoNormalTable {mso-style-name:普通表格; mso-tstyle-rowband-size:0; mso-tstyle-colband-size:0; mso-style-noshow:yes; mso-style-parent:""; mso-padding-al
java Super详解
m0_61857489的博客
01-26 1112
super在方法上也是可以同理使用的
JAVA 泛型
zhangyonzhi的专栏
07-14 121
 在Java SE1.5中，增加了一个新的特性：泛型（日本语中的总称型）。何谓泛型呢？通俗的说，就是泛泛的指定对象所操作的类型，而不像常规方式一样使用某种固定的类型去指定。泛型的本质就是将所操作的数据类型参数化，也就是说，该数据类型被指定为一个参数。这种参数类型可以使用在类、接口以及方法定义中。   一、                       为什么使用泛型呢？      在以往的J2...
001之Java入门之Java基础
weixin_39455643的博客
01-30 389
0-35,java development kit/java runtime environment/jvm; javac编译,Java运行。 源文件xxx.java编译多个xxx.class字节码可以被jvm识别。 0-36,如何让JAVA命令运行,把命令写进环境变量让找path。 path作用:为Windows找命令指路。 classpath是为类加载器指路的。 环境变量:分为用户和系统环境变量, 0-51,public class 和class的区别：
java private super_java中super 的两种用法
weixin_32487557的博客
02-13 499
通过用static来定义方法或成员，为我们编程提供了某种便利，从某种程度上可以说它类似于C语言中的全局函数和全局变量。但是，并不是说有了这种便利，你便可以随处使用，如果那样的话，你便需要认真考虑一下自己是否在用面向对象的思想编程，自己的程序是否是面向对象的。好了，现在开始讨论this&super这两个关键字的意义和用法。在Java中，this通常指当前对象，super则指父类的。当你想要引...
Java super详解
weixin_45857066的博客
01-25 333
Java继承——super详解 可以与this进行对比 //Person类，父类 public class Person { protected String name = "szc"; } //学生is人，子类，继承父类Person public class Student extends Person { private String name = "Hust"; public void test(String name){ System.out.printl
java中super
weixin_45735044的博客
12-09 772
super方法必须是在构造方法的第一条命令，普通方法中不能使用super方法。 创建对象时当类中，所有构造方法都没有时，此时会调用父类的无参数构造方法构造对象。 子类无参数构造方法时，不用显式调用父类无参数构造方法，系统会自动提供。 默认不含super时自动调用不带参super，意味着父类中必须要有不带参数的构造方法，除非子类使用带参数super。 调用父类的构造方法，一定要放在方法的第一行。 this()和super()都只能出现在构造方法的第一行，故this()和super()方法不能共存，当一个类的.
JavaSE--------------基础知识点20（JDK1.8的新特性）
榮十一的博客
08-22 218
JDK1.8新特性 JDK1.8新特性简介 速度更快 - 优化底层源码，比如HashMap、ConcurrentHashMap 代码更少 - 添加新的语法Lambda表达式 强大的Stream API 便于并行 最大化减少空指针异常 - Optional Lambda表达式 简介 Lambda是一个匿名函数(方法)， 允许把函数作为一个方法的参数 。利用Lambda表达式可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。一般都是优化匿名内部类 基础语法
Java基础知识入门：从零开始的编程之旅
"该课程是针对零基础学员的JAVA基础知识学习，旨在教授Java开发环境的使用，编程入门，以及核心概念。课程涵盖了标示符、关键字、数据类型、表达式和流程控制的基本知识，深入讲解数组，常用数据结构和算法，重点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值