mkgsh的博客

package softDay9; /*内部类访问规则：将一个类定义在另个一类的里面，对里面那个类就称为内部类(内置类，嵌套类) * 内部类可以直接访问外部类的成员,包括私有 * 之所以可以直接访问外部类中的成员 是因为内部类中有一个外部类的引用格式:外部名.this.XX * 外部类如果想访问内部类，必须建立内部类对象 * * 访问格式： * 1.当内部类定义在外部类的

public class Demo2 {public static void main(String[] args){ Person p1 = new Person(20); Person p2 = new Person(30); boolean b = p1.compare(p2); System.out.println(b);}} /* 需求：给人定义一个用于

/*this :看上去是用于区分局部变量和成员变量同名的情况 *this为什么可以解决这个问题？ *this到底可以代表什么 *this：就代表本类的对象,到底代表哪一个呢？ *this代表它所在函数 所属对象的引用 相当于那个p1 *简单说 哪个对象在调用this所在的函数 this就代表哪个对象。 *哪个对象调用this，this就代表哪个对象 * */ publ

/*构造函数 对象一建立就会调用与之对应的构造初始化 *构造函数的作用 可以用于给对象初始化 * 构造函数的小细节：当一个类中没有定义构造函数时 那么系统会默认给该类加入一个空参数的函数 * 当类中自定义了构造函数后，默认的构造函数就没有了。 * * 构造函数和一般函数写法上不同 * 在运行上也不同 * 构造函数是函数一建立就运行 给对象进行初始化 * 而一般方法是

//面向对象 封装private class Person { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub Persono p = new Persono();

//封装 是对隐藏对象的属性和实现细节 仅对外提供公共访问方式 /*好处： * 讲变化隔离 * 便于使用 * 提高重用性 * 提高安全性 *封装原则： * 将不需要对外提供的内容都隐藏起来 * 把属性都隐藏起来 提供公共方法对其访问 * */ public class Encapsulate { /** * @par

public class ExampleDemo {/** * @param args */public static void main(String[] args) { // TODO Auto-generated method stub}} abstract class Student{abstract void study();void sleep(){ System

package softspractice; /*接口类 interface(); * 借口中的成员修饰符是固定的 * 成员常量：public static final * 成员变量（抽象方法）：public abstract * 接口的出现将”多继承”通过另一种形式体现出来，即 “多实现” * * 初期理解：可以认为是一个特殊的抽象类 * 当抽象

//匿名对象的应用 public class CarDemo2 {/** * @param args */public static void main(String[] args) { // TODO Auto-generated method stub /*Car c = new Car(); *c.num = 5;相当于 */ new Car(

package softspractice; /* * 需求：获取一段程序运行的时间 * 原理：获取程序开始或结束的时间相减即可 * * 获取时间：System.currentTimeMillis(); * * 当代码完成优化后 就可以解决这类问题 * 这种方式，模板方法设计模式 * * 什么事模板方法设计呢？ * 在定义功能时，功能一部分是确定的，但

public class Demo2 {public static void main(String[] args){ Person p = new Person("lisan",30); Person p1 = new Person("lisi",30);}} /* this语句用于构造函数间进行互相调用 构造函数间调用只能用this this语句只能定义在构造函数的第一行

/** *多态：可以理解为事物存在的多种体现形态。 *比如人：男人 女人 * 动物：猫 狗 * 猫 x = new 猫(); * 动物 x = new 猫(); *对象的多态性 * *1,多态的基本体现 * 代码体现形式： 父类的引用指定自己的子类对象 * 父类的引用也可以引用自己的子类对象 *2,多态的前提 *必须是类与类之间有

class Fu{int num = 5;void method1(){ System.out.println("fu method_1");}void method2(){ System.out.println("fu method_2");}static void method4(){ System.out.println("fu method_4");}} c

/** * 单例设计模式调用 * 设计模式: 解决某一类问题最行之有效的方法 * java中23种设计模式 * 单例设计模式:解决一个类在内存只有一个对象 * 要保证对象唯一: * 1,为了避免其他程序过多建立该类对象，先控制禁止其他程序的建立该类对象 * 2,还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象 * 3,为

/* * 静态代码块 * 格式： * static { * * 静态代码块中的执行语句 * } * 特点：1,随着类的加载而执行，只执行一次，并优先于主函数执行 * 2,用于给类进行初始化 * */ public class StaticCodeDemo {/** * @param args */static { Syste

/** *静态的应用 * *每个应用程序中都有共性的功能 *可以讲这些功能进行抽取 独立封装 以便服用 *虽然可以通过建立Arraytool的对象使用这些工具方法 对数组进行操作 *发现了问题 *1,对象是用于封装数据的 可是ArrayTool对象并未封装特有数据 根本用不到对象 *2,操作数组的每一个方法都没有用到ArrayTool对象中的特有数据 * *

/* * Object ：是所有对象的直接后者简介父类 传说中的上帝 超类 * 该类定义的肯定是所有对象都具备的功能 * java认为所有对象都可以进行比较 比较的是内存地址 * * Object类中已经提供了对对象是否相同的比较方法 * * 如果自定义类中有比较相同的方法 没有必要重新定义 * 只要沿袭父类中的功能 建立自己持有比较内容即可 这就是覆盖 *

/** *什么时候使用static静态？ * *要从两方面下手 *因为静态修饰的内容有成员变量和函数 *什么时候定义静态变量(类变量)呢？ *当对象中出现共享数据时,该数据被静态所修饰 *对象中特有数据要定义成非静态存于堆内存中 *什么时候定义静态的函数呢？ *当功能内部没有访问到非静态数据(对象的特有数据)， *那么该功能可以定义成静态的。 * */

/** * public static void main(String[] args) * { * 主函数：是一个特殊的函数 作为程序的入口 可以被jvm调用 * 主函数的定义： * public：代表着该函数的权限是最大的 * static：代表着主函数随着类的加载就已经存在了 * void：主函数没有具体的返回值 * main：非关键字 但是是一个特殊的单词 可

/** * 静态：static * 用法 是一个修饰符 用于修饰变量(成员变量 成员函数) * 当成员被静态修饰后 就多了一个调用方式 除了可以被对象调用外 还 * 可以直接被类名调用。写法格式是 类名.静态成员 * —————————— * 存在于： 方法区 共享区 数据区 * —————————— * static的特点 * 1,随着类的加载而加载 *

/** * 需求：数据库的操作。 * 数据： 用户信息 * 1,连接数据库 * JDBC HIbernate框架链接 * 2,操作数据库 * c create r read u update d delete * 3,关闭数据库的<连接> * */ //伪代码 interface UserInfoDao{/*public void add(Use

/** * 需求： * 电脑运行实例 * 电脑运行基于主板 * */ public class DuoTaiDemo6 {/** * @param args */public static void main(String[] args) { // TODO Auto-generated method stub MainBoard mb = new MainBo

package softspractice; /** * 我们在开发一个系统时需要对员工进行建模 员工包含三个属性 * 姓名 工号 工资 进行建模 员工包含 3 个属性 * 另外一个特殊属性:奖金属性 利用继承思想设计出员工类和经理类 * 要求类中提供必要的方法属性进行属性访问 * * 员工类 name id pay * 经理类 继承了员工，并有自己特有的bon

//常见操作—-获取数组中的最大值和最小值 public class ArrayTest {/** * @param args */public static void main(String[] args) { // TODO Auto-generated method stub /* * 获取数组最大值 * 思路： * 1,获取最值需要进行比较，每一

public class ArrayDemo3 {/** * @param args */public static void main(String[] args) { // TODO Auto-generated method stub //数组的操作 //获取数组中的元素 通常会用到遍历 //int[] arr = new int[3]; //数组中国

package Day; //定义一个功能 用于打印矩形public class Day4 {/** * @param args */public static void main(String[] args) { // TODO Auto-generated method stub draw(7,9); printHr(); draw(7,9); pr

package Day; /*数组和内存结构 * 数组 同一种类型数据的集合 其实数组就是一个容器 就是用来装东西 * 数组的好处 可以自动给数组中的元素从0开始编号 方便操作这些元素 *他可以自动给存的东西进行编号 * 想定义一个可以存储三个整数的容器 * * 元素类型[] 数组名 = new 元素类型[元素个数或者数组长度]; * 需求

//语句嵌套形式 语句之中包含语句//嵌套循环 public class Cat {public static void main(String[] args){ //int z = 5; for(int x=5;x>0;x–) { for(int y=0;y

package Day; //函数的重载 //同一个类中，同名不同参 //定义一个加法运算 获取两个整数的和 //当定义的功能相同时 但参与的运算的未知内容不同 那么 这时就定义一个函数名称以表示其功能 方便阅读 //而通过参数列表的不同来区分多个同名函数 这就是重载 public class Day4a {/** * @param args */public static vo

package Day; //练习 等腰三角形 public class Day2 {/** * @param args */public static void main(String[] args) { // TODO Auto-generated method stub for(int x=0;x<5;x++){ for(int y=x;y<5;y++)

package Day;public class Day1 {/** * @param args */public static void main(String[] args) { // TODO Auto-generated method stub// for(int x=0;x<3;x++){ // // System.out.println(“x=”+

//给指定数进行排序 选择比较 //{5,1,6,4,2,8,9} /**排序思想: * 0 1 2 3 4 5 下角标 * 3 1 4 2 7 5 数组元素 * 使用嵌套循环 * 内循环结束一次 最止出现在头角标位置上 * */ import java.util.*; public class ArrayTest2{public

//数组的查找操作 折半查找 public class ArrayTest4 {/** * @param args */public static void main(String[] args) { // TODO Auto-generated method stub int[] arr = {2,3,4,5,6}; //int index = getIndex

//十进制转化为二进制 public abstract class ArrayTest5 {/** * @param args */public static void main(String[] args) { // TODO Auto-generated method stub toBin(6);}/*十进制转化为二进制*/public static void toBi

package softstudy; /*抽象类 * 当多个类中出现相同的功能 但功能主体不同 * 这时可以进行向上抽取 这时只抽取功能定义 不抽取功能主体。 * abstract 笼统的 抽象的 看不懂的方法 * abstract方法必须存在abstract类中 你不能创建一个看不懂的类的对象 * * 就是看不懂 * 抽象类的特点： * 1,抽象方法一定

/*final：最终; * 1,可以修饰：类,函数,变量 * 2,被final修饰的类不可以被继承，为了避免被继承，被子类复写(覆盖)功能 * 3,被final修饰的方法不可以被复写 * 4,被final修饰的变量是一个常量只能赋值一次 既可以修饰成员变量 又可以修饰局部变量 * 当在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性 都给这些值起个名字 方便于阅读

package softstudy; /*3,子父类中的构造函数 * 在对子类对象进行初始化时 父类的构造函数也会运行 * 那是因为子类的构造函数默认第一行有一条隐式的语句 super(); * super();会访问空参数的构造函数 而且子类中所有的构造函数默认第一行都是super(); * * 为什么子类一定要访问父类中的构造函数? * 因为父类中的数据子类可以直接获

package softstudy; /*super关键字 * 子父类出现后 类成员的特点： * * 类中成员： * 1,变量 * 2,函数 * 3,构造函数 * * 1,变量 * 如果子类中出现私有的同名成员变量时 * 子类要访问本类中的变量 用this * 子类要访问父类中的同名变量 用super * * super和this的使用几乎

package softstudy; /* * 将学生和工人的共性描述提取出来 单独进行描述 * 只要让学生和工人与单独描述的这个类 就可以了 * * 继承(extends)： * 1,提高了代码的复用性 * 2,让类与类之间产生了关系 有了这个关系 才有了多态的特性 * * 比如 B extends A A就是猫科 B就是老虎 B有A所有特性 *

/** * 对象是方法被调用时，才初始化，也叫做对象的延时加载，成为:懒汉式。 * * */ public class SingleDemo2 {/** * @param args */public static void main(String[] args) { // TODO Auto-generated method stub}} /* * 懒汉式：延迟