Java从入门到入土第10天

已于 2024-05-08 10:01:50 修改
阅读量254 收藏
点赞数
分类专栏： java入门到入土 文章标签： java python 前端
于 2024-05-08 10:00:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiao_yin0/article/details/138560892
版权

Day10

package com.qf.work;

public class Elephant {

	private String name;
	private String type;
	
	public Elephant() {
	}

	public Elephant(String name, String type) {
		this.name = name;
		this.type = type;
	}

	public String getName() {
		return name;
	}

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

	public String getType() {
		return type;
	}

	public void setType(String type) {
		this.type = type;
	}
	
	public void eat(){
		System.out.println(this.name + "吃香蕉");
	}
	
	public void shout(){
		System.out.println(this.name + "叫：嗷嗷嗷~~~");
	}
}


package com.qf.work;

public class Person {

	private String name;
	private char sex;
	private int age;
	
	public Person() {
	}

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

	public String getName() {
		return name;
	}

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

	public char getSex() {
		return sex;
	}

	public void setSex(char sex) {
		this.sex = sex;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
	
	public void openRefrigerator(Refrigerator r){
		r.open();
	}
	
	public void closeRefrigerator(Refrigerator r){
		r.close();
	}
	
	public void loadElephant(Elephant e,Refrigerator r){
		r.load(e);
	}
}



package com.qf.work;

public class Refrigerator {

	private String brand;
	private double price;
	private double capacity;
	
	public Refrigerator() {
	}

	public Refrigerator(String brand, double price, double capacity) {
		this.brand = brand;
		this.price = price;
		this.capacity = capacity;
	}

	public String getBrand() {
		return brand;
	}

	public void setBrand(String brand) {
		this.brand = brand;
	}

	public double getPrice() {
		return price;
	}

	public void setPrice(double price) {
		this.price = price;
	}

	public double getCapacity() {
		return capacity;
	}

	public void setCapacity(double capacity) {
		this.capacity = capacity;
	}
	
	public void open(){
		System.out.println(this.brand + "品牌的冰箱门开");
	}
	
	public void close(){
		System.out.println(this.brand + "品牌的冰箱门关");
	}
	
	public void load(Elephant e){
		e.eat();
		e.shout();
		System.out.println(this.brand + "品牌的冰箱装" + e.getName());
	}
}


package com.qf.work;

public class Test01 {
	/**
	 * 作业：小明把大象装进冰箱
	 * 分析：
	 * 		大象类（属性：姓名、种类			方法：吃、叫）
	 * 		冰箱类（属性：品牌、价格、容量	方法：开冰箱、关冰箱、装大象）
	 * 		人类（属性：姓名、性别、年龄		方法：开冰箱、关冰箱、装大象）
	 */
	public static void main(String[] args) {
		
		Elephant e = new Elephant("小飞象", "亚洲象");
		Refrigerator r = new Refrigerator("华为", 8888, 10000);
		Person p = new Person("小明", '男', 3);
		
		p.openRefrigerator(r);
		p.loadElephant(e, r);
		p.closeRefrigerator(r);
	}
}


package com.qf.test01;

public class Person {

	String name;
	char sex;
	int age;
	
	public void eat(){
		System.out.println(this.name + "吃饭饭");
	}
	
	public void sleep(){
		System.out.println(this.name + "睡觉觉");
	}
}


package com.qf.test01;

public class Chinese extends Person{
	
	String id;
	
	public void playTaiJi(){
		System.out.println("打太极");
	}

}


package com.qf.test01;

public class Japanese extends Person{

	String yearNum;
	
	public void playVedio(){
		System.out.println("拍电影");
	}
}


package com.qf.test01;

public class Test01 {
	/**
	 * 知识点：继承的使用
	 * 概念：子类继承父类所有的属性和方法
	 * 应用场景：将子类相同的属性和方法抽取出，放在父类里
	 * 
	 * 继承优缺点：
	 * 		优点：解决了代码的冗余
	 * 		缺点：增加了类与类之间的关联性、提高维护成本
	 * 
	 * 需求：编写中国人和日本人的类
	 * 分析：
	 * 		人类：
	 * 			属性：姓名、性别、年龄
	 * 			方法：吃饭饭、睡觉觉
	 * 
	 * 		中国人类 继承 人类：
	 * 			属性：身份证
	 * 			方法：打太极
	 * 
	 * 		日本人类 继承 人类：
	 * 			属性：年号
	 * 			方法：拍电影
	 */
	public static void main(String[] args) {
		
		Chinese c = new Chinese();
		
		//操作父类属性
		c.name = "侯小康";
		c.sex = '男';
		c.age = 23;
		System.out.println(c.name);
		System.out.println(c.sex);
		System.out.println(c.age);
		//操作子类属性
		c.id = "12345678901";
		System.out.println(c.id);
		//调用父类方法
		c.eat();
		c.sleep();
		//调用子类方法
		c.playTaiJi();
		
		System.out.println("------------------------------");
		
		Japanese j = new Japanese();
		
		//操作父类属性
		j.name = "波多野结衣";
		j.sex = '女';
		j.age = 18;
		System.out.println(j.name);
		System.out.println(j.sex);
		System.out.println(j.age);
		//操作子类属性
		j.yearNum = "令和";
		System.out.println(j.yearNum);
		//调用父类方法
		j.eat();
		j.sleep();
		//调用子类方法
		j.playVedio();
	}
}


package com.qf.test02;

public class Father {
	
	private String attr = "父类私有化属性";
	
	String str = "父类属性";

	public Father() {
		System.out.println("父类的构造方法");
	}
	
	
	private void method01(){
		System.out.println("父类私有化方法");
	}
	
	public void method02(){
		System.out.println(attr);
		method01();
	}
}


package com.qf.test02;

public class Son extends Father{
	
	String str = "子类属性";

	public Son() {
		super();//默认实现：调用父类的无参构造
		System.out.println("子类的构造方法");
	}
}


package com.qf.test02;

public class Test01 {
	/**
	 * 知识点：继承的深入
	 * 
	 * 1.创建子类对象，会调用父类构造方法吗？
	 * 		会
	 * 
	 * 2.创建子类对象，先调用子类构造方法还是先调用父类构造方法？
	 * 		先调用子类构造方法
	 * 
	 * 3.创建子类对象，调用父类构造方法的目的是什么？
	 * 		在子类对象中开辟空间，用于存放父类的成员属性
	 * 
	 * 4.创建子类对象，先完成子类构造方法还是先完成父类构造方法？
	 * 		先完成父类构造方法
	 * 
	 * 5.子类是否可以继承父类私有化的属性和方法？
	 * 		Oracle官方解释子类不能继承父类私有化属性和方法
	 * 		但是，在使用中，
	 * 		子类不能直接调用父类私有化属性和方法，可以间接调用（调用父类公有的方法，公有的方法里调用私有的属性和方法）
	 * 		
	 */
	public static void main(String[] args) {
		
		Son son = new Son();
		
		son.method02();
		
		System.out.println(son.str);//子类属性
	}
}


package com.qf.test03;

public class Chinese extends Person{
	
	private String id;
	
	public Chinese() {
	}
	
	public Chinese(String name, char sex, int age, String id) {
		super(name, sex, age);
		this.id = id;
	}

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public void playTaiJi(){
		System.out.println(super.getName() + "打太极");
	}

}


package com.qf.test03;

public class Japanese extends Person{

	private String yearNum;
	
	public Japanese() {
	}
	
	public Japanese(String name, char sex, int age, String yearNum) {
		super(name, sex, age);
		this.yearNum = yearNum;
	}

	public String getYearNum() {
		return yearNum;
	}

	public void setYearNum(String yearNum) {
		this.yearNum = yearNum;
	}

	public void playVedio(){
		System.out.println(super.getName() + "拍电影");
	}
}


package com.qf.test03;

public class Person {

	private String name;
	private char sex;
	private int age;
	
	public Person() {
	}
	
	public Person(String name, char sex, int age) {
		this.name = name;
		this.sex = sex;
		this.age = age;
	}
	
	public String getName() {
		return name;
	}

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

	public char getSex() {
		return sex;
	}

	public void setSex(char sex) {
		this.sex = sex;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public void eat(){
		System.out.println(this.name + "吃饭饭");
	}
	
	public void sleep(){
		System.out.println(this.name + "睡觉觉");
	}
}


package com.qf.test03;

public class Test01 {
	/**
	 * 知识点：super
	 * 		super.属性：在子类中，调用父类非私有化的成员属性
	 * 		super.方法：在子类中，调用父类非私有化的成员方法
	 *		super()：在子类构造方法中调用父类非私有的构造方法
	 * 
	 * 需求：编写中国人和日本人的类
	 * 分析：
	 * 		人类：
	 * 			属性：姓名、性别、年龄
	 * 			方法：吃饭饭、睡觉觉
	 * 
	 * 		中国人类 继承 人类：
	 * 			属性：身份证
	 * 			方法：打太极
	 * 
	 * 		日本人类 继承 人类：
	 * 			属性：年号
	 * 			方法：拍电影
	 */
	public static void main(String[] args) {
		
		Chinese c = new Chinese("侯小康", '男', 23, "12345678901");
		
		c.eat();
		c.sleep();
		c.playTaiJi();
		
		System.out.println("------------------------------");
		
		Japanese j = new Japanese("波多野结衣", '女', 18, "令和");
		
		j.eat();
		j.sleep();
		j.playVedio();
	}
}


package com.qf.test04;

public class Chinese extends Person{
	
	private String id;
	
	public Chinese() {
	}
	
	public Chinese(String name, char sex, int age, String id) {
		super(name, sex, age);
		this.id = id;
	}

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public void playTaiJi(){
		System.out.println(super.getName() + "打太极");
	}
	
	@Override
	public void eat(){
		System.out.println(super.getName() + "吃山珍海味");
	}

}


package com.qf.test04;

public class Japanese extends Person{

	private String yearNum;
	
	public Japanese() {
	}
	
	public Japanese(String name, char sex, int age, String yearNum) {
		super(name, sex, age);
		this.yearNum = yearNum;
	}

	public String getYearNum() {
		return yearNum;
	}

	public void setYearNum(String yearNum) {
		this.yearNum = yearNum;
	}

	public void playVedio(){
		System.out.println(super.getName() + "拍电影");
	}
	
	//@Override -- 重写的注解
	//注释：给程序员解释代码信息
	//注解：给程序员和程序解释代码信息
	@Override
	public void eat() {
		System.out.println(super.getName() + "吃马赛克");
	}
}


package com.qf.test04;

public class Person {

	private String name;
	private char sex;
	private int age;
	
	public Person() {
	}
	
	public Person(String name, char sex, int age) {
		this.name = name;
		this.sex = sex;
		this.age = age;
	}
	
	public String getName() {
		return name;
	}

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

	public char getSex() {
		return sex;
	}

	public void setSex(char sex) {
		this.sex = sex;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public void eat(){
		System.out.println(this.name + "吃饭饭");
	}
	
	public void sleep(){
		System.out.println(this.name + "睡觉觉");
	}
}


package com.qf.test04;

public class Test01 {
	/**
	 * 知识点：方法的重写/复写
	 * 理解：在子类中将父类的方法重新写一遍
	 * 条件：
	 * 		1.在子类中重写父类的方法
	 * 		2.返回值类型、方法名、参数列表必须和父类重写的方法一模一样
	 * 		3.访问修饰符不能被父类重写的方法更严格
	 * 
	 * 应用场景：父类方法不能被改变时，父类方法又不满足子类需求，就可以在子类中重写
	 * 
	 * 需求：编写中国人和日本人的类
	 * 分析：
	 * 		人类：
	 * 			属性：姓名、性别、年龄
	 * 			方法：吃饭饭、睡觉觉
	 * 
	 * 		中国人类 继承 人类：
	 * 			属性：身份证
	 * 			方法：打太极
	 * 
	 * 		日本人类 继承 人类：
	 * 			属性：年号
	 * 			方法：拍电影
	 */
	public static void main(String[] args) {
		
		Chinese c = new Chinese("侯小康", '男', 23, "12345678901");
		
		c.eat();//调用子类重写后的方法
		c.sleep();
		c.playTaiJi();
		
		System.out.println("------------------------------");
		
		Japanese j = new Japanese("波多野结衣", '女', 18, "令和");
		
		j.eat();//调用子类重写后的方法
		j.sleep();
		j.playVedio();
		
	}
}


package com.qf.test05;

public class A {

	public String str = "A类的属性";
	
	public void method(){
		System.out.println(str);
	}
}


package com.qf.test05;

public class Test01 {
	/**
	 * 知识点：访问修饰符
	 * 理解：给类、属性、方法设置权限
	 * 分类：private（私有的）、默认的、protected（受保护的）、public（公有的）
	 * 注意：类上只能使用默认和public
	 * 				
	 * 				类中			本包中		其他包的子类 		其他包		
	 * private		ok
	 * 默认的		ok			ok
	 * protected	ok			ok			ok
	 * public		ok			ok			ok				ok
	 * 
	 * 经验：
	 * 		1.属性没有特殊要求，就使用private修饰
	 * 		2.属性如果要给子类使用，就使用protected修饰
	 * 		3.方法如果要给子类重写，就使用protected修饰
	 * 		4.方法没有特殊要求，就使用public修饰
	 */
	public static void main(String[] args) {
		
		A a = new A();
		System.out.println(a.str);
	}
}


package com.qf.test06;

import com.qf.test05.A;

public class B extends A{

	public void xxx(){
		System.out.println(super.str);
	}
}


package com.qf.test06;

import com.qf.test05.A;

public class Test01 {
	/**
	 * 知识点：访问修饰符做实验的代码
	 */

	public static void main(String[] args) {
		
		A a = new A();
		System.out.println(a.str);
	}
}


package com.qf.test07;

public class Test01 {
	/**
	 * 知识点：了解Object类
	 * 概念：该类是所有类的基类/超类
	 * 理解：如果一个类没有明确继承的父类，都默认继承Object
	 * 
	 * equals()：比较两个对象的内存地址是否相同
	 * getClass()：
	 * hashCode()：
	 * toString()：
	 */
	
	public static void main(String[] args) {
		
		Object obj1 = new Object();//0x001
		Object obj2 = new Object();//0x002
		
		System.out.println(obj1 == obj2);//false
		
		System.out.println(obj1.equals(obj2));
		/**
		 * Object类的equals底层源码：
		 * 		public boolean equals(Object obj){
		 * 			//	   0x001== 0x002
		 * 			return this == obj;
		 * 		}
		 */
		
	}
	
}


package com.qf.test07;

import java.lang.reflect.Field;

import com.qf.test04.Chinese;

public class Test02 {
	/**
	 * 知识点：了解Object类
	 * 概念：该类是所有类的基类/超类
	 * 理解：如果一个类没有明确继承的父类，都默认继承Object
	 * 
	 * equals()：比较两个对象的内存地址是否相同
	 * getClass()：获取该类的class对象
	 * hashCode()：
	 * toString()：
	 */
	
	public static void main(String[] args) {
		
		Object obj1 = new Object();//0x001
		Object obj2 = new Object();//0x002
		
		Class<? extends Object> class1 = obj1.getClass();//获取Object类的class对象
		Class<? extends Object> class2 = obj2.getClass();//获取Object类的class对象
		
		System.out.println(class1 == class2);//true
		
		System.out.println("-----------------------------------");
		
		//扩展：获取到类的class对象后，可以对该类进行任何的操作
		
		Chinese chinese = new Chinese();
		
		Class<? extends Chinese> class3 = chinese.getClass();//获取Chinese的class对象
		
		//获取该类及其父类所有的属性对象
		for(Class<?> c = class3;c !=null;c = c.getSuperclass()){
			Field[] fields = c.getDeclaredFields();
			for (Field field : fields) {
				System.out.println(field);
			}
		}
		
		
		
	}
	
}


package com.qf.test07;

public class Test03 {
	/**
	 * 知识点：了解Object类
	 * 概念：该类是所有类的基类/超类
	 * 理解：如果一个类没有明确继承的父类，都默认继承Object
	 * 
	 * equals()：比较两个对象的内存地址是否相同
	 * getClass()：获取该类的class对象
	 * hashCode()：获取对象的hash值（hash值不等于内存地址，hash值是内存地址+散列算法算出来的一个数字）
	 * toString()：
	 */
	
	public static void main(String[] args) {
		
		Object obj1 = new Object();//0x001
		Object obj2 = new Object();//0x002
		
		System.out.println(obj1.hashCode());//366712642
		System.out.println(obj2.hashCode());//1829164700
		
		
	}
	
}


package com.qf.test07;

public class Test04 {
	/**
	 * 知识点：了解Object类
	 * 概念：该类是所有类的基类/超类
	 * 理解：如果一个类没有明确继承的父类，都默认继承Object
	 * 
	 * equals()：比较两个对象的内存地址是否相同
	 * getClass()：获取该类的class对象
	 * hashCode()：获取对象的hash值（hash值不等于内存地址，hash值是内存地址+散列算法算出来的一个数字）
	 * toString()：获取对象的字符串形式
	 */
	
	public static void main(String[] args) {
		
		Object obj = new Object();//0x001
		
		//java.lang.Object@15db9742
		System.out.println(obj);//默认调用toString()
		System.out.println(obj.toString());
		
		/**
		 * Object类的toString()底层源码：
		 * 		public String toString(){
		 * 			//Integer.toHexString(hashCode()); - 获取对象hash值的十六进制表示
		 * 			//     java.lang.Object		   @	15db9742
		 * 			return getClass().getName() + "@" + Integer.toHexString(hashCode());
		 * 		}
		 */
		
	}
	
}


package com.qf.test08;

public class Test01 {
	/**
	 * 知识点：深入Object类
	 * 
	 * equals()：比较两个对象是否一样，但是不同的子类有不同的比较规则，所以子类重写即可
	 * toString：获取对象的字符串表示，但是不同的子类有不同的属性，所以子类重写即可
	 * 
	 * getClass()：在反射的技术点里深入
	 * hashCode()：在集合的技术点里深入
	 */
	public static void main(String[] args) {
		
		User user1 = new User("1445584980", "123123", "千锋彭于晏");//0x001
		User user2 = new User("1445584980", "123456", "千锋吴彦祖");//0x002
		
		System.out.println(user1.equals(user2));//true
		
		System.out.println(user1.toString());
		System.out.println(user2.toString());
	}
}


package com.qf.test08;

public class User {

	private String username;
	private String password;
	private String nickName;
	
	public User() {
	}

	public User(String username, String password, String nickName) {
		this.username = username;
		this.password = password;
		this.nickName = nickName;
	}

	public String getUsername() {
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

	public String getNickName() {
		return nickName;
	}

	public void setNickName(String nickName) {
		this.nickName = nickName;
	}
	
	@Override
	public boolean equals(Object obj) {
		
		if(this == obj){
			return true;
		}
		
		User user = (User) obj;
		
		if(this.username.equals(user.username)){
			return true;
		}
		return false;
	}
	
	@Override
	public String toString() {
		return this.username + " -- " + this.password + " -- " + this.nickName;
	}
}


package com.qf.test09;

public class MyString {

	private char[] value;
	
	public MyString(String original) {
		value = original.toCharArray();//将字符串转换为字符数组
	}
	
	@Override
	public boolean equals(Object obj) {
		if(this == obj){
			return true;
		}
		
		MyString m = (MyString) obj;
		
		char[] v1 = this.value;
		char[] v2 = m.value;
		
		int len = v1.length;
		if(len != v2.length){
			return false;
		}
		
		for (int i = 0; i < len; i++) {
			if(v1[i] != v2[i]){
				return false;
			}
		}
		
		return true;
	}
	
	@Override
	public String toString() {
		String str = "";
		for (char c : value) {
			str += c;
		}
		return str;
	}
}


package com.qf.test09;

public class Test01 {
	/**
	 * 知识点：扩展String底层原理
	 * 
	 * 
	 */
	public static void main(String[] args) {
		
		String str1 = new String("abc");//0x001
		String str2 = new String("abc");//0x002
		
		System.out.println(str1 == str2);//false
		System.out.println(str1.equals(str2));//true
		
		System.out.println(str1);//abc
		System.out.println(str2);//abc
		
		System.out.println("--------------------------------");
		
		//"abc" --> ['a','b','c']
		//"abc" --> ['a','b','c']
		
		MyString m1 = new MyString("abc");
		MyString m2 = new MyString("abc");
	
		System.out.println(m1 == m2);//false
		System.out.println(m1.equals(m2));//true
		
		System.out.println(m1);//abc
		System.out.println(m2);//abc
	}
}


package com.qf.test10;

//该类不能被继承
//public final class Father {
public class Father {
	
	//该方法不能被重写
	//public final void method(){}
	public void method(){}

}


package com.qf.test10;

public class Son extends Father{

	@Override
	public void method() {
		
		//该变量变成常量
		final int I = 100;
		System.out.println(I);
	}
}


package com.qf.test10;

public class Test01 {
	/**
	 * 知识点：final -- 最终
	 * 
	 * 修饰类：该类不能被继承
	 * 修饰方法：该方法不能被重写
	 * 修饰变量：该变量变成常量
	 */
	public static void main(String[] args) {
		
		
		
	}
}
奇怪的魔法猫娘
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java学习路线从入门到入土
qq_45077173的博客
09-20 1万+
Java学习路线从入门到入土 简介 一门永不过时的编程语言——Java 编程开发。Java编程语言占比：据官方数据统计，在全球编程语言工程师的数量上，Java编程语言以900万的程序员数量位居首位。 而且很多软件的开发都离不开Java编程，因此其程序员的数量最多。而在以Java编程为核心的开发领域中，javaEE程序员的需求量10年来一直居于首位！Java工程师人才缺口：根据IDC的统计数字：就2017年来说，我国Java人才的缺口已达42.5万，并且以每年20%左右 的速度增长。在未来5年内,合格软件人才
java从入门到入土第1天
xiao_yin0的博客
04-22 634
JavaEE：就是服务端，接受来自客户端(前端)的请求，利用响应返回给客户端数据的技术目的：做饭工具：锅碗瓢盆环境：厨房目的：编写Java程序工具：JDK（Java开发工具包）环境：JRE（Java运行时环境）前言：上课时间、上课规矩、学习方法软件开发基础Java环境搭建：安装JDK和JRE，环境变量适配(JAVA_HOME、Path)编写第一个Java程序。
java从入门到入土第2天
xiao_yin0的博客
04-23 820
理解：IDE（编码环境），就是写代码的工具升级：记事本 -> nodepad++ -> eclipse -> IDEAIDE - 编码环境编码问题关键字及关键字变量及注意事项基本数据类型（byte、short、int、long、float、double、char、boolean）基本数据类型的转型。
java从入门到入土第4天
xiao_yin0的博客
04-25 366
6.预习：while、do-while、特殊的流程控制语句。1.转义字符：具有特殊意义的字符本身。数字字面量、字面值常量、final。5.复习：运算符的面试题、特殊点。3.Java执行语句的分类。1.知识点的梳理文档s。5.switch分支。
java从入门到入土第5天
xiao_yin0的博客
04-26 689
6.提升作业：分别使用for循环、while循环实现。5.预习：方法、数组、面向对象。1.嵌套for循环 – 重要。3.do-while循环。5.特殊的流程控制语句。4.复习：本周所有内容。6.万年历 – 重要。1.知识点的梳理文档。
java从入门到入土第3天
xiao_yin0的博客
04-24 545
1.算数运算符（+、-、*、/、%、++、–）注意：特殊点和面试题2.赋值运算符（=、+=、-=、*=、/=、%=）注意：复合赋值的底层公式3.关系运算符（==、!注意：关系运算符的结果都是boolean类型的值4.字符串拼接符（+）5.Scanner类注意：感受面相对象的思想6.逻辑运算符（&、&&、|、||、^、!注意：逻辑运算符的结果都是boolean类型的值7.三目运算符注意：语法结构、返回值规则8.位运算符（&、|、^、、>>>）
java从入门到入土第8天
xiao_yin0的博客
05-04 270
3.预习：面向对象 – 构造方法、this、private、封装、static、继承、super、重写、访问修饰符、抽象类及抽象方法、接口、多态、对象转型、内部类。2.复习：之前所有的内容。
java从入门到入土第6天
xiao_yin0的博客
04-28 110
带返回值的方法（方法声明时的类型、return后接的数据）1.知识点的梳理文档（方法.md、数组.md）2.方法的重载（概念、条件、好处、应用场景）3.画内存图（手画2遍、拍照发到QQ群里）3.方法的递归（概念、找出口、找规律）带参数的方法（形参和实参）5.复习：上周所有内容。无参数无返回值的方法。4.方法版本的万年历。
java从入门到入土第7天
xiao_yin0的博客
04-29 65
【代码】java从入门到入土第7天。
java从入门到入土第一卷
11-08
没事复习一遍
Java 学习路线思维导图-从入门到入土
11-19
这份资源是xmind版本，自己电脑需要下载个xmind软件才能打开。
Java从入门到入土之面向对象之三大特性之多态的思维导图
12-18
多态的思维导图
java入门到入土.md
02-20
java入门到入土.md
JAVA教程集合汇总-从入门到入土【汇总多年-史上最详细】呕心沥血整理
02-16
课程内容均为作者多年学习汇总出来的资料，下载后解压可提取相关资源列表，希望能与各位同行共同进步成长，有相关问题请私信我
日常工作记录目录
与海
06-21 52
EasyExcel实现二维码下载与展示
数据结构与算法-差分数组及应用
qq_36115196的博客
06-20 609
差分数组： 其实差分数组是创建一个一个辅助数组，用来表示给定数组的变化，一般用来对数组进行区间修改的操作。
Day43
m0_67496588的博客
06-20 690
JSON，Ajax
Homebrew使用
最新发布
gghh2015的博客
06-21 145
具体参考：https://blog.csdn.net/m0_67402970/article/details/126434901。简介：https://www.jianshu.com/p/f4c9cf0733ea。2、查看安装路径：brew list maven。官网：https://brew.sh/
java学习怎么从入门到入土
03-31
作为一个 AI，我不能协助您在学习过程中“入土”，因为我的宗旨是帮助人们更好地学习和成长。以下是一些建议，可以帮助您更好地学习 Java。 1. 学习基础：首先，您需要了解 Java 的基础知识，例如变量、数据类型、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值