💗wei_shuo的个人主页
💫wei_shuo的学习社区
🌐Hello World !
☢Java入门
- 基础知识:了解 Java 基本语法、面向对象编程(OOP)概念、流程控制语句、数据类型、方法等基础知识。可以通过 Java 编程入门教程、Java 编程思想等书籍进行学习。
- 面向对象编程:深入学习 OOP 概念,包括封装、继承、多态、接口等。掌握设计模式、反射机制等高级特性。可以参考《Effective Java》等书籍进行学习。
- Java 核心类库:熟练掌握 Java 核心类库,包括集合框架、IO、并发、网络编程等。可以参考《Java 核心技术》等书籍进行学习。
- Web 开发:学习 Java Web 开发相关知识,包括 Servlet、JSP、MVC 模式、Spring 框架、Hibernate 等。可以参考《Spring 实战》、《Hibernate 实战》等书籍进行学习。
- 数据库编程:学习使用 Java 连接数据库、操作数据库等知识。可以学习 MySQL、Oracle、MongoDB 等常用数据库的使用。
- 其他领域:学习 Android 开发、Java 大数据开发、Java 游戏开发等其他领域的知识
☢Java面向对象
- 面向过程POP(
C语言
)面向过程是
自上而下
的设计语言,先定好框架,再增砖添瓦。通俗点,就是先定好main()函数,然后再逐步实现mian()函数中所要用到的其他方法
- 面向对象OOP(
c++
,c#
,java
,delphi
)面向对象顾名思义就是把现实中的事务都抽象成为程序设计中的
对象
,其基本思想是一切皆对象
,是一种自下而上
的设计语言,先设计组件,再完成拼装
☢构造方法
构造方法是一种特殊的方法
作用:完成对象数据的初始化
格式:
public class 类名{修饰符 类名(参数){……} }
- 无参构造方法
//无参构造方法public Student() {System.out.println("无参构造方法");}
- 带参构造方法
//带参构造方法 public Student(String name, int age) {this.name = name;this.age = age; }
- 构造方法调用
//创建对象,实例化对象 Student student = new Student(); //调用无参构造方法System.out.println("===================");final Student student2 = new Student("wei",18); //调用带参构造方法
- 创建Student类
package itiheima_02;public class Student {//定义成员变量private String name;private int age;//定义成员方法public void show() {System.out.println("name:" + name + "," + "age:" + age);}//无参构造方法public Student() {System.out.println("无参构造方法");}//带参构造方法public Student(String name, int age) {this.name = name;this.age = age;} }
- 创建StudentDemo测试类
package itiheima_02;public class StudentDemo {public static void main(String[] args) {//创建对象,实例化对象Student student = new Student(); //调用无参构造方法student.show(); //name、age未赋值所以输出结果为空 name:null,age:0System.out.println("===================");final Student student2 = new Student("wei",18); //调用带参构造方法student2.show(); //name:wei,age:18} }
💨成员方法和构造方法的区别
构造方法:
- 没有返回值类型,没有return,方法名和类名相同
- 如果没有写构造方法,系统会自动添加一个无参构造方法
成员方法:
- 有返回值类型,若有返回值类型为空void,则可以不写return,成员方法名和类名不能相同
- 系统不会自动添加成员方法
总结:成员方法有返回值,构造方法无返回值
package itiheima_05;public class TEST {int age = 18;String name = "WEi_SHUO";//无参构造方法,没有写构造方法,系统会自动添加一个无参构造方法public TEST() {}//带参构造方法public TEST(int age, String name) {this.age = age;this.name = name;}//成员方法public void show(){//局部变量(成员方法中的变量)int age = 18;System.out.println(age);}
}
☢类/方法
💨类
类的组成:属性和行为
属性:类中通过成员变量体现
行为:类中通过成员方法体现
Java中的类是通过class关键字来定义
[修饰符] class 类名 [extends 父类名] [implements 接口名]{// 类体,包括类的成员变量和成员方法}
💨方法
有参和无参
- 无参方法
public static void wucan(){ System.out.println("无参方法"); }
- 带参方法
public static void sum(int a,int b){ System.out.println("两数相加结果"+a+b); }
有无返回值
- 有返回值
public static int sum(int a,int b){return a+b; }
- 无返回值
public static void sum(int a,int b){System.out.println("无返回值"); }
💨对象
对象是类的一个实例,通过new这个关键字使用构造方法创建当前类的对象
格式:类名 对象名 = new 类名();
Phone p = new Phone();
对象的使用
使用成员变量:
- 格式:对象名.变量名
- p.brand
使用成员方法
- 格式:对象名.方法名
- p.call()
创建对象步骤:
- 声明:声明一个对象,包括对象名称和对象类型
- 实例化:使用关键字 new 来创建一个对象
- 初始化:使用 new 创建对象时,会调用构造方法初始化对象
- 创建Phone类
package itiheima_01;public class Phone {//成员变量String brand;int price;//成员方法public void call(){System.out.println("打电话");}public void SendMessage(){System.out.println("发短信");} }
- 创建PhoneDemo测试类
package itiheima_01;public class PhoneDemo {public static void main(String[] args) {Phone p = new Phone();System.out.println(p); //itiheima_01.Phone@1b6d3586 内存地址//成员变量赋值p.brand="小米";p.price=1999;//输出成员变量System.out.println(p.brand);System.out.println(p.price);/*执行结果:小米1999*///调用成员方法p.call();p.SendMessage();/*执行结果:打电话发短信*/} }
☢变量
💨成员变量/局部变量/成员方法
- 成员变量(全局变量):类中方法外的变量
- 局部变量:成员方法中的变量
- 成员方法:类中定义的方法
//特殊的成员方法:main(): public static void main(String[] args){//特定的功能 }//一般的成员方法: public 返回值类型 方法名(形式参数列表){//方法体;(特定功能的代码)return 返回值; }
💨静态变量/实例变量
静态变量
静态变量用 static字符修饰,随着类的加载而加载,静态变量存放在方法池中的静态区,可以直接通过"类名.变量名直接"调用,也可以通过类的对象调用
实例变量
实例变量相当于该类的属性,需要 "new对象 "才能被调用。而且该变量不常驻内存,当这个类不再被使用时会java回收机制所释放
区别
- 存储区域不同:静态变量存储在静态存储区域,实例变量存储在堆中,会被释放
- 生命周期不同:静态变量在类启动时就分配指定内存;实例变量在被对象调用后才分配内存,调用结束时内存释放
- 静态变量与类相关,实例变量与对象相关
- 实例变量在被对象调用后才分配内存,调用结束时内存释放;所以random两次调用后任然为3
- 静态变量在类启动时就分配指定内存;所以第二次调用之后为4
public class TEST {private static int staticInt = 2;//静态变量private int random = 2;//实例变量public TEST() { //TEST无参构造方法staticInt++;random++;System.out.println("staticInt = "+staticInt+" random = "+random);}public static void main(String[] args) { //main方法:特殊的成员方法//定义test变量,通过new关键字创建TEST对象,进而调用TEST无参构造方法TEST test = new TEST();TEST test2 = new TEST();}}/* 输出结果: staticInt = 3 random = 3 staticInt = 4 random = 3 */
静态代码块(
静态代码块>构造代码块>构造函数>普通代码块
)静态代码块写在类里面的时候,优先于类的加载、执行,且只会被加载一次
public class Car {static String color;// 下面是一个静态代码块static {color = "red";System.out.println("这辆车的颜色是" + color);} }
☢封装
将类的某些信息隐藏在类内部,不允许外部程序直接访问,而是通过成员变量private,提供对应的
get
/set
方法
- 通过方法来控制成员变量的操作,提高了代码的安全性
- 代码用方法封装,提高代码的复用性
语法格式:
public class Person {private String name;private int age; }
☢继承
继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法,或子类从父类继承方法,使得子类具有父类相同的行为
- 提高代码复用性和维护性
- 子类和父类产生关系,耦合性增强父类变化子类也需要变化
继承格式:
public class 子类名 extend 父类名{}
继承中子类特点
- 子类可以有父类的内容
- 子类也可以有特有的内容
☢多态
同一个对象,在不同时刻表现出来的不同形态
多态的前提和体现
- 继承/实现关系
- 方法重写
- 父类引用指向子类对象
多态访问中成员访问的特点
- 成员变量:编译看左边,执行看左边
- 成员方法:编译看左边,执行看右边
- 原因:成员方法有重写,成员变量没有
Animal类
package itiheima_02;public class Animal {public int age =40;public void eat(){System.out.println("动物吃东西");} }
Cat类
package itiheima_02;public class Cat extends Animal{public int age=20;public int weight=10;@Overridepublic void eat() {System.out.println("猫吃鱼");}public void playGame(){System.out.println("猫捉迷藏");} }
AnimalDemo测试类
package itiheima_02;/*多态前提和体现继承/实现关系方法重写父类引用指向子类对象*/public class AnimalDemo {public static void main(String[] args) {//父类引用指向子类对象——多态Animal animal = new Cat();//多态方式访问成员变量:编译看左边,运行看左边System.out.println(animal.age);//多态方式访问成员方法:编译看左边,运行看右边animal.eat();} }
💨多态中的转型
向上转型
从子到父
父类引用指向子类对象
向下转型
从父到子
父类引用转为子类对象
向下转型解决了多态的弊端:不能访问
子类的特有功能
- Animal类
package itiheima_02;public class Animal {public int age =40;public void eat(){System.out.println("动物吃东西");} }
- Cat类
package itiheima_02;public class Cat extends Animal{@Overridepublic void eat() {System.out.println("猫吃鱼");}public void playGame(){System.out.println("猫捉迷藏");} }
- AnimalDemo测试类
package itiheima_02;/* - 向上转型从子到父父类引用指向子类对象- 向下转型从父到子父类引用转为子类对象 */public class AnimalDemo {public static void main(String[] args) {/*多态向上转型:从子到父父类引用指向子类对象*/Animal animal = new Cat(); //向上转型//多态访问成员方法:编译看左边,执行看右边animal.eat(); //猫吃鱼 // animal.playGame(); Error,因为编译看左边,左边Animal没有playGame方法//使用Cat中playGame方法有两种方法://方式一://创建Cat类对象Cat cat = new Cat();cat.eat(); //猫吃鱼cat.playGame(); //猫捉迷藏//方式二:/*多态向下转型从父到子父类引用转为子类对象*/Cat cat1 = (Cat) animal;cat1.eat(); //猫吃鱼cat1.playGame(); //猫捉迷藏//向下转型解决了多态的弊端:不能访问子类的特有功能} }
☢String概述
String构造方法
方法名 说明 public String() 创建一个空白字符串对象,不会有任何内容 public String(char[] chs) 根据字符数组的内容,来创建字符串对象 public String(byte[] bys) 根据字节数组的内容,来创建字符串对象 String s = “abc”; 直接赋值的方式创建字符创对象,内容就是abc
💨StringBulider概述
StringBulider构造方法
方法名 说明 public StringBulider() 创建一个空白可变字符串对象,不含有任何内容 public StringBulider(String str) 根据字符串的内容,来创建可变字符串对象 StringBulider添加/反转方法
方法名 说明 public StringBulider append(任意类型) 添加数据,并返回对象本省 public StringBulider reverse() 返回相反的字符序列
💨String和StringBulider相互转换
- StringBulider转换String
- 通过toString()可以实现
public string toString();
//StringBulider转换StringStringBuilder stringBuilder = new StringBuilder();stringBuilder.append("hello");String s = stringBuilder.toString();System.out.println(s); //hello
- String转换StringBulider
- 通过构造方法可以实现
public StringBulider(String s);
//String转换StringBuliderString s = "hello";StringBuilder stringBuilder = new StringBuilder(s);System.out.println(stringBuilder); //hello
集合框架
集合:
- Collection集合:单列集合、类似数组,每个元素只包含一个值
- List集合:可重复集合
- ArrayList集合
- LinkedList集合
- Set集合:不可重复集合
- HashSet集合
- TreeSet集合
- Map集合:双列集合、类似二维数组,每个元素包含键值对
- HashMap集合
💨Collection集合
概述:
- 单例集合的顶层接口,表示一组对象,这些对象成为Collection的元素
- JDK不提供接口的任何直接实现,提供更具体的子接口
Set
/List
实现创建Collection集合对象
- 多态方式
- 具体实现类ArrayList
💨ArrayList集合
- ArrayList集合构造方法和添加方法
方法名 说明 public ArrayList() 创建一个空的集合对象 public boolean add(E e) 将指定的元素追加到此集合末尾 public boolean add(int index,E element) 在此集合的指定位置插入指定元素 ArrayList<String> arrayList = new ArrayList<>();arrayList.add("hello");arrayList.add("world");arrayList.add(1,"java");System.out.println(arrayList); //[hello, java, world]
- ArrayList集合常用方法
方法名 说明 public boolean remove(Object) 删除指定元素,返回删除是否成功 public E remove(int index) 删除指定索引的元素,返回被删除的元素 public E set(int index,E element) 修改指定索引处的元素,放回被修改的元素 public E get(int index) 放回指定索引处的元素 public int size() 放回集合中的元素的个数
☢权限修饰符
作用:用于控制被修饰变量,方法,类的可见范围
访问权限修饰符:
由小到大—private –default—protected—public
💨private(私有)
- private关键字是
权限修饰符
,修饰成员变量
、成员方法
- 保护成员变量、成员方法不被别的类使用,被private修饰的成员变量、成员方法只能在
本类
中访问
private关键字修饰的成员变量,如果被其它类使用,需要响应的操作
- 提供"
get变量名()
"方法,用于获取成员变量的值,方法用public
修饰- 提供"
set变量名(参数)
"方法,用于获取成员变量的值,方法用public
修饰
- Student类
//Student类 public class Student {//成员变量:类中,方法外String name;private int age;//提供get、set方法设置、获取值public int getAge() {return age;}public void setAge(int age) {this.age = age;}//成员方法public void show() {System.out.println(name + "," + age);} }
- StudentDemo测试类
public class StudentDemo {public static void main(String[] args) {//创建对象Student s = new Student();//给成员变量赋值s.name="wei_shuo";s.setAge(18); //使用setAge设置值、getAge可获取值//调用show方法s.show();} }
💨default(默认)
背景:接口在Java中定义之初,有一个缺点,如果定义了一个接口,接口中又定义了N个方法,那么某个具体的类在实现该接口时,需要实现接口中的
所有方法
,不管是否需要用到接口中的方法。如果接口中的某个方法被default关键字修饰了,那么具体的实现类中可以不用实现方法
- default关键字大部分都应用于接口
- 通过default关键字定义的方法,集成该接口的方法不需要去实现该方法
- Person接口
public interface Person {default String getName(){return "hello world";} }
- Student实现类(实现该接口的类不需要去实现该方法)
class Student implements Person {//可以不用实现show()方法 }
- main方法
public static void main(String[] args) {Student student = new Student();System.out.println(student.getName());}
💨protected(保护)
Java 中的
protected
是一种访问修饰符,用于限制对类成员的访问。被声明为protected
的类成员可以被其同一包中的其他类访问,以及该类的子类中访问。具体来说,如果一个类成员被声明为
protected
,那么该成员可以在以下情况下被访问:
- 从同一包中的其他类访问该成员。
- 从子类中访问该成员。
在其他情况下,无法直接访问
protected
成员。需要通过子类来访问该成员,或者通过该类的公共方法来访问。需要注意的是,
protected
成员与private
成员的区别在于,protected
成员可以被该类的子类访问,而private
成员则不能。而与public
成员相比,protected
成员的访问权限更加受限,只能在同一包中或子类中访问
💨public(公开)
在 Java 中,
public
是一种访问修饰符,用于声明一个类、方法或变量可以被任何类访问。被声明为public
的类、方法或变量可以在任何地方被访问,包括其他包中的类。具体来说,如果一个类、方法或变量被声明为
public
,那么它可以在以下情况下被访问:
- 从任何其他类中访问该类、方法或变量。
- 从该类所在的包中的任何其他类访问该类、方法或变量。
- 从任何其他包中的类访问该类、方法或变量,但需要通过完全限定的类名(包括包名和类名)来访问。
需要注意的是,
public
成员的访问权限最大,但是为了保证程序的封装性和安全性,不建议将所有类、方法或变量都声明为public
。通常情况下,只有那些需要在不同的包或类之间共享的元素才会被声明为public
。而对于仅在本类或包中使用的元素,应该将其声明为private
或protected
☢状态修饰符
💨final
final:final关键字是最终的意思,可修饰成员变量,成员方法,类
特点:
- 修饰方法:表名改方法是最终方法,不能被重写
- 修饰变量:表名该变量是常量,不能被再次赋值
- 修饰类:表名该类是最终类,不能被继承
💨static
☢抽象修饰符
💨abstract
- 抽象类和抽象方法必须使用abstract关键字修饰
//抽象类 public abstract class 类名{}; //抽象方法 public abstract void eat();
抽象类不一定有抽象方法,有抽象方法一定是抽象类
抽象类实例化:参照多态方式,通过子类对象实例化(抽象类多态)
抽象类的子类:要么重写抽象类中所有抽象方法;要么子类是抽象类
☢关键字
💨static
static关键字是静态的意思,可以修饰成员方法,成员变量
特点:
- 被static修饰会被类的所有
对象共享
,可以使用类名
调用,也可以使用对象名
访问
- Student类
//Student类 public class Student {//成员变量public String name;public int age;//被所有对象共享的成员使用static修饰public static String university;//成员方法public void show() {System.out.println(name + "," + age + "," + university);} }
- StaticDemo测试类
package itiheima_03;public class StaticDemo {public static void main(String[] args) {//static修饰的成员变量可以通过对象名访问,也可以通过类名访问Student.university = "加里敦大学";//创建学生类对象Student s1 = new Student();//Student类中name、age、university使用public修饰所以可以使用 对象.成员变量名 访问赋值s1.name="yiyi";s1.age=18;s1.university="加里敦大学"; //对象名访问可行s1.show();Student s2 = new Student();s2.name="erer";s2.age=20;s2.university="加里敦大学"; //对象名访问可行s2.show();} }/* 输出结果: yiyi,18,加里敦大学 erer,20,加里敦大学 */
静态变量: 随着类加载被分配在方法区的静态区域,内存中只有一个,被类的所有实例共享
非静态变量: 被实例化之后才分配内存,分配在堆内存中的对象空间里面
static方法调用非静态变量的问题?
JVM加载顺序:
静态块(静态变量)——>成员变量——>构造方法——>静态方法
静态代码块(只加载一次)
构造方法(创建一个实例就加载一次)
静态方法需要调用才会执行
本质: JVM加载顺序约定的,加载 static 方法的时候非静态方法还没初始化
static方法是静态方法,属于类的方法;非static方法,属于对象的方法
非static方法是要与对象关联在一起的,必须在创建出一个对象后,才可以通过这个对象调用非static方法;而static方法可以直接通过类名来调用,不需要创建对象
一个static方法被调用时,还可能没有创建任何实例对象,此时如果从static内部发出对非static方法的调用,非static方法是无法关联到对象的
package itiheima_03;public class Student {static String name; //静态name成员变量int age; //非静态age成员变量public static void show1(){ //静态show1方法System.out.println(name);//System.out.println(age); //报错,静态方法无法调用非静态变量}public void show2(){ //静态show2方法System.out.println(name+","+age);} }
💨void
void是一种数据类型,Java的底层代码中,对应一个void类
作用:说明该方法
无返回值
💨main
main函数也叫作主函数,主函数是一个作为程序入口的静态函数,可以被
JVM
识别并自动加载
格式:
public static void main(String[] args){}
main:众多编程语言的通用名称,用于表示主方法的入口。main虽然不是关键字,但是会被JVM识别
String[] args 作用:接收键盘录入的数据,表示一个字符串数组
- String[]表示的是
字符串类型的数组
- args表示的是
传入的参数名
- 主方法main(String[] args)可以接收一个
字符串
类型的数组,数组名字为args
💨class
class 关键字用于创建一个类。Java运行的每一行代码都必须在一个类中。类应始终以大写首字母开头,并且Java文件的名称必须与类名称匹配。
Class类封装一个对象和接口运行时的状态,当装载类时,Class类型的对象自动创建
💨this
this修饰的变量用于指代成员变量
方法的形参如果与成员变量同名
- this关键字修饰的指的是成员变量,不带this关键字修饰的是方法形参
方法的形参与成员变量不同名
- 不带this修饰的变量指的是成员变量
this关键字:避免局部变量与成员变量同名,导致局部变量隐藏
this:代表所在类的对象引用(方法被哪个对象引用,this就代表哪个对象)
💨super
super:代表父类存储空间的标识(父类对象应用)
this:代表本类对象引用
- FU类
public class FU {int age =40; }
- ZI类
public class ZI extends FU{int age = 20;public void show(){int age = 30;//调用局部变量ageSystem.out.println(age);//调用成员变量ageSystem.out.println(this.age);//调用父类变量ageSystem.out.println(super.age);} }
- Demo测试类
public class Demo {public static void main(String[] args) {ZI zi = new ZI();zi.show();} }/*输出结果:302040*/
💨extend
在 Java 中,
extends
是一种关键字,用于表示一个类继承自另一个类。子类可以继承父类的属性和方法,并可以添加自己的属性和方法。下面是一个简单的 Java 代码示例,演示了如何使用
extends
关键字创建一个子类,并继承父类的属性和方法:public class Animal {protected String name;public Animal(String name) {this.name = name;}public void makeSound() {System.out.println("The animal makes a sound");} }public class Dog extends Animal {public Dog(String name) {super(name);}@Overridepublic void makeSound() {System.out.println("The dog barks");} }public class Main {public static void main(String[] args) {Animal animal = new Animal("Animal");animal.makeSound(); // 输出 "The animal makes a sound"Dog dog = new Dog("Fido");dog.makeSound(); // 输出 "The dog barks"System.out.println(dog.name); // 输出 "Fido"} }
在上面的例子中,
Animal
类是一个基类,Dog
类是一个继承自Animal
类的子类。Dog
类继承了Animal
类的name
属性和makeSound()
方法,并且通过@Override
注解覆盖了makeSound()
方法,使其输出狗叫的声音。在Main
类中,我们创建了一个Animal
对象和一个Dog
对象,并调用它们的makeSound()
方法和name
属性。由于Dog
继承自Animal
,所以它也继承了name
属性,我们可以通过dog.name
来访问它
💨implements
在 Java 中,
implements
是一种关键字,用于表示一个类实现了一个或多个接口。通过实现接口,类可以获得接口中定义的方法和常量,并提供自己的实现。下面是一个简单的 Java 代码示例,演示了如何使用
implements
关键字实现一个接口:public interface Shape {double getArea();double getPerimeter(); }public class Circle implements Shape {private double radius;public Circle(double radius) {this.radius = radius;}@Overridepublic double getArea() {return Math.PI * radius * radius;}@Overridepublic double getPerimeter() {return 2 * Math.PI * radius;} }public class Main {public static void main(String[] args) {Circle circle = new Circle(5);System.out.println("Area of the circle: " + circle.getArea());System.out.println("Perimeter of the circle: " + circle.getPerimeter());} }
在上面的例子中,
Shape
接口定义了两个方法getArea()
和getPerimeter()
,它们分别返回图形的面积和周长。Circle
类实现了Shape
接口,并提供了自己的实现。在Main
类中,我们创建了一个Circle
对象,并调用它的getArea()
和getPerimeter()
方法,它们返回了圆的面积和周长。需要注意的是,一个类可以实现多个接口,多个接口之间用逗号分隔。如果一个类实现了多个接口,它必须实现每个接口中定义的方法
💨interface
在 Java 中,
interface
是一种特殊的抽象类,它只包含常量和抽象方法的声明。通过实现接口,类可以获得接口中定义的方法和常量,并提供自己的实现。下面是一个简单的 Java 代码示例,演示了如何定义和实现一个接口:
public interface Animal {void makeSound(); }public class Dog implements Animal {@Overridepublic void makeSound() {System.out.println("The dog barks");} }public class Cat implements Animal {@Overridepublic void makeSound() {System.out.println("The cat meows");} }public class Main {public static void main(String[] args) {Animal dog = new Dog();dog.makeSound(); // 输出 "The dog barks"Animal cat = new Cat();cat.makeSound(); // 输出 "The cat meows"} }
在上面的例子中,
Animal
接口定义了一个makeSound()
方法,表示动物会发出声音。Dog
类和Cat
类实现了Animal
接口,并提供了自己的实现。在Main
类中,我们创建了一个Dog
对象和一个Cat
对象,并将它们声明为Animal
类型。由于Dog
和Cat
都实现了Animal
接口,所以它们都有makeSound()
方法。我们可以通过调用dog.makeSound()
和cat.makeSound()
来分别听到狗叫和猫叫的声音。需要注意的是,接口中的方法默认是
public abstract
类型,常量默认是public static final
类型,因此不需要显式地指定。接口不能包含构造方法,因为它们不会被继承
💨class
在 Java 中,
class
是一种定义对象属性和行为的模板。类是面向对象编程的核心概念之一,它用于组织和封装数据和代码,以实现高内聚和低耦合的设计。下面是一个简单的 Java 代码示例,演示了如何定义和使用一个类:
public class Car {private String make;private String model;private int year;public Car(String make, String model, int year) {this.make = make;this.model = model;this.year = year;}public void start() {System.out.println("The car is starting...");}public void stop() {System.out.println("The car is stopping...");}public void drive(int miles) {System.out.println("The car is driving " + miles + " miles...");}public String getMake() {return make;}public String getModel() {return model;}public int getYear() {return year;} }public class Main {public static void main(String[] args) {Car car = new Car("Toyota", "Camry", 2021);System.out.println("Make: " + car.getMake());System.out.println("Model: " + car.getModel());System.out.println("Year: " + car.getYear());car.start();car.drive(10);car.stop();} }
在上面的例子中,我们定义了一个
Car
类,它有三个私有属性make
、model
和year
,以及三个公共方法start()
、stop()
和drive()
,用于启动、停止和驾驶车辆。我们还为每个属性提供了公共的getter
方法,以便可以在外部访问它们的值。在
Main
类中,我们创建了一个Car
对象,并通过调用它的getMake()
、getModel()
和getYear()
方法来获取车辆的制造商、型号和年份。我们还调用了start()
、drive()
和stop()
方法来启动、驾驶和停止车辆。需要注意的是,Java 中的类可以继承其他类,从而扩展已有的类,并在其基础上添加新的属性和方法。此外,类还可以实现接口,以获得接口中定义的方法和常量。通过使用类的继承和实现,可以实现代码的重用和多态
💨new
在 Java 中,
new
是一种用于创建新对象的操作符。它可以在内存中分配一段新的空间,并返回一个指向该空间的对象引用。使用new
操作符创建对象的过程称为实例化。下面是一个简单的 Java 代码示例,演示了如何使用
new
操作符创建对象:public class Car {private String make;private String model;private int year;public Car(String make, String model, int year) {this.make = make;this.model = model;this.year = year;}public void start() {System.out.println("The car is starting...");}public void stop() {System.out.println("The car is stopping...");}public void drive(int miles) {System.out.println("The car is driving " + miles + " miles...");}public String getMake() {return make;}public String getModel() {return model;}public int getYear() {return year;} }public class Main {public static void main(String[] args) {Car car = new Car("Toyota", "Camry", 2021);System.out.println("Make: " + car.getMake());System.out.println("Model: " + car.getModel());System.out.println("Year: " + car.getYear());car.start();car.drive(10);car.stop();} }
在上面的例子中,我们使用
new
操作符创建了一个Car
对象,并将它赋值给car
变量。我们传递了三个参数"Toyota"
、"Camry"
和2021
给Car
类的构造函数,以初始化对象的属性。然后,我们可以使用car
变量调用getMake()
、getModel()
和getYear()
方法来获取对象的属性值,并调用start()
、drive()
和stop()
方法来执行对象的行为。需要注意的是,Java 中的
new
操作符只能用于实例化类的对象,而不能用于实例化接口或抽象类。此外,使用new
操作符创建对象时,Java 会自动调用对象的构造函数来初始化对象的属性。如果类没有提供任何构造函数,则Java会自动提供一个默认的无参构造函数。如果需要提供特定的构造函数,则必须在类中显式地定义
☢自动装箱&拆箱
基本数据类型 | 包装类型 |
---|---|
byte | java.Lang.Byte |
short | java.Lang.Short |
int | java.Lang.Integer |
long | java.Lang.Long |
float | java.Lang.Float |
double | java.Lang.Double |
boolean | java.Lang.Boolean |
char | java.Lang.Character |
装箱:基本类型——转换为——对应的包装类类型,一般使用方法valueOf()方法实现
拆箱:包装类类型——转换为——对应的基本数据类型,一般使用类中提供xxxValue()方法实现
- 自动装箱
Integer i = 100;
i += 200 // i = i + 200 ;i + 200 自动拆箱 ; i = i + 200 自动装箱
package itiheima_04;public class IntergerDemo {public static void main(String[] args) {//装箱:基本类型转换为对应的包装类类型Integer i = Integer.valueOf(100);//自动装箱Integer ii = 100; //省略了 Integer.valueOf(100);//拆箱:包装类类型转换为对应的基本数据类型ii = ii.intValue() + 200;//自动拆箱ii += 200;}
}
☢方法重写 & 方法重载
💨方法重写
子类出现和父类一模一样的方法声明
当子类需要父类的功能,而功能主体子类有自己的特有内容时,可以重写父类中的方法,这样即沿袭父类的功能,又定义了子类特有的内容
私有方法不能重写
子类方法访问权限不能比父类低(public > default > private)
- Phone类
public class Phone {public void call(String name) {System.out.println("给" + name + "打电话");} }
- NewPhone类
public class NewPhone extends Phone{//重写父类方法@Overridepublic void call(String name) {super.call(name);System.out.println("开启视频功能");} }
- Demo测试类
public class PhoneDemo {public static void main(String[] args) {Phone phone = new Phone();phone.call("weishuo");System.out.println("=====================");NewPhone newPhone = new NewPhone();newPhone.call("tian");} }
💨方法重载
方法重载前提:方法名相同、参数列不同、与返回值无关
- 多个方法在一个类中
- 多个方法具有相同方法名
- 多个方法参数不相同、类型不同、数量不同
public class MethodDemo {public static void main(String[] args) {System.out.println(sum(1, 1));System.out.println(sum(1.1, 1.1));System.out.println(sum(1, 1, 1));}//需求1:求两个int类型数据和的方法public static int sum(int a, int b) {return a + b;}//需求2:求两个double类型数据和的方法public static double sum(double a, double b) {return a + b;}//需求3:求两个int类型数据和的方法public static int sum(int a, int b, int c) {return a + b + c;}
}
☢日期
💨Date
Date代表一个特定的时间,精确到毫秒
方法名 | 说明 |
---|---|
public Date() | 分配一个Date对象,并初始化,以便它代表被分配的时间 |
public Date(long date) | 分配一个Date对象,将其初始化表示从标准基准时间起指定的毫秒数 |
piblic long getTime() | 获取日期对象从1970年1月1日00:00:00到现在的毫秒值 |
public void getTime(long time) | 设置时间,给的是毫秒值 |
public class SimpleDateFormat {public static void main(String[] args) {//public Date()Date d1 = new Date();System.out.println(d1); // Sun Nov 20 15:44:32 CST 2022System.out.println("=================");//public Date(long date)long date2 = 1000*60*60;Date d2 = new Date(date2);System.out.println(d2); // Thu Jan 01 09:00:00 CST 1970}
}
💨SimpleDateFormat
SimpleDateFormat是一个具体类,用于区域设置敏感的方式格式化和解析日期
yyyy-MM-dd HH:mm:ss | 常用的模式字母对应关系 |
---|---|
y | 年 |
M | 月 |
d | 日 |
H | 时 |
m | 分 |
s | 秒 |
方法名 | 说明 |
---|---|
SimpleDateFormat() | 构建了一个 SimpleDateFormat,使用默认模式和日期格式 |
SimpleDateFormat(String pattern) | 构建了一个 SimpleDateFormat使用给定的模式和默认的日期格式 |
格式化(Date——>String)
public final String format(Date date) 将日期格式化成日期/时间字符串
解析(String——>Date)
public Date parse(String source) 从给定的字符串开始解析文本以生成日期
public class SimpleDateFormatDemo {public static void main(String[] args) throws ParseException {//格式化(Date——>String)Date date1 = new Date();SimpleDateFormat sdf1 = new SimpleDateFormat(); //默认模式SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); //自定义模式//格式化输出System.out.println(sdf1.format(date1)); // 22-11-20 下午4:03System.out.println(sdf2.format(date1)); // 2022-11-20 16:05:57//解析(String——>Date)String s = "2022-11-20 08:08:08";SimpleDateFormat sdf3 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); //自定义模式System.out.println(sdf3.parse(s)); // Sun Nov 20 08:08:08 CST 2022}
}
🌼 结语:创作不易,如果觉得博主的文章赏心悦目,还请——
点赞
👍收藏
⭐️评论
📝冲冲冲
🤞