概述
目录
构造方法
代码块
this关键字
static 静态修饰符 修饰成员变量与方法（函数）
计算器案例
-
构造方法
package cn.testjava;
/*
* 构造函数
* 作用：给对应的对象进行初始化
*
* 构造函数的格式：
* 修饰符 函数名(形式参数){
* 函数体
* }
*
* 构造函数的说明：
* 构造函数 是没有返回值类型的
* 构造函数的函数名必须与类名相同
* 构造函数不是由手动调用，在创建对象是时jvm主动调用构造函数
* 如果一个类没有显示的写上一个构造方法时，java编译器会为该类添加一个无参构造函数
* 如果一个类显示的写上了一个构造方法，那么Java编译器则不会为该类添加一个无参的构造函数
* 构造函数可以在一个类中以函数重载的形式存在多个
*
* JDK提供一个Java开发工具（java.exe）给我们进行反编译
*
* javap 反编译的使用格式：
* javap -c -1 -private 类名
*
* java编译器添加的无参构造函数的权限修饰符 是什么
* 与类的权限修饰符是一致的。
*
* 构造函数与普通函数的区别：
* 返回值类型：
* 构造函数没有返回值类型
* 普通函数是有返回值类型的，即使函数没有返回值，返回值类型也要写上void
*
* 函数名
* 构造函数的函数名必须与类名相同
* 普通函数只要符合标识符的命名规则即可
*
* 调用方式
* 构造函数是在创建对象的时候由JVM调用
* 普通函数是由我们使用对象调用的，一个对象可以调用多次普通函数
*
* 作用不同
* 构造函数的作用是初始化一个对象
* 普通函数是用于描述一类公共事物的行为
*
*
* */
public class Dome02 {
/*
* 实战
* 需求：使用Java描述婴儿
* 两种情况，一种是父母在婴儿出生没户口（黑户），一类是婴儿出生有户口（白户）
*
* */
public static void main(String[] args) {
//实例化一个对象：创建一个对象的过程
//创建一个BaBy对象
BaBy B1 = new BaBy();
B1.Name ="小宝";
B1.Id = 001;
System.out.println(" 编号：" + B1.Id + " 姓名：" + B1.Name);
//调用婴儿行为
B1.Cry();
B1.Cry();
}
}
class BaBy{
int Id;
String Name;
// 构造函数 初始化对象
public BaBy(int I, String N){
Id = I;
Name = N;
System.out.println("baby的属性初始化完成！！！");
}
// 无参构造
public BaBy(){
System.out.println("无参数的构造函数被调用。。");
}
// 婴儿的行为 哭 普通函数描述
public void Cry(){
System.out.println(Name + "呜呜呜...");
}
}
-
代码块
package cn.testjava;
/*
构造代码块：
构造代码块的作用：给对象进行统一的初始化。
构造函数的作用： 给对应的对象进行初始化。
构造代码块的格式：
{
构造代码块
}
注意： 构造代码块的大括号必须位于成员位置（同级）上。
构造代码块要注意的事项：
1. java编译器编译一个java源文件的时候，会把成员变量的声明语句提前至一个类的最前端。
2. 成员变量的初始化工作其实都在在构造函数中执行的。
3. 一旦经过java编译器编译后，那么构造代码块的代码块就会被移动构造函数中执行，是在构造函数之前执行的，构造函数的中代码是最后执行 的。
构造代码块的执行优先于构造函数的代码块
4. 成员变量的显示初始化与构造代码块 的代码是按照当前代码的顺序执行的。
代码块的类别：
1. 构造代码块。
2. 局部代码块 大括号位于方法之内。 作用：缩短局部 变量 的生命周期，节省一点点内存。
3. 静态代码块 static
*/
public class Demo03 {
public static void main(String[] args) {
//创建对象
Demo03 D = new Demo03();
System.out.println("i = " + D.i);
}
int i = 100000; //初始化成员变量
//构造函数
public Demo03(){
int i; //局部变量
i = 3000000;
}
//构造代码快
{
i = 20000;
}
}
-
this关键字
package cn.testjava;
/*
* static(静态 修饰符)
* static修饰成员变量：数据需共享给对象时，可以用static修饰成员变量
* 静态成员： 在类加载的时候，类加载完成，就分配完空间；直到类被卸载时空间被回收
* 非静态成员： 创建对象的时候分配空间； 对象变为垃圾空间被回收的时候被销毁
*
* 静态成员变量的访问方式
* 方式1： 使用对象进行访问
* 格式： 对象.变量名
*
* 方式2: 可以使用类名进行访问
* 格式： 类名.变量名;
*
* 注意：
* 非静态的成员变量只能使用对象进行访问，不能使用类名进行访问
* 不要为方便访问数据而是用static修饰成员变量，只有成员变量数据是真正需要被共享的时候才使用static修饰。
*
* static修饰成员变量的使用场景：如果一个数据需要被所有对象共享时，使用static修饰成员变量
*
* static可以修饰成员函数:
* */
public class Demo05 {
public static void main(String[] args) {
Student Stu = new Student();
Stu.Name = "张三";
Stu.Name = "李四";
System.out.println("国籍： "+ Student.Country);
System.out.println("国籍：" + new Student().Country );
System.out.println("国籍：" + new Student().Country +"名字：" + Stu.Name);
System.out.println();
}
}
class Student{
String Name; //非静态成员变量
final static String Country ="中国"; //静态成员变量 为保持变量的一致性 在static前面加final 不允许修改final
//构造函数 初始化成员变量 对象的属性
public Student(){
this.Name = Name;
}
}
-
static 静态修饰符 修饰成员变量与方法（函数）
package cn.testjava;
/*
* this关键字：
* this关键字代表了所属函数的调用者对象
*
* this关键字的作用
* 如果存在同名成员变量与局部变量，在方法内部默认是访问局部变量的数据，可以通过this关键字指定访问成员变量的数据。
* 在一个构造函数中可以调用另外一个构造函数初始化对象
*
* this关键字调用其他构造函数的注意事项：
* this关键字调用其他构造函数，this关键必须要位于构造函数的第一个语句
* this关键字在构造函数中不能出现相互调用的情况，这是一个死循环
*
* this关键字要注意的事项：
* 存在同名成员变量与局部变量时，在方法内部访问的事局部变量（java 采用的是”就近原则“ 访问的）
* 如果在一个方法中访问了一个变量，该变量只存在成员变量的情况下，那么java编译器会在该变量的 前面添加this关键字。
*
*/
public class Demo04 {
public static void main(String[] args) {
Animal cat = new Animal("猫","黑色");
Animal dog = new Animal("狗","白色"); //现在在内存中存在两份name数据。
cat.eat();
}
}
class Animal{
String Name;
String Color;
//构造方法 初始化成员变量
public Animal(String N, String C){
Name = N;
Color =C;
}
//this关键字代表了所属函数的调用者对象
public void eat(){
// String Name = "耗子";
System.out.println(this.Color +this.Name + "在吃...");//this关键字调用成员变量
System.out.println(Name + "在吃...");
System.out.println(this.Color + this.Name + "在吃...");
}
}
package cn.testjava;
/*
* static静态，修饰符)
* static修饰成员变量时：被static修饰的成员变量是共享数据
*
* 静态成员变量访问方式：
* 方式一：使用对象访问
* 对象.属性名
* 方式二：使用类名进行访问
* 类名.属性名
* 注意：
* 非静态成员变量不能使用类名进行访问，只能使用对象进行访问
* 不能为了访问方便而使用static修饰成员变量，一定该数据是共享数据 时才使用static修饰。
*
* static修饰方法（静态的成员方法）
* 方式一： 对象.静态方法（函数）名();
* 方式二: 类.静态函数ming() 推荐使用
*
* 静态成员变量与非静态成员变量的区别
* 1. 作用上的区别：
* 1. 静态的成员变量的作用共享一个 数据给所有的对象使用。
* 2. 非 静态的成员变量的作用是描述一类事物的公共属性。
* 2. 数量与存储位置上的区别：
* 1. 静态成员变量是存储方法 区内存中，而且只会存在一份数据。
* 2. 非静态的成员变量是存储在堆内存中，有n个对象就有n份数据。
* 3. 生命周期的区别：
* 1. 静态的成员变量数据是随着类的加载而存在，随着类文件的消失而消失。
* 2.非静态的成员数据是随着对象的创建而存在，随着 对象被垃圾回收器回收而消失。
*
* 静态函数要注意的事项：
* 1. 静态函数是可以通过类名或者对象进行调用的，而非静态函数只能使用对象进行调用。
* 2. 静态的函数可以直接访问静态的成员，但是不能直接访问非静态的成员。
* 原因：静态函数是可以使用类名直接调用的，这时候可能还没有存在对象，
* 而非静态的 成员数据是随着对象 的存在而存在的。
*
* 3. 非静态的函数是可以直接访问静态与非静态的成员。
* 原因：非静态函数只能由对象调用，当对象存在的时候，静态数据老早就已经存在了，而非静态数据也随着对象的创建而存在了。
*
* 4. 静态函数不能出现this或者super关键字。
* 原因：因为静态的函数是可以使用类名调用的，一旦使用类名调用这时候不存在对象，而this关键字是代表了一个函数 的调用者对象，这时候产生了冲突。
*
*静态的数据的生命周期：静态的成员变量数据是优先于对象存在的。
*
*static什么时候修饰一个函数？
* 如果一个函数没有直接访问到非静态的成员时，那么就可以使用static修饰了。 一般用于工具类型的方法
*
*静态函数不能访问非静态的成员？
* 静态函数只要存在有对象，那么也可以访问非 静态的数据。只是不能直接访问而已。
*
* 分类
* 静态成员函数
* 静态函数
*
* static修饰的函数，被限定在本类的源文件中，不能被其他源文件的类调用
*/
public class Dome06 {
public static void main(String[] args) {
//通过类名直接调用
Student.Sleep();
//通过对象调用
Student Stu = new Student();
Stu.Sleep();
}
}
class Student{
String Name;
final static String Country = "华国";
static {
System.out.println("静态构造块");
}
//函数 非静态
public void Study(){
System.out.println("好好学习" + this.Name);
}
//静态函数
public static void Sleep(){
Student Stu = new Student();
Stu.Name = "张三";
System.out.println(Stu.Name + "Hello World");
}
}-
计算器案例
package cn.testjava;
//计算器案例
public class Demo01 {
public static void main(String[] args) {
}
// 定义两个操作数Num1,Num2 和一个运算符Option
private int Num1;
private int Num2;
private char Option;
//定义运算符
public void InitCalulator(int N1, int N2, char O){
Num1 = N1;
Num2 = N2;
if(O == '+' || O == '-' || O == '*' || O =='/'){
Option = O;
}else{
Option = '+';
}
}
//实现操作数的运算
public void calculate(){
switch(Option){
case '+':
System.out.println("做加法运算,结果是："+(Num1+Num2));
break;
case '-':
System.out.println("做减法运算,结果是："+(Num1-Num2));
break;
case '*':
System.out.println("做乘法运算,结果是："+(Num1*Num2));
break;
case '/':
System.out.println("做除法运算,结果是："+(Num1/Num2));
break;
}
}
}
最后
以上就是哭泣鸭子为你收集整理的day02之面向对象 ---- java基础篇的全部内容，希望文章能够帮你解决day02之面向对象 ---- java基础篇所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
![Day02--3继承、方法覆盖、多态、final、package、import、访问控制权限、IDEA快捷键1.继承2.方法覆盖/重写（override[官方]/overwrite）3.多态4.final关键字（最终的、不可变的）5.包机制（packet）6.import语句7.访问控制权限8.IDEA快捷键](/uploads/reation/bcimg1.png)
发表评论 取消回复