山丘i资料

本文主要介绍山丘i资料 方法和在新技术下所面对的“挑战”,方便大家深入理解山丘i资料 过程。本文也将分享山丘i资料 所遇到的问题和应对策略,怎么解决怎么做的问题。
通过深入本文可以理解代码原理,进行代码文档的下载,也可以查看相应 Demo 部署效果。

一、类及对象

1. 类的组成成分

  • 属性(成员变量,Field)
  • 方法(成员方法,函数,Method)

2. 属性

成员变量 vs 局部变量

  • 相同点:
    • 遵循变量声明的格式: 数据类型 变量名 = 初始化值
    • 都有作用域
  • 不同点:
    • 声明的位置的不同 :成员变量:声明在类里,方法外, 局部变量:声明在方法内,方法的形参部分,代码块内
    • 成员变量的修饰符有四个:public private protected 缺省,局部变量没有修饰符,与所在的方法修饰符相同
    • 初始化值:一定会有初始化值,成员变量:如果在声明的时候,不显式的赋值,那么不同数据类型会有不同的默认初始化值。 局部变量:一定要显式的赋值。(局部变量没有默认初始化值
      • byte short int long ==>0
      • float double ==>0.0
      • char ==>空格
      • boolean ==>false
      • 引用类型变量==>null
    • 二者在内存中存放的位置不同:成员变量存在于堆空间中;局部变量:栈空间中
  • 总结:
    • 按照数据类型的不同:基本数据类型(8种) & 引用数据类型
    • 按照声明的位置的不同:成员变量 & 局部变量

3. 方法

提供某种功能的实现

    public void eat(){//方法体}     public String getName(){}     public void setName(String n){}     //格式:权限修饰符 返回值类型(void:无返回值/具体的返回值) 方法名(形参){} 
  • 关于返回值类型
    • void:表明此方法不需要返回值
    • 有返回值的方法:在方法的最后一定有return + 返回值类型对应的变量
  • 方法内可以调用本类的其他方法或属性,但是不能在方法内再定义方法!

4. 面向对象编程的思想的落地法则一:

  • 设计并创建类及类的成分
  • 实例化类的对象
  • 通过“对象.属性”或"对象.方法"的形式完成某项功能

5. 类的初始化内存解析:内存划分的结构

  • 栈(stack):局部变量 、对象的引用名、数组的引用名
  • 堆(heap):new 出来的“东西”(如:对象的实体,数组的实体),含成员变量
  • 方法区:含字符串常量
  • 静态域:声明为static的变量

6. 万事万物皆对象

  • 在Java语言范畴中,我们都能将功能、结构等封装到类中,通过类的实体化,来调用具体的功能结构
    • Scanner、String
    • 文件:File
  • 设计到Java语言与前端Html、后端的数据库交互时,都体现为类、对象

7. 例题

/*  * 4. 对象数组题目: 定义类Student,包含三个属性:学号number(int),年级state(int),成绩score(int)。  创建20个学生对象,学号为1到20,年级和成绩都由随机数确定。 问题一:打印出3年级(state值为3)的学生信息。 问题二:使用冒泡排序按学生成绩排序,并遍历所有学生信息  提示: 1) 生成随机数:Math.random(),返回值类型double;   2) 四舍五入取整:Math.round(double d),返回值类型long。  *   *   *  // 两位数的,随机数  10 - 99   公式:【a,b】 :   Math.random()*(b-a+1)+a   再强转数据类型。  *   */ public class StudentTest { 	public static void main(String[] args) {  		// 声明Student类型的数组 		Student[] stu = new Student[20];  		for (int i = 0; i < stu.length; i++) { 			// 给数组元素赋值 			stu[i] = new Student(); 			stu[i].number = i + 1; 			// [1,6] 			stu[i].state = (int) (Math.random() * (6 - 1 + 1) + 1); 			// [0,100] 			stu[i].score = (int) (Math.random() * (100 - 0 + 1)); 		}  		StudentTest test = new StudentTest(); 		 		// 问题1 		test.searchState(stu,3); 		System.out.println("------------------------"); 		// 		// 问题2 		test.sort(stu); 		test.print(stu); 		 	}  	 	// 遍历学生数组 	public void print(Student[] stu) { 		for (int i = 0; i < stu.length; i++) { 			System.out.println(stu[i].info()); 		} 	}  	/** 	 *  	 * @Description  查找指定年纪的学生 	 * @author MD 	 * @date 2020年7月6日下午12:02:56 	 * @param stu 查找的数组 	 * @param state 指定的年纪 	 */ 	public void searchState(Student[] stu, int state) { 		for (int i = 0; i < stu.length; i++) { 			if (stu[i].state == 3) 				System.out.println(stu[i].info()); 		} 	} 	 	 	public void sort(Student[] stu) { 		for (int i = 0; i < stu.length - 1; i++) { 			for (int j = 0; j < stu.length - i - 1; j++) { 				if (stu[j].score <= stu[j + 1].score) { 					// 注意,这里交换的不是成绩而是对象 					Student temp = stu[j]; 					stu[j] = stu[j + 1]; 					stu[j + 1] = temp; 				} 			} 		} 	}  }  class Student { 	int number; 	int state; 	int score;  	public String info() { 		return "学号:" + number + " 年级:" + state + " 分数:" + score; 	}  } 

二、方法的重载(overload)

要求:
* 同一个类中
* 方法名必须相同
* 方法的参数列表不同(①参数的个数不同②参数类型不同
补充:方法的重载与方法的返回值类型没有关系!

//如下的四个方法构成重载 //定义两个int型变量的和 public int getSum(int i,int j){     return i + j; } //定义三个int型变量的和 public int getSum(int i,int j,int k){     return i + j + k; } //定义两个double型数据的和 public double getSum(double d1,double d2){     return d1 + d2; }  //定义三个double型数组的和 public void getSum(double d1,double d2,double d3){     System.out.println(d1 + d2 + d3); } //不能与如上的几个方法构成重载 //  public int getSum1(int i,int j,int k){ //      return i + j + k; //  } //  public void getSum(int i,int j,int k){ //      System.out.println(i + j + k); //  }   //以下的两个方法构成重载。 public void method1(int i,String str){      } public void method1(String str1,int j){      } 

三、可变个数的形参的方法

  • .格式:对于方法的形参: 数据类型 … 形参名
  • 可变个数的形参的方法与同名的方法之间构成重载
  • 可变个数的形参在调用时,个数从0开始,到无穷多个都可以
  • 使用可变多个形参的方法与方法的形参使用数组是一致
  • 若方法中存在可变个数的形参,那么一定要声明在方法形参的最后
  • 在一个方法中,最多声明一个可变个数的形参
//如下四个方法构成重载     //在类中一旦定义了重载的可变个数的形参的方法以后,如下的两个方法可以省略 //  public void sayHello(){ //      System.out.println("hello world!"); //  } //  public void sayHello(String str1){ //      System.out.println("hello " + str1); //  }     //可变个数的形参的方法     public void sayHello(String ... args){         for(int i = 0;i < args.length;i++){             System.out.println(args[i] + "$");         }         //System.out.println("=====");     }          public void sayHello(int i,String ... args){     //public void sayHello(String ... args,int i){         System.out.println(i);                  for(int j = 0;j < args.length;j++){             System.out.println(args[j] + "$");         }     }          public void sayHello1(String[] args){         for(int i = 0;i < args.length;i++){             System.out.println(args[i]);         }     }      

四、 Java的值传递

  • 方法的参数传递(重点、难点)
    • 形参:方法声明时,方法小括号内的参数
    • 实参:调用方法时,实际传入的参数的值
  • java中的参数传递机制:值传递机制
    • 形参是基本数据类型的:将实参的值传递给形参的基本数据类型的变量
    • 形参是引用数据类型的:将实参的引用类型变量的值(对应的堆空间的对象实体的首地址值)传递给形参的引用类型变量
  • 关于变量的赋值
    • 如果变量是基本数据类型,此时赋值的是变量所保存的数据值
    • 如果变量是引用数据类型,此时赋值的变量是所保存的地址值

1. 例一

public static void main(String[] args) {     TestArgsTransfer tt = new TestArgsTransfer();          int i = 10;     int j = 5;     System.out.println("i:" + i + " j:" + j);//i : 10  j : 5      //      //交换变量i与j的值 //      int temp = i; //      i = j; //      j = temp;     tt.swap(i, j);//将i的值传递给m,j的值传递给n               System.out.println("i:" + i + " j:" + j);//i : 10  j : 5      } //定义一个方法,交换两个变量的值 public void swap(int m,int n){     int temp = m;     m = n;     n = temp;     System.out.println("m:" + m + " n:" + n);  } 

2. 例二

public class TestArgsTransfer1 {     public static void main(String[] args) {         TestArgsTransfer1 tt = new TestArgsTransfer1();         DataSwap ds = new DataSwap();                  System.out.println("ds.i:" + ds.i + " ds.j:" + ds.j);                  tt.swap(ds);         System.out.println(ds);                  System.out.println("ds.i:" + ds.i + " ds.j:" + ds.j);              }     //交换元素的值     public void swap(DataSwap d){         int temp = d.i;         d.i = d.j;         d.j = temp;         System.out.println(d);//打印引用变量d的值     } }  class DataSwap{     int i = 10;     int j = 5; } 

3. 例3

山丘i

package com.atguigu.exer;  import java.io.PrintStream;  public class Test {  	public static void main(String[] args) { 		int a = 10; 		int b = 10; 		method(a,b); 		System.out.println("a="+a); 		System.out.println("b="+b); 	} 	 //	public static void method(int a , int b) { //		a = a * 10; //		b = b * 20; //		System.out.println(a); //		System.out.println(b); //		System.exit(0); //	} 	public static void method(int a, int b) { 		PrintStream ps = new PrintStream(System.out) { 			public void println(String x){ 				if("a=10".equals(x)) { 					x = "a=100"; 				}else if("b=10".equals(x)) { 					x = "b=200"; 				} 				super.println(x); 			} 		}; 		 		System.setOut(ps); 	}  	 }  

山丘i

4. 例4

输出的什么?

public class Test1 {  	public static void main(String[] args) { 		int[] arr = new int[] {1,2,3}; 		System.out.println(arr); //地址值 		 		char[] arr1 = new char[] {'a','b','c'}; 		System.out.println(arr1); //abc 	} }  

五、面向对象的特征一:封装

  • 问题:当创建了类的对象以后,如果直接通过"对象.属性"的方式对相应的对象属性赋值的话,可能会出现不满足实际情况的意外,我们考虑不让对象来直接作用属性,而是通过"对象.方法"的形式,来控制对象对属性的访问。实际情况中,对属性的要求就可以通过方法来体现
  • 高内聚,低耦合
  • 面向对象思想的落地法则二:
    • 将类的属性私有化
    • 提供公共的方法(setter & getter)来实现调用
  • 四种权限修饰符
    • 权限从大到小为:public protected 缺省 private
    • 四种权限都可以用来修饰属性、方法、构造器
    • 修饰类的话:public 缺省

山丘i

  • 封装性的体现
    • 将类的属性私有化,提供公共的方法来调用
    • 不对外暴露的私有化方法
    • 单例模式

1. 构造器

构造器的作用:①创建对象 ②给创建的对象的属性赋值

  • 设计类时,若不显式声明类的构造器的话,程序会默认提供一个空参的构造器
  • 一旦显式的定义类的构造器,那么默认的构造器就不再提供
  • 如何声明类的构造器。格式:权限修饰符 类名(形参){ }
  • 类的多个构造器之间构成重载
  • 类对象的属性赋值的先后顺序:
    • 属性的默认初始化
    • 属性的显式初始化
    • 通过构造器给属性初始化
    • 通过"对象.方法"的方式给属性赋值
  • 一个类中至少会有一个构造器,一般都提供一个空参的构造器

2. this关键字

  • 使用在类中,可以用来修饰属性、方法、构造器
  • 表示当前对象或者是当前正在创建的对象
  • 当形参与成员变量重名时,如果在方法内部需要使用成员变量,必须添加this来表明该变量时类成员
  • 在任意方法内,如果使用当前类的成员变量或成员方法可以在其前面添加this,增强程序的阅读性
  • 在构造器中使用“this(形参列表)”显式的调用本类中重载的其它的构造器,要求“this(形参列表)”要声明在构造器的首行!
public class TestPerson {     public static void main(String[] args) {         Person p1 = new Person();         System.out.println(p1.getName() + ":" + p1.getAge());                  Person p2 = new Person("BB",23);         int temp = p2.compare(p1);         System.out.println(temp);     } } class Person{          private String name;     private int age;          public Person(){         this.name = "AA";         this.age = 1;     }          public Person(String name){         this(); // 先调用空参数的         this.name = name;     }     public Person(String name,int age){         this(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;     }     public void eat(){         System.out.println("eating");     }     public void sleep(){         System.out.println("sleeping");         this.eat();     }     //比较当前对象与形参的对象的age谁大。     public int compare(Person p){         if(this.age > p.age)             return 1;         else if(this.age < p.age)             return -1;         else             return 0;     }      } 

3. package/import

package: 声明源文件所在的包,写在程序的第一行
import:

  • 显式导入指定包下的类或接口
  • 写在包的声明和源文件之间
  • 如果需要引入多个类或接口,那么就并列写出
  • 如果导入的类是java.lang包下的,如:System String Math等,就不需要显式的声明
  • 理解.*的概念。比如java.util. *;
  • 导入java.lang.*只能导入lang包下的所有类或接口,不能导入lang的子包下的类或接口
  • import static 表示导入指定类的static的属性或方法
/import java.util.Scanner; //import java.util.Date; //import java.util.List; //import java.util.ArrayList; import java.lang.reflect.Field; import java.util.*; import static java.lang.System.*; public class TestPackageImport {     public static void main(String[] args) {         out.println("helloworld");         Scanner s = new Scanner(System.in);         s.next();                  Date d = new Date();         List list = new ArrayList();                  java.sql.Date d1 = new java.sql.Date(522535114234L);                  Field f = null;     } }  

六、面向对象的特征二:继承

  1. 继承的格式
    • 通过"class A extends B"类实现类的继承
  2. 子类继承父类以后,父类中声明的属性、方法,子类就可以获取到
    • 当父类中有私有的属性或方法时,子类同样可以获取得到,只是由于封装性的设计,使得子类不可以直接调用罢了
    • 子类除了通过继承,获取父类的结构之外,还可以定义自己的特有的成分
  3. java中类的继承性只支持单继承:一个类只能继承一个父类。反之,一个父类可以有多个子类
  4. 如果没有显示声明一个类的父类的话,则此类继承于java.lang.Object类

1. 方法的重写(override orverwrite) vs 重载(overload)

  1. 重载:“两同一不同”:同一个类,同一个方法名,不同的参数列表注:方法的重载与方法的返回值无关!构造器是可以重载的
  2. 重写:(前提:在继承的基础之上,子类在获取了父类的结构以后,可以对父类中同名的方法进行“重构”)方法的返回值,方法名,形参列表形同;权限修饰符不小于父类的同名方法;子类方法的异常类型不大于父类的;两个方法要同为static或同为非static
    • 注:不能重写父类的私有的方法
    • 父类被重写的返回值类型是A类型,那么子类重写方法的返回值类型可以是A类或者A类的子类
class Cirlce{    //求圆的面积     public double findArea(){         }   }  class Cylinder extends Circle{       //求圆柱的表面积       public double findArea(){       } } 

2. 关键字 super

  1. super,相较于关键字this,可以修饰属性、方法、构造器
  2. super修饰属性、方法:在子类的方法、构造器中,通过super.属性或者super.方法的形式,显式的调用父类的指定属性或方法。尤其是,当子类与父类有同名的属性、或方法时,调用父类中的结构的话,一定要用“super.”
  3. 通过“super(形参列表)”,显式的在子类的构造器中,调用父类指定的构造器!
  4. 任何一个类(除Object类)的构造器的首行,要么显式的调用本类中重载的其它的构造器“this(形参列表)”或显式的调用父类中指定的构造器“super(形参列表)”,要么默认的调用父类空参的构造器"super()",只能二选一
  5. 建议在设计类时,提供一个空参的构造器

3. 子类对象实例化的全过程

无论通过那个构造器创建子类对象,需要保证先初始化父类

目的:当子类继承父类后,继承父类中所有的属性和方法,因此子类必须知道父类如何为对象进行初始化

public class TestDog {     public static void main(String[] args) {         Dog d = new Dog();         d.setAge(10);         d.setName("小明");         d.setHostName("花花");          System.out.println("name:" + d.getName() + " age:" + d.getAge()                 + "hostName:" + d.getHostName());                  System.out.println(d.toString());     } }  // 生物 class Creator {     private int age;      public int getAge() {         return age;     }      public void setAge(int age) {         this.age = age;     }      public Creator() {         super();         System.out.println("this is Creator's constructor");     }  }  // 动物类 class Animal extends Creator {     private String name;      public String getName() {         return name;     }      public void setName(String name) {         this.name = name;     }      public Animal() {         super();         System.out.println("this is Animal's constructor");     }  }  // 狗 class Dog extends Animal {     private String hostName;      public String getHostName() {         return hostName;     }      public void setHostName(String hostName) {         this.hostName = hostName;     }      public Dog() {         super();         System.out.println("this is Dog's constructor");     } }  

七、 面向对象的特征三:多态

1. 多态性的表现:

①方法的重载与重写 ②子类对象的多态性

2. 使用的前提:

①要有继承关系 ②要有方法的重写

3. 格式

  • Person p = new Man();//向上转型
  • 通过父类的引用指向子类的对象实体,当调用方法时实际执行的是子类重写父类的方法

编译时,认为p是Person类型的,故只能执行Person里才有的结构,即Man里特有的结构不能够调用,子类对象的多态性,并不使用于属性。

调用方法:编译看左边,运行看右边

属性:编译和运行都看左边

package com.atguigu.java;  public class AnimalTest {  	public static void main(String[] args) { 		 		AnimalTest test = new AnimalTest(); 		// 多态性的体现 		test.func(new Dag()); 		test.func(new Cat()); 	}  	public void func(Animal an) {  // Animal an = new Dag(); 		an.eat(); 		an.shot(); 	} 	 	 //	public void func(Dag dag) { //		dag.eat(); //		dag.shot(); //	} 	 }  class Animal{ 	public void eat() { 		System.out.println("动物:吃食物"); 	} 	 	public void shot() { 		System.out.println("动物:叫"); 	} }  class Dag extends Animal{ 	public void eat() { 		System.out.println("狗吃肉"); 	} 	 	public void shot() { 		System.out.println("汪!汪"); 	} }  class Cat extends Animal{ 	public void eat() { 		System.out.println("猫吃鱼"); 	} 	 	public void shot() { 		System.out.println("喵!喵"); 	} } 

4. 关于向下转型

有了对象的多态性之后,内存中实际上是加载了子类特有的属性和方法,但是由于变量声明为父类类型,导致了编译时只能调用父类中声明的属性和方法,子类中特有的属性和方法调用不了,所以有了向下转型

  • 向下转型,使用强转符:()
  • 为了保证不报ClassCastException,最好在向下转型前,进行判断: instanceof
if (p1 instanceof Woman) {             System.out.println("hello!");             Woman w1 = (Woman) p1;             w1.shopping();   }     if (p1 instanceof Man) {         Man m1 = (Man) p1;          m1.entertainment();   } 

5. 多态是编译性行为还是运行时行为

运行时行为

package com.atguigu.java5;   import java.util.Random;  //面试题:多态是编译时行为还是运行时行为? //证明如下: class Animal  {   	protected void eat() { 		System.out.println("animal eat food"); 	} }  class Cat  extends Animal  {   	protected void eat() { 		System.out.println("cat eat fish"); 	} }  class Dog  extends Animal  {   	public void eat() { 		System.out.println("Dog eat bone"); 	} }  class Sheep  extends Animal  {  	public void eat() { 		System.out.println("Sheep eat grass"); 	} }  public class InterviewTest {  	public static Animal  getInstance(int key) { 		switch (key) { 		case 0: 			return new Cat (); 		case 1: 			return new Dog (); 		default: 			return new Sheep (); 		} 	}  	public static void main(String[] args) { 		int key = new Random().nextInt(3);  		System.out.println(key);  		Animal  animal = getInstance(key); 		 		animal.eat(); 	} }  

6. 问题1

package com.atguigu.exer; /*  * 练习:  * 1.若子类重写了父类方法,就意味着子类里定义的方法彻底覆盖了父类里的同名方法,  * 系统将不可能把父类里的方法转移到子类中:编译看左边,运行看右边  *   * 2.对于实例变量则不存在这样的现象,即使子类里定义了与父类完全相同的实例变量,  * 这个实例变量依然不可能覆盖父类中定义的实例变量:编译运行都看左边  */ class Base { 	int count = 10;  	public void display() { 		System.out.println(this.count); 	} }  class Sub extends Base { 	int count = 20;  	public void display() { 		System.out.println(this.count); 	} }  public class FieldMethodTest { 	public static void main(String[] args) { 		Sub s = new Sub(); 		System.out.println(s.count);//20 		s.display();//20 		 		Base b = s;//多态性 		//==:对于引用数据类型来讲,比较的是两个引用数据类型变量的地址值是否相同 		System.out.println(b == s);//true 		System.out.println(b.count);//10 		b.display();//20 	} }  

7. 问题2

package com.atguigu.exer;  //考查多态的笔试题目: public class InterviewTest1 {  	public static void main(String[] args) { 		Base1 base = new Sub1(); 		base.add(1, 2, 3); //sub_1  		Sub1 s = (Sub1)base; 		s.add(1,2,3); //sub_2 	} }  class Base1 { 	public void add(int a, int... arr) { 		System.out.println("base1"); 	} }  class Sub1 extends Base1 {  	public void add(int a, int[] arr) { 		System.out.println("sub_1"); 	}  	public void add(int a, int b, int c) { 		System.out.println("sub_2"); 	}  } 

山丘i资料部分资料来自网络,侵权毕设源码联系删除

区块链毕设网(www.qklbishe.com)全网最靠谱的原创区块链毕设代做网站
部分资料来自网络,侵权联系删除!
资源收费仅为搬运整理打赏费用,用户自愿支付 !
qklbishe.com区块链毕设代做网专注|以太坊fabric-计算机|java|毕业设计|代做平台 » 山丘i资料

提供最优质的资源集合

立即查看 了解详情